diff --git a/src/main/java/de/dhbwstuttgart/parser/antlr/Java8BaseListener.java b/src/main/java/de/dhbwstuttgart/parser/antlr/Java8BaseListener.java index 1c94febc..644786ac 100644 --- a/src/main/java/de/dhbwstuttgart/parser/antlr/Java8BaseListener.java +++ b/src/main/java/de/dhbwstuttgart/parser/antlr/Java8BaseListener.java @@ -1,4 +1,4 @@ -// Generated from Java8.g4 by ANTLR 4.7 +// Generated from Java8.g4 by ANTLR 4.8 package de.dhbwstuttgart.parser.antlr; import org.antlr.v4.runtime.ParserRuleContext; diff --git a/src/main/java/de/dhbwstuttgart/parser/antlr/Java8Lexer.java b/src/main/java/de/dhbwstuttgart/parser/antlr/Java8Lexer.java index 9c2e22c4..c346153e 100644 --- a/src/main/java/de/dhbwstuttgart/parser/antlr/Java8Lexer.java +++ b/src/main/java/de/dhbwstuttgart/parser/antlr/Java8Lexer.java @@ -1,4 +1,4 @@ -// Generated from Java8.g4 by ANTLR 4.7 +// Generated from Java8.g4 by ANTLR 4.8 package de.dhbwstuttgart.parser.antlr; import org.antlr.v4.runtime.Lexer; import org.antlr.v4.runtime.CharStream; @@ -11,7 +11,7 @@ import org.antlr.v4.runtime.misc.*; @SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"}) public class Java8Lexer extends Lexer { - static { RuntimeMetaData.checkVersion("4.7", RuntimeMetaData.VERSION); } + static { RuntimeMetaData.checkVersion("4.8", RuntimeMetaData.VERSION); } protected static final DFA[] _decisionToDFA; protected static final PredictionContextCache _sharedContextCache = @@ -42,68 +42,79 @@ public class Java8Lexer extends Lexer { "DEFAULT_MODE" }; - public static final String[] ruleNames = { - "T__0", "ABSTRACT", "ASSERT", "BOOLEAN", "BREAK", "BYTE", "CASE", "CATCH", - "CHAR", "CLASS", "CONST", "CONTINUE", "DEFAULT", "DO", "DOUBLE", "ELSE", - "ENUM", "EXTENDS", "FINAL", "FINALLY", "FLOAT", "FOR", "IF", "GOTO", "IMPLEMENTS", - "IMPORT", "INSTANCEOF", "INT", "INTERFACE", "LONG", "NATIVE", "NEW", "PACKAGE", - "PRIVATE", "PROTECTED", "PUBLIC", "RETURN", "SHORT", "STATIC", "STRICTFP", - "SUPER", "SWITCH", "SYNCHRONIZED", "THIS", "THROW", "THROWS", "TRANSIENT", - "TRY", "VOID", "VOLATILE", "WHILE", "IntegerLiteral", "DecimalIntegerLiteral", - "HexIntegerLiteral", "OctalIntegerLiteral", "BinaryIntegerLiteral", "IntegerTypeSuffix", - "DecimalNumeral", "Digits", "Digit", "NonZeroDigit", "DigitsAndUnderscores", - "DigitOrUnderscore", "Underscores", "HexNumeral", "HexDigits", "HexDigit", - "HexDigitsAndUnderscores", "HexDigitOrUnderscore", "OctalNumeral", "OctalDigits", - "OctalDigit", "OctalDigitsAndUnderscores", "OctalDigitOrUnderscore", "BinaryNumeral", - "BinaryDigits", "BinaryDigit", "BinaryDigitsAndUnderscores", "BinaryDigitOrUnderscore", - "FloatingPointLiteral", "DecimalFloatingPointLiteral", "ExponentPart", - "ExponentIndicator", "SignedInteger", "Sign", "FloatTypeSuffix", "HexadecimalFloatingPointLiteral", - "HexSignificand", "BinaryExponent", "BinaryExponentIndicator", "BooleanLiteral", - "CharacterLiteral", "SingleCharacter", "StringLiteral", "StringCharacters", - "StringCharacter", "EscapeSequence", "OctalEscape", "ZeroToThree", "UnicodeEscape", - "NullLiteral", "LPAREN", "RPAREN", "LBRACE", "RBRACE", "LBRACK", "RBRACK", - "SEMI", "COMMA", "DOT", "ASSIGN", "GT", "LT", "BANG", "TILDE", "QUESTION", - "COLON", "EQUAL", "LE", "GE", "NOTEQUAL", "AND", "OR", "INC", "DEC", "ADD", - "SUB", "MUL", "DIV", "BITAND", "BITOR", "CARET", "MOD", "ARROW", "COLONCOLON", - "ADD_ASSIGN", "SUB_ASSIGN", "MUL_ASSIGN", "DIV_ASSIGN", "AND_ASSIGN", - "OR_ASSIGN", "XOR_ASSIGN", "MOD_ASSIGN", "LSHIFT_ASSIGN", "RSHIFT_ASSIGN", - "URSHIFT_ASSIGN", "Identifier", "JavaLetter", "JavaLetterOrDigit", "AT", - "ELLIPSIS", "WS", "COMMENT", "LINE_COMMENT" - }; + private static String[] makeRuleNames() { + return new String[] { + "T__0", "ABSTRACT", "ASSERT", "BOOLEAN", "BREAK", "BYTE", "CASE", "CATCH", + "CHAR", "CLASS", "CONST", "CONTINUE", "DEFAULT", "DO", "DOUBLE", "ELSE", + "ENUM", "EXTENDS", "FINAL", "FINALLY", "FLOAT", "FOR", "IF", "GOTO", + "IMPLEMENTS", "IMPORT", "INSTANCEOF", "INT", "INTERFACE", "LONG", "NATIVE", + "NEW", "PACKAGE", "PRIVATE", "PROTECTED", "PUBLIC", "RETURN", "SHORT", + "STATIC", "STRICTFP", "SUPER", "SWITCH", "SYNCHRONIZED", "THIS", "THROW", + "THROWS", "TRANSIENT", "TRY", "VOID", "VOLATILE", "WHILE", "IntegerLiteral", + "DecimalIntegerLiteral", "HexIntegerLiteral", "OctalIntegerLiteral", + "BinaryIntegerLiteral", "IntegerTypeSuffix", "DecimalNumeral", "Digits", + "Digit", "NonZeroDigit", "DigitsAndUnderscores", "DigitOrUnderscore", + "Underscores", "HexNumeral", "HexDigits", "HexDigit", "HexDigitsAndUnderscores", + "HexDigitOrUnderscore", "OctalNumeral", "OctalDigits", "OctalDigit", + "OctalDigitsAndUnderscores", "OctalDigitOrUnderscore", "BinaryNumeral", + "BinaryDigits", "BinaryDigit", "BinaryDigitsAndUnderscores", "BinaryDigitOrUnderscore", + "FloatingPointLiteral", "DecimalFloatingPointLiteral", "ExponentPart", + "ExponentIndicator", "SignedInteger", "Sign", "FloatTypeSuffix", "HexadecimalFloatingPointLiteral", + "HexSignificand", "BinaryExponent", "BinaryExponentIndicator", "BooleanLiteral", + "CharacterLiteral", "SingleCharacter", "StringLiteral", "StringCharacters", + "StringCharacter", "EscapeSequence", "OctalEscape", "ZeroToThree", "UnicodeEscape", + "NullLiteral", "LPAREN", "RPAREN", "LBRACE", "RBRACE", "LBRACK", "RBRACK", + "SEMI", "COMMA", "DOT", "ASSIGN", "GT", "LT", "BANG", "TILDE", "QUESTION", + "COLON", "EQUAL", "LE", "GE", "NOTEQUAL", "AND", "OR", "INC", "DEC", + "ADD", "SUB", "MUL", "DIV", "BITAND", "BITOR", "CARET", "MOD", "ARROW", + "COLONCOLON", "ADD_ASSIGN", "SUB_ASSIGN", "MUL_ASSIGN", "DIV_ASSIGN", + "AND_ASSIGN", "OR_ASSIGN", "XOR_ASSIGN", "MOD_ASSIGN", "LSHIFT_ASSIGN", + "RSHIFT_ASSIGN", "URSHIFT_ASSIGN", "Identifier", "JavaLetter", "JavaLetterOrDigit", + "AT", "ELLIPSIS", "WS", "COMMENT", "LINE_COMMENT" + }; + } + public static final String[] ruleNames = makeRuleNames(); - private static final String[] _LITERAL_NAMES = { - null, "'var'", "'abstract'", "'assert'", "'boolean'", "'break'", "'byte'", - "'case'", "'catch'", "'char'", "'class'", "'const'", "'continue'", "'default'", - "'do'", "'double'", "'else'", "'enum'", "'extends'", "'final'", "'finally'", - "'float'", "'for'", "'if'", "'goto'", "'implements'", "'import'", "'instanceof'", - "'int'", "'interface'", "'long'", "'native'", "'new'", "'package'", "'private'", - "'protected'", "'public'", "'return'", "'short'", "'static'", "'strictfp'", - "'super'", "'switch'", "'synchronized'", "'this'", "'throw'", "'throws'", - "'transient'", "'try'", "'void'", "'volatile'", "'while'", null, null, - null, null, null, "'null'", "'('", "')'", "'{'", "'}'", "'['", "']'", - "';'", "','", "'.'", "'='", "'>'", "'<'", "'!'", "'~'", "'?'", "':'", - "'=='", "'<='", "'>='", "'!='", "'&&'", "'||'", "'++'", "'--'", "'+'", - "'-'", "'*'", "'/'", "'&'", "'|'", "'^'", "'%'", "'->'", "'::'", "'+='", - "'-='", "'*='", "'/='", "'&='", "'|='", "'^='", "'%='", "'<<='", "'>>='", - "'>>>='", null, "'@'", "'...'" - }; - private static final String[] _SYMBOLIC_NAMES = { - null, null, "ABSTRACT", "ASSERT", "BOOLEAN", "BREAK", "BYTE", "CASE", - "CATCH", "CHAR", "CLASS", "CONST", "CONTINUE", "DEFAULT", "DO", "DOUBLE", - "ELSE", "ENUM", "EXTENDS", "FINAL", "FINALLY", "FLOAT", "FOR", "IF", "GOTO", - "IMPLEMENTS", "IMPORT", "INSTANCEOF", "INT", "INTERFACE", "LONG", "NATIVE", - "NEW", "PACKAGE", "PRIVATE", "PROTECTED", "PUBLIC", "RETURN", "SHORT", - "STATIC", "STRICTFP", "SUPER", "SWITCH", "SYNCHRONIZED", "THIS", "THROW", - "THROWS", "TRANSIENT", "TRY", "VOID", "VOLATILE", "WHILE", "IntegerLiteral", - "FloatingPointLiteral", "BooleanLiteral", "CharacterLiteral", "StringLiteral", - "NullLiteral", "LPAREN", "RPAREN", "LBRACE", "RBRACE", "LBRACK", "RBRACK", - "SEMI", "COMMA", "DOT", "ASSIGN", "GT", "LT", "BANG", "TILDE", "QUESTION", - "COLON", "EQUAL", "LE", "GE", "NOTEQUAL", "AND", "OR", "INC", "DEC", "ADD", - "SUB", "MUL", "DIV", "BITAND", "BITOR", "CARET", "MOD", "ARROW", "COLONCOLON", - "ADD_ASSIGN", "SUB_ASSIGN", "MUL_ASSIGN", "DIV_ASSIGN", "AND_ASSIGN", - "OR_ASSIGN", "XOR_ASSIGN", "MOD_ASSIGN", "LSHIFT_ASSIGN", "RSHIFT_ASSIGN", - "URSHIFT_ASSIGN", "Identifier", "AT", "ELLIPSIS", "WS", "COMMENT", "LINE_COMMENT" - }; + private static String[] makeLiteralNames() { + return new String[] { + null, "'var'", "'abstract'", "'assert'", "'boolean'", "'break'", "'byte'", + "'case'", "'catch'", "'char'", "'class'", "'const'", "'continue'", "'default'", + "'do'", "'double'", "'else'", "'enum'", "'extends'", "'final'", "'finally'", + "'float'", "'for'", "'if'", "'goto'", "'implements'", "'import'", "'instanceof'", + "'int'", "'interface'", "'long'", "'native'", "'new'", "'package'", "'private'", + "'protected'", "'public'", "'return'", "'short'", "'static'", "'strictfp'", + "'super'", "'switch'", "'synchronized'", "'this'", "'throw'", "'throws'", + "'transient'", "'try'", "'void'", "'volatile'", "'while'", null, null, + null, null, null, "'null'", "'('", "')'", "'{'", "'}'", "'['", "']'", + "';'", "','", "'.'", "'='", "'>'", "'<'", "'!'", "'~'", "'?'", "':'", + "'=='", "'<='", "'>='", "'!='", "'&&'", "'||'", "'++'", "'--'", "'+'", + "'-'", "'*'", "'/'", "'&'", "'|'", "'^'", "'%'", "'->'", "'::'", "'+='", + "'-='", "'*='", "'/='", "'&='", "'|='", "'^='", "'%='", "'<<='", "'>>='", + "'>>>='", null, "'@'", "'...'" + }; + } + private static final String[] _LITERAL_NAMES = makeLiteralNames(); + private static String[] makeSymbolicNames() { + return new String[] { + null, null, "ABSTRACT", "ASSERT", "BOOLEAN", "BREAK", "BYTE", "CASE", + "CATCH", "CHAR", "CLASS", "CONST", "CONTINUE", "DEFAULT", "DO", "DOUBLE", + "ELSE", "ENUM", "EXTENDS", "FINAL", "FINALLY", "FLOAT", "FOR", "IF", + "GOTO", "IMPLEMENTS", "IMPORT", "INSTANCEOF", "INT", "INTERFACE", "LONG", + "NATIVE", "NEW", "PACKAGE", "PRIVATE", "PROTECTED", "PUBLIC", "RETURN", + "SHORT", "STATIC", "STRICTFP", "SUPER", "SWITCH", "SYNCHRONIZED", "THIS", + "THROW", "THROWS", "TRANSIENT", "TRY", "VOID", "VOLATILE", "WHILE", "IntegerLiteral", + "FloatingPointLiteral", "BooleanLiteral", "CharacterLiteral", "StringLiteral", + "NullLiteral", "LPAREN", "RPAREN", "LBRACE", "RBRACE", "LBRACK", "RBRACK", + "SEMI", "COMMA", "DOT", "ASSIGN", "GT", "LT", "BANG", "TILDE", "QUESTION", + "COLON", "EQUAL", "LE", "GE", "NOTEQUAL", "AND", "OR", "INC", "DEC", + "ADD", "SUB", "MUL", "DIV", "BITAND", "BITOR", "CARET", "MOD", "ARROW", + "COLONCOLON", "ADD_ASSIGN", "SUB_ASSIGN", "MUL_ASSIGN", "DIV_ASSIGN", + "AND_ASSIGN", "OR_ASSIGN", "XOR_ASSIGN", "MOD_ASSIGN", "LSHIFT_ASSIGN", + "RSHIFT_ASSIGN", "URSHIFT_ASSIGN", "Identifier", "AT", "ELLIPSIS", "WS", + "COMMENT", "LINE_COMMENT" + }; + } + private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); /** diff --git a/src/main/java/de/dhbwstuttgart/parser/antlr/Java8Listener.java b/src/main/java/de/dhbwstuttgart/parser/antlr/Java8Listener.java index a875c96f..88b4f7e7 100644 --- a/src/main/java/de/dhbwstuttgart/parser/antlr/Java8Listener.java +++ b/src/main/java/de/dhbwstuttgart/parser/antlr/Java8Listener.java @@ -1,4 +1,4 @@ -// Generated from Java8.g4 by ANTLR 4.7 +// Generated from Java8.g4 by ANTLR 4.8 package de.dhbwstuttgart.parser.antlr; import org.antlr.v4.runtime.tree.ParseTreeListener; diff --git a/src/main/java/de/dhbwstuttgart/parser/antlr/Java8Parser.java b/src/main/java/de/dhbwstuttgart/parser/antlr/Java8Parser.java index 398dd5f8..2d2fdd46 100644 --- a/src/main/java/de/dhbwstuttgart/parser/antlr/Java8Parser.java +++ b/src/main/java/de/dhbwstuttgart/parser/antlr/Java8Parser.java @@ -1,4 +1,4 @@ -// Generated from Java8.g4 by ANTLR 4.7 +// Generated from Java8.g4 by ANTLR 4.8 package de.dhbwstuttgart.parser.antlr; import org.antlr.v4.runtime.atn.*; import org.antlr.v4.runtime.dfa.DFA; @@ -11,7 +11,7 @@ import java.util.ArrayList; @SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"}) public class Java8Parser extends Parser { - static { RuntimeMetaData.checkVersion("4.7", RuntimeMetaData.VERSION); } + static { RuntimeMetaData.checkVersion("4.8", RuntimeMetaData.VERSION); } protected static final DFA[] _decisionToDFA; protected static final PredictionContextCache _sharedContextCache = @@ -122,108 +122,119 @@ public class Java8Parser extends Parser { RULE_postfixExpression = 232, RULE_postIncrementExpression = 233, RULE_postIncrementExpression_lf_postfixExpression = 234, RULE_postDecrementExpression = 235, RULE_postDecrementExpression_lf_postfixExpression = 236, RULE_castExpression = 237; - public static final String[] ruleNames = { - "literal", "type", "primitiveType", "numericType", "integralType", "floatingPointType", - "referenceType", "classOrInterfaceType", "classType", "classType_lf_classOrInterfaceType", - "classType_lfno_classOrInterfaceType", "interfaceType", "interfaceType_lf_classOrInterfaceType", - "interfaceType_lfno_classOrInterfaceType", "typeVariable", "arrayType", - "dims", "typeParameter", "typeParameterModifier", "typeBound", "additionalBound", - "typeArguments", "typeArgumentList", "typeArgument", "wildcard", "wildcardBounds", - "packageName", "typeName", "packageOrTypeName", "expressionName", "methodName", - "ambiguousName", "compilationUnit", "packageDeclaration", "packageModifier", - "importDeclaration", "singleTypeImportDeclaration", "typeImportOnDemandDeclaration", - "singleStaticImportDeclaration", "staticImportOnDemandDeclaration", "typeDeclaration", - "classDeclaration", "normalClassDeclaration", "classModifier", "typeParameters", - "typeParameterList", "superclass", "superinterfaces", "interfaceTypeList", - "classBody", "classBodyDeclaration", "classMemberDeclaration", "fieldDeclaration", - "fieldModifier", "variableDeclaratorList", "variableDeclarator", "variableDeclaratorId", - "variableInitializer", "unannType", "unannPrimitiveType", "unannReferenceType", - "unannClassOrInterfaceType", "unannClassType", "unannClassType_lf_unannClassOrInterfaceType", - "unannClassType_lfno_unannClassOrInterfaceType", "unannInterfaceType", - "unannInterfaceType_lf_unannClassOrInterfaceType", "unannInterfaceType_lfno_unannClassOrInterfaceType", - "unannTypeVariable", "unannArrayType", "methodDeclaration", "methodModifier", - "methodHeader", "result", "methodDeclarator", "formalParameterList", "formalParameters", - "formalParameter", "variableModifier", "lastFormalParameter", "receiverParameter", - "throws_", "exceptionTypeList", "exceptionType", "methodBody", "instanceInitializer", - "staticInitializer", "constructorDeclaration", "constructorModifier", - "constructorDeclarator", "simpleTypeName", "constructorBody", "explicitConstructorInvocation", - "enumDeclaration", "enumBody", "enumConstantList", "enumConstant", "enumConstantModifier", - "enumBodyDeclarations", "interfaceDeclaration", "normalInterfaceDeclaration", - "interfaceModifier", "extendsInterfaces", "interfaceBody", "interfaceMemberDeclaration", - "constantDeclaration", "constantModifier", "interfaceMethodDeclaration", - "interfaceMethodModifier", "annotationTypeDeclaration", "annotationTypeBody", - "annotationTypeMemberDeclaration", "annotationTypeElementDeclaration", - "annotationTypeElementModifier", "defaultValue", "annotation", "normalAnnotation", - "elementValuePairList", "elementValuePair", "elementValue", "elementValueArrayInitializer", - "elementValueList", "markerAnnotation", "singleElementAnnotation", "arrayInitializer", - "variableInitializerList", "block", "blockStatements", "blockStatement", - "localVariableDeclarationStatement", "unannTypeOrAuto", "localVariableDeclaration", - "statement", "statementNoShortIf", "statementWithoutTrailingSubstatement", - "emptyStatement", "labeledStatement", "labeledStatementNoShortIf", "expressionStatement", - "statementExpression", "ifThenStatement", "ifThenElseStatement", "ifThenElseStatementNoShortIf", - "assertStatement", "switchStatement", "switchBlock", "switchBlockStatementGroup", - "switchLabels", "switchLabel", "enumConstantName", "whileStatement", "whileStatementNoShortIf", - "doStatement", "forStatement", "forStatementNoShortIf", "basicForStatement", - "basicForStatementNoShortIf", "forInit", "forUpdate", "statementExpressionList", - "enhancedForStatement", "enhancedForStatementNoShortIf", "breakStatement", - "continueStatement", "returnStatement", "throwStatement", "synchronizedStatement", - "tryStatement", "catches", "catchClause", "catchFormalParameter", "catchType", - "finally_", "tryWithResourcesStatement", "resourceSpecification", "resourceList", - "resource", "primary", "primaryNoNewArray", "primaryNoNewArray_lf_arrayAccess", - "primaryNoNewArray_lfno_arrayAccess", "primaryNoNewArray_lf_primary", - "primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary", "primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary", - "primaryNoNewArray_lfno_primary", "primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary", - "primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary", "classInstanceCreationExpression", - "classInstanceCreationExpression_lf_primary", "classInstanceCreationExpression_lfno_primary", - "typeArgumentsOrDiamond", "fieldAccess", "fieldAccess_lf_primary", "fieldAccess_lfno_primary", - "arrayAccess", "arrayAccess_lf_primary", "arrayAccess_lfno_primary", "methodInvocation", - "methodInvocation_lf_primary", "methodInvocation_lfno_primary", "argumentList", - "methodReference", "methodReference_lf_primary", "methodReference_lfno_primary", - "arrayCreationExpression", "dimExprs", "dimExpr", "constantExpression", - "expression", "lambdaExpression", "lambdaParameters", "inferredFormalParameterList", - "lambdaBody", "assignmentExpression", "assignment", "leftHandSide", "assignmentOperator", - "conditionalExpression", "conditionalOrExpression", "conditionalAndExpression", - "inclusiveOrExpression", "exclusiveOrExpression", "andExpression", "equalityExpression", - "relationalExpression", "shiftExpression", "additiveExpression", "multiplicativeExpression", - "unaryExpression", "preIncrementExpression", "preDecrementExpression", - "unaryExpressionNotPlusMinus", "postfixExpression", "postIncrementExpression", - "postIncrementExpression_lf_postfixExpression", "postDecrementExpression", - "postDecrementExpression_lf_postfixExpression", "castExpression" - }; + private static String[] makeRuleNames() { + return new String[] { + "literal", "type", "primitiveType", "numericType", "integralType", "floatingPointType", + "referenceType", "classOrInterfaceType", "classType", "classType_lf_classOrInterfaceType", + "classType_lfno_classOrInterfaceType", "interfaceType", "interfaceType_lf_classOrInterfaceType", + "interfaceType_lfno_classOrInterfaceType", "typeVariable", "arrayType", + "dims", "typeParameter", "typeParameterModifier", "typeBound", "additionalBound", + "typeArguments", "typeArgumentList", "typeArgument", "wildcard", "wildcardBounds", + "packageName", "typeName", "packageOrTypeName", "expressionName", "methodName", + "ambiguousName", "compilationUnit", "packageDeclaration", "packageModifier", + "importDeclaration", "singleTypeImportDeclaration", "typeImportOnDemandDeclaration", + "singleStaticImportDeclaration", "staticImportOnDemandDeclaration", "typeDeclaration", + "classDeclaration", "normalClassDeclaration", "classModifier", "typeParameters", + "typeParameterList", "superclass", "superinterfaces", "interfaceTypeList", + "classBody", "classBodyDeclaration", "classMemberDeclaration", "fieldDeclaration", + "fieldModifier", "variableDeclaratorList", "variableDeclarator", "variableDeclaratorId", + "variableInitializer", "unannType", "unannPrimitiveType", "unannReferenceType", + "unannClassOrInterfaceType", "unannClassType", "unannClassType_lf_unannClassOrInterfaceType", + "unannClassType_lfno_unannClassOrInterfaceType", "unannInterfaceType", + "unannInterfaceType_lf_unannClassOrInterfaceType", "unannInterfaceType_lfno_unannClassOrInterfaceType", + "unannTypeVariable", "unannArrayType", "methodDeclaration", "methodModifier", + "methodHeader", "result", "methodDeclarator", "formalParameterList", + "formalParameters", "formalParameter", "variableModifier", "lastFormalParameter", + "receiverParameter", "throws_", "exceptionTypeList", "exceptionType", + "methodBody", "instanceInitializer", "staticInitializer", "constructorDeclaration", + "constructorModifier", "constructorDeclarator", "simpleTypeName", "constructorBody", + "explicitConstructorInvocation", "enumDeclaration", "enumBody", "enumConstantList", + "enumConstant", "enumConstantModifier", "enumBodyDeclarations", "interfaceDeclaration", + "normalInterfaceDeclaration", "interfaceModifier", "extendsInterfaces", + "interfaceBody", "interfaceMemberDeclaration", "constantDeclaration", + "constantModifier", "interfaceMethodDeclaration", "interfaceMethodModifier", + "annotationTypeDeclaration", "annotationTypeBody", "annotationTypeMemberDeclaration", + "annotationTypeElementDeclaration", "annotationTypeElementModifier", + "defaultValue", "annotation", "normalAnnotation", "elementValuePairList", + "elementValuePair", "elementValue", "elementValueArrayInitializer", "elementValueList", + "markerAnnotation", "singleElementAnnotation", "arrayInitializer", "variableInitializerList", + "block", "blockStatements", "blockStatement", "localVariableDeclarationStatement", + "unannTypeOrAuto", "localVariableDeclaration", "statement", "statementNoShortIf", + "statementWithoutTrailingSubstatement", "emptyStatement", "labeledStatement", + "labeledStatementNoShortIf", "expressionStatement", "statementExpression", + "ifThenStatement", "ifThenElseStatement", "ifThenElseStatementNoShortIf", + "assertStatement", "switchStatement", "switchBlock", "switchBlockStatementGroup", + "switchLabels", "switchLabel", "enumConstantName", "whileStatement", + "whileStatementNoShortIf", "doStatement", "forStatement", "forStatementNoShortIf", + "basicForStatement", "basicForStatementNoShortIf", "forInit", "forUpdate", + "statementExpressionList", "enhancedForStatement", "enhancedForStatementNoShortIf", + "breakStatement", "continueStatement", "returnStatement", "throwStatement", + "synchronizedStatement", "tryStatement", "catches", "catchClause", "catchFormalParameter", + "catchType", "finally_", "tryWithResourcesStatement", "resourceSpecification", + "resourceList", "resource", "primary", "primaryNoNewArray", "primaryNoNewArray_lf_arrayAccess", + "primaryNoNewArray_lfno_arrayAccess", "primaryNoNewArray_lf_primary", + "primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary", "primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary", + "primaryNoNewArray_lfno_primary", "primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary", + "primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary", "classInstanceCreationExpression", + "classInstanceCreationExpression_lf_primary", "classInstanceCreationExpression_lfno_primary", + "typeArgumentsOrDiamond", "fieldAccess", "fieldAccess_lf_primary", "fieldAccess_lfno_primary", + "arrayAccess", "arrayAccess_lf_primary", "arrayAccess_lfno_primary", + "methodInvocation", "methodInvocation_lf_primary", "methodInvocation_lfno_primary", + "argumentList", "methodReference", "methodReference_lf_primary", "methodReference_lfno_primary", + "arrayCreationExpression", "dimExprs", "dimExpr", "constantExpression", + "expression", "lambdaExpression", "lambdaParameters", "inferredFormalParameterList", + "lambdaBody", "assignmentExpression", "assignment", "leftHandSide", "assignmentOperator", + "conditionalExpression", "conditionalOrExpression", "conditionalAndExpression", + "inclusiveOrExpression", "exclusiveOrExpression", "andExpression", "equalityExpression", + "relationalExpression", "shiftExpression", "additiveExpression", "multiplicativeExpression", + "unaryExpression", "preIncrementExpression", "preDecrementExpression", + "unaryExpressionNotPlusMinus", "postfixExpression", "postIncrementExpression", + "postIncrementExpression_lf_postfixExpression", "postDecrementExpression", + "postDecrementExpression_lf_postfixExpression", "castExpression" + }; + } + public static final String[] ruleNames = makeRuleNames(); - private static final String[] _LITERAL_NAMES = { - null, "'var'", "'abstract'", "'assert'", "'boolean'", "'break'", "'byte'", - "'case'", "'catch'", "'char'", "'class'", "'const'", "'continue'", "'default'", - "'do'", "'double'", "'else'", "'enum'", "'extends'", "'final'", "'finally'", - "'float'", "'for'", "'if'", "'goto'", "'implements'", "'import'", "'instanceof'", - "'int'", "'interface'", "'long'", "'native'", "'new'", "'package'", "'private'", - "'protected'", "'public'", "'return'", "'short'", "'static'", "'strictfp'", - "'super'", "'switch'", "'synchronized'", "'this'", "'throw'", "'throws'", - "'transient'", "'try'", "'void'", "'volatile'", "'while'", null, null, - null, null, null, "'null'", "'('", "')'", "'{'", "'}'", "'['", "']'", - "';'", "','", "'.'", "'='", "'>'", "'<'", "'!'", "'~'", "'?'", "':'", - "'=='", "'<='", "'>='", "'!='", "'&&'", "'||'", "'++'", "'--'", "'+'", - "'-'", "'*'", "'/'", "'&'", "'|'", "'^'", "'%'", "'->'", "'::'", "'+='", - "'-='", "'*='", "'/='", "'&='", "'|='", "'^='", "'%='", "'<<='", "'>>='", - "'>>>='", null, "'@'", "'...'" - }; - private static final String[] _SYMBOLIC_NAMES = { - null, null, "ABSTRACT", "ASSERT", "BOOLEAN", "BREAK", "BYTE", "CASE", - "CATCH", "CHAR", "CLASS", "CONST", "CONTINUE", "DEFAULT", "DO", "DOUBLE", - "ELSE", "ENUM", "EXTENDS", "FINAL", "FINALLY", "FLOAT", "FOR", "IF", "GOTO", - "IMPLEMENTS", "IMPORT", "INSTANCEOF", "INT", "INTERFACE", "LONG", "NATIVE", - "NEW", "PACKAGE", "PRIVATE", "PROTECTED", "PUBLIC", "RETURN", "SHORT", - "STATIC", "STRICTFP", "SUPER", "SWITCH", "SYNCHRONIZED", "THIS", "THROW", - "THROWS", "TRANSIENT", "TRY", "VOID", "VOLATILE", "WHILE", "IntegerLiteral", - "FloatingPointLiteral", "BooleanLiteral", "CharacterLiteral", "StringLiteral", - "NullLiteral", "LPAREN", "RPAREN", "LBRACE", "RBRACE", "LBRACK", "RBRACK", - "SEMI", "COMMA", "DOT", "ASSIGN", "GT", "LT", "BANG", "TILDE", "QUESTION", - "COLON", "EQUAL", "LE", "GE", "NOTEQUAL", "AND", "OR", "INC", "DEC", "ADD", - "SUB", "MUL", "DIV", "BITAND", "BITOR", "CARET", "MOD", "ARROW", "COLONCOLON", - "ADD_ASSIGN", "SUB_ASSIGN", "MUL_ASSIGN", "DIV_ASSIGN", "AND_ASSIGN", - "OR_ASSIGN", "XOR_ASSIGN", "MOD_ASSIGN", "LSHIFT_ASSIGN", "RSHIFT_ASSIGN", - "URSHIFT_ASSIGN", "Identifier", "AT", "ELLIPSIS", "WS", "COMMENT", "LINE_COMMENT" - }; + private static String[] makeLiteralNames() { + return new String[] { + null, "'var'", "'abstract'", "'assert'", "'boolean'", "'break'", "'byte'", + "'case'", "'catch'", "'char'", "'class'", "'const'", "'continue'", "'default'", + "'do'", "'double'", "'else'", "'enum'", "'extends'", "'final'", "'finally'", + "'float'", "'for'", "'if'", "'goto'", "'implements'", "'import'", "'instanceof'", + "'int'", "'interface'", "'long'", "'native'", "'new'", "'package'", "'private'", + "'protected'", "'public'", "'return'", "'short'", "'static'", "'strictfp'", + "'super'", "'switch'", "'synchronized'", "'this'", "'throw'", "'throws'", + "'transient'", "'try'", "'void'", "'volatile'", "'while'", null, null, + null, null, null, "'null'", "'('", "')'", "'{'", "'}'", "'['", "']'", + "';'", "','", "'.'", "'='", "'>'", "'<'", "'!'", "'~'", "'?'", "':'", + "'=='", "'<='", "'>='", "'!='", "'&&'", "'||'", "'++'", "'--'", "'+'", + "'-'", "'*'", "'/'", "'&'", "'|'", "'^'", "'%'", "'->'", "'::'", "'+='", + "'-='", "'*='", "'/='", "'&='", "'|='", "'^='", "'%='", "'<<='", "'>>='", + "'>>>='", null, "'@'", "'...'" + }; + } + private static final String[] _LITERAL_NAMES = makeLiteralNames(); + private static String[] makeSymbolicNames() { + return new String[] { + null, null, "ABSTRACT", "ASSERT", "BOOLEAN", "BREAK", "BYTE", "CASE", + "CATCH", "CHAR", "CLASS", "CONST", "CONTINUE", "DEFAULT", "DO", "DOUBLE", + "ELSE", "ENUM", "EXTENDS", "FINAL", "FINALLY", "FLOAT", "FOR", "IF", + "GOTO", "IMPLEMENTS", "IMPORT", "INSTANCEOF", "INT", "INTERFACE", "LONG", + "NATIVE", "NEW", "PACKAGE", "PRIVATE", "PROTECTED", "PUBLIC", "RETURN", + "SHORT", "STATIC", "STRICTFP", "SUPER", "SWITCH", "SYNCHRONIZED", "THIS", + "THROW", "THROWS", "TRANSIENT", "TRY", "VOID", "VOLATILE", "WHILE", "IntegerLiteral", + "FloatingPointLiteral", "BooleanLiteral", "CharacterLiteral", "StringLiteral", + "NullLiteral", "LPAREN", "RPAREN", "LBRACE", "RBRACE", "LBRACK", "RBRACK", + "SEMI", "COMMA", "DOT", "ASSIGN", "GT", "LT", "BANG", "TILDE", "QUESTION", + "COLON", "EQUAL", "LE", "GE", "NOTEQUAL", "AND", "OR", "INC", "DEC", + "ADD", "SUB", "MUL", "DIV", "BITAND", "BITOR", "CARET", "MOD", "ARROW", + "COLONCOLON", "ADD_ASSIGN", "SUB_ASSIGN", "MUL_ASSIGN", "DIV_ASSIGN", + "AND_ASSIGN", "OR_ASSIGN", "XOR_ASSIGN", "MOD_ASSIGN", "LSHIFT_ASSIGN", + "RSHIFT_ASSIGN", "URSHIFT_ASSIGN", "Identifier", "AT", "ELLIPSIS", "WS", + "COMMENT", "LINE_COMMENT" + }; + } + private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); /** @@ -273,6 +284,7 @@ public class Java8Parser extends Parser { super(input); _interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); } + public static class LiteralContext extends ParserRuleContext { public TerminalNode IntegerLiteral() { return getToken(Java8Parser.IntegerLiteral, 0); } public TerminalNode FloatingPointLiteral() { return getToken(Java8Parser.FloatingPointLiteral, 0); } @@ -389,6 +401,7 @@ public class Java8Parser extends Parser { public AnnotationContext annotation(int i) { return getRuleContext(AnnotationContext.class,i); } + public TerminalNode BOOLEAN() { return getToken(Java8Parser.BOOLEAN, 0); } public PrimitiveTypeContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -529,6 +542,11 @@ public class Java8Parser extends Parser { } public static class IntegralTypeContext extends ParserRuleContext { + public TerminalNode BYTE() { return getToken(Java8Parser.BYTE, 0); } + public TerminalNode SHORT() { return getToken(Java8Parser.SHORT, 0); } + public TerminalNode INT() { return getToken(Java8Parser.INT, 0); } + public TerminalNode LONG() { return getToken(Java8Parser.LONG, 0); } + public TerminalNode CHAR() { return getToken(Java8Parser.CHAR, 0); } public IntegralTypeContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -574,6 +592,8 @@ public class Java8Parser extends Parser { } public static class FloatingPointTypeContext extends ParserRuleContext { + public TerminalNode FLOAT() { return getToken(Java8Parser.FLOAT, 0); } + public TerminalNode DOUBLE() { return getToken(Java8Parser.DOUBLE, 0); } public FloatingPointTypeContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -736,7 +756,7 @@ public class Java8Parser extends Parser { setState(518); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,7,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { @@ -776,6 +796,7 @@ public class Java8Parser extends Parser { public ClassOrInterfaceTypeContext classOrInterfaceType() { return getRuleContext(ClassOrInterfaceTypeContext.class,0); } + public TerminalNode DOT() { return getToken(Java8Parser.DOT, 0); } public ClassTypeContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -878,6 +899,7 @@ public class Java8Parser extends Parser { } public static class ClassType_lf_classOrInterfaceTypeContext extends ParserRuleContext { + public TerminalNode DOT() { return getToken(Java8Parser.DOT, 0); } public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } public List annotation() { return getRuleContexts(AnnotationContext.class); @@ -1271,6 +1293,14 @@ public class Java8Parser extends Parser { } public static class DimsContext extends ParserRuleContext { + public List LBRACK() { return getTokens(Java8Parser.LBRACK); } + public TerminalNode LBRACK(int i) { + return getToken(Java8Parser.LBRACK, i); + } + public List RBRACK() { return getTokens(Java8Parser.RBRACK); } + public TerminalNode RBRACK(int i) { + return getToken(Java8Parser.RBRACK, i); + } public List annotation() { return getRuleContexts(AnnotationContext.class); } @@ -1320,7 +1350,7 @@ public class Java8Parser extends Parser { setState(609); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,21,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { @@ -1473,6 +1503,7 @@ public class Java8Parser extends Parser { } public static class TypeBoundContext extends ParserRuleContext { + public TerminalNode EXTENDS() { return getToken(Java8Parser.EXTENDS, 0); } public TypeVariableContext typeVariable() { return getRuleContext(TypeVariableContext.class,0); } @@ -1553,6 +1584,7 @@ public class Java8Parser extends Parser { } public static class AdditionalBoundContext extends ParserRuleContext { + public TerminalNode BITAND() { return getToken(Java8Parser.BITAND, 0); } public InterfaceTypeContext interfaceType() { return getRuleContext(InterfaceTypeContext.class,0); } @@ -1594,9 +1626,11 @@ public class Java8Parser extends Parser { } public static class TypeArgumentsContext extends ParserRuleContext { + public TerminalNode LT() { return getToken(Java8Parser.LT, 0); } public TypeArgumentListContext typeArgumentList() { return getRuleContext(TypeArgumentListContext.class,0); } + public TerminalNode GT() { return getToken(Java8Parser.GT, 0); } public TypeArgumentsContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -1643,6 +1677,10 @@ public class Java8Parser extends Parser { public TypeArgumentContext typeArgument(int i) { return getRuleContext(TypeArgumentContext.class,i); } + public List COMMA() { return getTokens(Java8Parser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(Java8Parser.COMMA, i); + } public TypeArgumentListContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -1751,6 +1789,7 @@ public class Java8Parser extends Parser { } public static class WildcardContext extends ParserRuleContext { + public TerminalNode QUESTION() { return getToken(Java8Parser.QUESTION, 0); } public List annotation() { return getRuleContexts(AnnotationContext.class); } @@ -1821,9 +1860,11 @@ public class Java8Parser extends Parser { } public static class WildcardBoundsContext extends ParserRuleContext { + public TerminalNode EXTENDS() { return getToken(Java8Parser.EXTENDS, 0); } public ReferenceTypeContext referenceType() { return getRuleContext(ReferenceTypeContext.class,0); } + public TerminalNode SUPER() { return getToken(Java8Parser.SUPER, 0); } public WildcardBoundsContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -1883,6 +1924,7 @@ public class Java8Parser extends Parser { public PackageNameContext packageName() { return getRuleContext(PackageNameContext.class,0); } + public TerminalNode DOT() { return getToken(Java8Parser.DOT, 0); } public PackageNameContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -1920,7 +1962,7 @@ public class Java8Parser extends Parser { setState(679); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,31,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { if ( _parseListeners!=null ) triggerExitRuleEvent(); _prevctx = _localctx; @@ -1959,6 +2001,7 @@ public class Java8Parser extends Parser { public PackageOrTypeNameContext packageOrTypeName() { return getRuleContext(PackageOrTypeNameContext.class,0); } + public TerminalNode DOT() { return getToken(Java8Parser.DOT, 0); } public TypeNameContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -2016,6 +2059,7 @@ public class Java8Parser extends Parser { public PackageOrTypeNameContext packageOrTypeName() { return getRuleContext(PackageOrTypeNameContext.class,0); } + public TerminalNode DOT() { return getToken(Java8Parser.DOT, 0); } public PackageOrTypeNameContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -2053,7 +2097,7 @@ public class Java8Parser extends Parser { setState(697); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,33,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { if ( _parseListeners!=null ) triggerExitRuleEvent(); _prevctx = _localctx; @@ -2092,6 +2136,7 @@ public class Java8Parser extends Parser { public AmbiguousNameContext ambiguousName() { return getRuleContext(AmbiguousNameContext.class,0); } + public TerminalNode DOT() { return getToken(Java8Parser.DOT, 0); } public ExpressionNameContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -2186,6 +2231,7 @@ public class Java8Parser extends Parser { public AmbiguousNameContext ambiguousName() { return getRuleContext(AmbiguousNameContext.class,0); } + public TerminalNode DOT() { return getToken(Java8Parser.DOT, 0); } public AmbiguousNameContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -2223,7 +2269,7 @@ public class Java8Parser extends Parser { setState(717); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,35,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { if ( _parseListeners!=null ) triggerExitRuleEvent(); _prevctx = _localctx; @@ -2349,16 +2395,22 @@ public class Java8Parser extends Parser { } public static class PackageDeclarationContext extends ParserRuleContext { + public TerminalNode PACKAGE() { return getToken(Java8Parser.PACKAGE, 0); } public List Identifier() { return getTokens(Java8Parser.Identifier); } public TerminalNode Identifier(int i) { return getToken(Java8Parser.Identifier, i); } + public TerminalNode SEMI() { return getToken(Java8Parser.SEMI, 0); } public List packageModifier() { return getRuleContexts(PackageModifierContext.class); } public PackageModifierContext packageModifier(int i) { return getRuleContext(PackageModifierContext.class,i); } + public List DOT() { return getTokens(Java8Parser.DOT); } + public TerminalNode DOT(int i) { + return getToken(Java8Parser.DOT, i); + } public PackageDeclarationContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -2544,9 +2596,11 @@ public class Java8Parser extends Parser { } public static class SingleTypeImportDeclarationContext extends ParserRuleContext { + public TerminalNode IMPORT() { return getToken(Java8Parser.IMPORT, 0); } public TypeNameContext typeName() { return getRuleContext(TypeNameContext.class,0); } + public TerminalNode SEMI() { return getToken(Java8Parser.SEMI, 0); } public SingleTypeImportDeclarationContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -2587,9 +2641,13 @@ public class Java8Parser extends Parser { } public static class TypeImportOnDemandDeclarationContext extends ParserRuleContext { + public TerminalNode IMPORT() { return getToken(Java8Parser.IMPORT, 0); } public PackageOrTypeNameContext packageOrTypeName() { return getRuleContext(PackageOrTypeNameContext.class,0); } + public TerminalNode DOT() { return getToken(Java8Parser.DOT, 0); } + public TerminalNode MUL() { return getToken(Java8Parser.MUL, 0); } + public TerminalNode SEMI() { return getToken(Java8Parser.SEMI, 0); } public TypeImportOnDemandDeclarationContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -2634,10 +2692,14 @@ public class Java8Parser extends Parser { } public static class SingleStaticImportDeclarationContext extends ParserRuleContext { + public TerminalNode IMPORT() { return getToken(Java8Parser.IMPORT, 0); } + public TerminalNode STATIC() { return getToken(Java8Parser.STATIC, 0); } public TypeNameContext typeName() { return getRuleContext(TypeNameContext.class,0); } + public TerminalNode DOT() { return getToken(Java8Parser.DOT, 0); } public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public TerminalNode SEMI() { return getToken(Java8Parser.SEMI, 0); } public SingleStaticImportDeclarationContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -2684,9 +2746,14 @@ public class Java8Parser extends Parser { } public static class StaticImportOnDemandDeclarationContext extends ParserRuleContext { + public TerminalNode IMPORT() { return getToken(Java8Parser.IMPORT, 0); } + public TerminalNode STATIC() { return getToken(Java8Parser.STATIC, 0); } public TypeNameContext typeName() { return getRuleContext(TypeNameContext.class,0); } + public TerminalNode DOT() { return getToken(Java8Parser.DOT, 0); } + public TerminalNode MUL() { return getToken(Java8Parser.MUL, 0); } + public TerminalNode SEMI() { return getToken(Java8Parser.SEMI, 0); } public StaticImportOnDemandDeclarationContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -2739,6 +2806,7 @@ public class Java8Parser extends Parser { public InterfaceDeclarationContext interfaceDeclaration() { return getRuleContext(InterfaceDeclarationContext.class,0); } + public TerminalNode SEMI() { return getToken(Java8Parser.SEMI, 0); } public TypeDeclarationContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -2850,6 +2918,7 @@ public class Java8Parser extends Parser { } public static class NormalClassDeclarationContext extends ParserRuleContext { + public TerminalNode CLASS() { return getToken(Java8Parser.CLASS, 0); } public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } public ClassBodyContext classBody() { return getRuleContext(ClassBodyContext.class,0); @@ -2957,6 +3026,13 @@ public class Java8Parser extends Parser { public AnnotationContext annotation() { return getRuleContext(AnnotationContext.class,0); } + public TerminalNode PUBLIC() { return getToken(Java8Parser.PUBLIC, 0); } + public TerminalNode PROTECTED() { return getToken(Java8Parser.PROTECTED, 0); } + public TerminalNode PRIVATE() { return getToken(Java8Parser.PRIVATE, 0); } + public TerminalNode ABSTRACT() { return getToken(Java8Parser.ABSTRACT, 0); } + public TerminalNode STATIC() { return getToken(Java8Parser.STATIC, 0); } + public TerminalNode FINAL() { return getToken(Java8Parser.FINAL, 0); } + public TerminalNode STRICTFP() { return getToken(Java8Parser.STRICTFP, 0); } public ClassModifierContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -3050,9 +3126,11 @@ public class Java8Parser extends Parser { } public static class TypeParametersContext extends ParserRuleContext { + public TerminalNode LT() { return getToken(Java8Parser.LT, 0); } public TypeParameterListContext typeParameterList() { return getRuleContext(TypeParameterListContext.class,0); } + public TerminalNode GT() { return getToken(Java8Parser.GT, 0); } public TypeParametersContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -3099,6 +3177,10 @@ public class Java8Parser extends Parser { public TypeParameterContext typeParameter(int i) { return getRuleContext(TypeParameterContext.class,i); } + public List COMMA() { return getTokens(Java8Parser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(Java8Parser.COMMA, i); + } public TypeParameterListContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -3152,6 +3234,7 @@ public class Java8Parser extends Parser { } public static class SuperclassContext extends ParserRuleContext { + public TerminalNode EXTENDS() { return getToken(Java8Parser.EXTENDS, 0); } public ClassTypeContext classType() { return getRuleContext(ClassTypeContext.class,0); } @@ -3193,6 +3276,7 @@ public class Java8Parser extends Parser { } public static class SuperinterfacesContext extends ParserRuleContext { + public TerminalNode IMPLEMENTS() { return getToken(Java8Parser.IMPLEMENTS, 0); } public InterfaceTypeListContext interfaceTypeList() { return getRuleContext(InterfaceTypeListContext.class,0); } @@ -3240,6 +3324,10 @@ public class Java8Parser extends Parser { public InterfaceTypeContext interfaceType(int i) { return getRuleContext(InterfaceTypeContext.class,i); } + public List COMMA() { return getTokens(Java8Parser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(Java8Parser.COMMA, i); + } public InterfaceTypeListContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -3293,6 +3381,8 @@ public class Java8Parser extends Parser { } public static class ClassBodyContext extends ParserRuleContext { + public TerminalNode LBRACE() { return getToken(Java8Parser.LBRACE, 0); } + public TerminalNode RBRACE() { return getToken(Java8Parser.RBRACE, 0); } public List classBodyDeclaration() { return getRuleContexts(ClassBodyDeclarationContext.class); } @@ -3429,6 +3519,7 @@ public class Java8Parser extends Parser { public InterfaceDeclarationContext interfaceDeclaration() { return getRuleContext(InterfaceDeclarationContext.class,0); } + public TerminalNode SEMI() { return getToken(Java8Parser.SEMI, 0); } public ClassMemberDeclarationContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -3502,6 +3593,7 @@ public class Java8Parser extends Parser { public VariableDeclaratorListContext variableDeclaratorList() { return getRuleContext(VariableDeclaratorListContext.class,0); } + public TerminalNode SEMI() { return getToken(Java8Parser.SEMI, 0); } public List fieldModifier() { return getRuleContexts(FieldModifierContext.class); } @@ -3577,6 +3669,13 @@ public class Java8Parser extends Parser { public AnnotationContext annotation() { return getRuleContext(AnnotationContext.class,0); } + public TerminalNode PUBLIC() { return getToken(Java8Parser.PUBLIC, 0); } + public TerminalNode PROTECTED() { return getToken(Java8Parser.PROTECTED, 0); } + public TerminalNode PRIVATE() { return getToken(Java8Parser.PRIVATE, 0); } + public TerminalNode STATIC() { return getToken(Java8Parser.STATIC, 0); } + public TerminalNode FINAL() { return getToken(Java8Parser.FINAL, 0); } + public TerminalNode TRANSIENT() { return getToken(Java8Parser.TRANSIENT, 0); } + public TerminalNode VOLATILE() { return getToken(Java8Parser.VOLATILE, 0); } public FieldModifierContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -3676,6 +3775,10 @@ public class Java8Parser extends Parser { public VariableDeclaratorContext variableDeclarator(int i) { return getRuleContext(VariableDeclaratorContext.class,i); } + public List COMMA() { return getTokens(Java8Parser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(Java8Parser.COMMA, i); + } public VariableDeclaratorListContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -3732,6 +3835,7 @@ public class Java8Parser extends Parser { public VariableDeclaratorIdContext variableDeclaratorId() { return getRuleContext(VariableDeclaratorIdContext.class,0); } + public TerminalNode ASSIGN() { return getToken(Java8Parser.ASSIGN, 0); } public VariableInitializerContext variableInitializer() { return getRuleContext(VariableInitializerContext.class,0); } @@ -3976,6 +4080,7 @@ public class Java8Parser extends Parser { public NumericTypeContext numericType() { return getRuleContext(NumericTypeContext.class,0); } + public TerminalNode BOOLEAN() { return getToken(Java8Parser.BOOLEAN, 0); } public UnannPrimitiveTypeContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -4156,7 +4261,7 @@ public class Java8Parser extends Parser { setState(935); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,66,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { setState(933); @@ -4202,6 +4307,7 @@ public class Java8Parser extends Parser { public UnannClassOrInterfaceTypeContext unannClassOrInterfaceType() { return getRuleContext(UnannClassOrInterfaceTypeContext.class,0); } + public TerminalNode DOT() { return getToken(Java8Parser.DOT, 0); } public List annotation() { return getRuleContexts(AnnotationContext.class); } @@ -4296,6 +4402,7 @@ public class Java8Parser extends Parser { } public static class UnannClassType_lf_unannClassOrInterfaceTypeContext extends ParserRuleContext { + public TerminalNode DOT() { return getToken(Java8Parser.DOT, 0); } public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } public List annotation() { return getRuleContexts(AnnotationContext.class); @@ -4716,6 +4823,15 @@ public class Java8Parser extends Parser { public AnnotationContext annotation() { return getRuleContext(AnnotationContext.class,0); } + public TerminalNode PUBLIC() { return getToken(Java8Parser.PUBLIC, 0); } + public TerminalNode PROTECTED() { return getToken(Java8Parser.PROTECTED, 0); } + public TerminalNode PRIVATE() { return getToken(Java8Parser.PRIVATE, 0); } + public TerminalNode ABSTRACT() { return getToken(Java8Parser.ABSTRACT, 0); } + public TerminalNode STATIC() { return getToken(Java8Parser.STATIC, 0); } + public TerminalNode FINAL() { return getToken(Java8Parser.FINAL, 0); } + public TerminalNode SYNCHRONIZED() { return getToken(Java8Parser.SYNCHRONIZED, 0); } + public TerminalNode NATIVE() { return getToken(Java8Parser.NATIVE, 0); } + public TerminalNode STRICTFP() { return getToken(Java8Parser.STRICTFP, 0); } public MethodModifierContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -4961,6 +5077,7 @@ public class Java8Parser extends Parser { public UnannTypeContext unannType() { return getRuleContext(UnannTypeContext.class,0); } + public TerminalNode VOID() { return getToken(Java8Parser.VOID, 0); } public ResultContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -5021,6 +5138,8 @@ public class Java8Parser extends Parser { public static class MethodDeclaratorContext extends ParserRuleContext { public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public TerminalNode LPAREN() { return getToken(Java8Parser.LPAREN, 0); } + public TerminalNode RPAREN() { return getToken(Java8Parser.RPAREN, 0); } public FormalParameterListContext formalParameterList() { return getRuleContext(FormalParameterListContext.class,0); } @@ -5091,6 +5210,7 @@ public class Java8Parser extends Parser { public FormalParametersContext formalParameters() { return getRuleContext(FormalParametersContext.class,0); } + public TerminalNode COMMA() { return getToken(Java8Parser.COMMA, 0); } public LastFormalParameterContext lastFormalParameter() { return getRuleContext(LastFormalParameterContext.class,0); } @@ -5153,6 +5273,10 @@ public class Java8Parser extends Parser { public FormalParameterContext formalParameter(int i) { return getRuleContext(FormalParameterContext.class,i); } + public List COMMA() { return getTokens(Java8Parser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(Java8Parser.COMMA, i); + } public ReceiverParameterContext receiverParameter() { return getRuleContext(ReceiverParameterContext.class,0); } @@ -5186,7 +5310,7 @@ public class Java8Parser extends Parser { setState(1059); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,87,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { @@ -5211,7 +5335,7 @@ public class Java8Parser extends Parser { setState(1067); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,88,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { @@ -5318,6 +5442,7 @@ public class Java8Parser extends Parser { public AnnotationContext annotation() { return getRuleContext(AnnotationContext.class,0); } + public TerminalNode FINAL() { return getToken(Java8Parser.FINAL, 0); } public VariableModifierContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -5372,6 +5497,7 @@ public class Java8Parser extends Parser { public UnannTypeContext unannType() { return getRuleContext(UnannTypeContext.class,0); } + public TerminalNode ELLIPSIS() { return getToken(Java8Parser.ELLIPSIS, 0); } public VariableDeclaratorIdContext variableDeclaratorId() { return getRuleContext(VariableDeclaratorIdContext.class,0); } @@ -5475,6 +5601,7 @@ public class Java8Parser extends Parser { public UnannTypeContext unannType() { return getRuleContext(UnannTypeContext.class,0); } + public TerminalNode THIS() { return getToken(Java8Parser.THIS, 0); } public List annotation() { return getRuleContexts(AnnotationContext.class); } @@ -5482,6 +5609,7 @@ public class Java8Parser extends Parser { return getRuleContext(AnnotationContext.class,i); } public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public TerminalNode DOT() { return getToken(Java8Parser.DOT, 0); } public ReceiverParameterContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -5547,6 +5675,7 @@ public class Java8Parser extends Parser { } public static class Throws_Context extends ParserRuleContext { + public TerminalNode THROWS() { return getToken(Java8Parser.THROWS, 0); } public ExceptionTypeListContext exceptionTypeList() { return getRuleContext(ExceptionTypeListContext.class,0); } @@ -5594,6 +5723,10 @@ public class Java8Parser extends Parser { public ExceptionTypeContext exceptionType(int i) { return getRuleContext(ExceptionTypeContext.class,i); } + public List COMMA() { return getTokens(Java8Parser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(Java8Parser.COMMA, i); + } public ExceptionTypeListContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -5705,6 +5838,7 @@ public class Java8Parser extends Parser { public BlockContext block() { return getRuleContext(BlockContext.class,0); } + public TerminalNode SEMI() { return getToken(Java8Parser.SEMI, 0); } public MethodBodyContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -5795,6 +5929,7 @@ public class Java8Parser extends Parser { } public static class StaticInitializerContext extends ParserRuleContext { + public TerminalNode STATIC() { return getToken(Java8Parser.STATIC, 0); } public BlockContext block() { return getRuleContext(BlockContext.class,0); } @@ -5917,6 +6052,9 @@ public class Java8Parser extends Parser { public AnnotationContext annotation() { return getRuleContext(AnnotationContext.class,0); } + public TerminalNode PUBLIC() { return getToken(Java8Parser.PUBLIC, 0); } + public TerminalNode PROTECTED() { return getToken(Java8Parser.PROTECTED, 0); } + public TerminalNode PRIVATE() { return getToken(Java8Parser.PRIVATE, 0); } public ConstructorModifierContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -5985,6 +6123,8 @@ public class Java8Parser extends Parser { public SimpleTypeNameContext simpleTypeName() { return getRuleContext(SimpleTypeNameContext.class,0); } + public TerminalNode LPAREN() { return getToken(Java8Parser.LPAREN, 0); } + public TerminalNode RPAREN() { return getToken(Java8Parser.RPAREN, 0); } public TypeParametersContext typeParameters() { return getRuleContext(TypeParametersContext.class,0); } @@ -6089,6 +6229,8 @@ public class Java8Parser extends Parser { } public static class ConstructorBodyContext extends ParserRuleContext { + public TerminalNode LBRACE() { return getToken(Java8Parser.LBRACE, 0); } + public TerminalNode RBRACE() { return getToken(Java8Parser.RBRACE, 0); } public ExplicitConstructorInvocationContext explicitConstructorInvocation() { return getRuleContext(ExplicitConstructorInvocationContext.class,0); } @@ -6154,15 +6296,21 @@ public class Java8Parser extends Parser { } public static class ExplicitConstructorInvocationContext extends ParserRuleContext { + public TerminalNode THIS() { return getToken(Java8Parser.THIS, 0); } + public TerminalNode LPAREN() { return getToken(Java8Parser.LPAREN, 0); } + public TerminalNode RPAREN() { return getToken(Java8Parser.RPAREN, 0); } + public TerminalNode SEMI() { return getToken(Java8Parser.SEMI, 0); } public TypeArgumentsContext typeArguments() { return getRuleContext(TypeArgumentsContext.class,0); } public ArgumentListContext argumentList() { return getRuleContext(ArgumentListContext.class,0); } + public TerminalNode SUPER() { return getToken(Java8Parser.SUPER, 0); } public ExpressionNameContext expressionName() { return getRuleContext(ExpressionNameContext.class,0); } + public TerminalNode DOT() { return getToken(Java8Parser.DOT, 0); } public PrimaryContext primary() { return getRuleContext(PrimaryContext.class,0); } @@ -6342,6 +6490,7 @@ public class Java8Parser extends Parser { } public static class EnumDeclarationContext extends ParserRuleContext { + public TerminalNode ENUM() { return getToken(Java8Parser.ENUM, 0); } public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } public EnumBodyContext enumBody() { return getRuleContext(EnumBodyContext.class,0); @@ -6420,9 +6569,12 @@ public class Java8Parser extends Parser { } public static class EnumBodyContext extends ParserRuleContext { + public TerminalNode LBRACE() { return getToken(Java8Parser.LBRACE, 0); } + public TerminalNode RBRACE() { return getToken(Java8Parser.RBRACE, 0); } public EnumConstantListContext enumConstantList() { return getRuleContext(EnumConstantListContext.class,0); } + public TerminalNode COMMA() { return getToken(Java8Parser.COMMA, 0); } public EnumBodyDeclarationsContext enumBodyDeclarations() { return getRuleContext(EnumBodyDeclarationsContext.class,0); } @@ -6501,6 +6653,10 @@ public class Java8Parser extends Parser { public EnumConstantContext enumConstant(int i) { return getRuleContext(EnumConstantContext.class,i); } + public List COMMA() { return getTokens(Java8Parser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(Java8Parser.COMMA, i); + } public EnumConstantListContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -6527,7 +6683,7 @@ public class Java8Parser extends Parser { setState(1260); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,122,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { @@ -6563,6 +6719,8 @@ public class Java8Parser extends Parser { public EnumConstantModifierContext enumConstantModifier(int i) { return getRuleContext(EnumConstantModifierContext.class,i); } + public TerminalNode LPAREN() { return getToken(Java8Parser.LPAREN, 0); } + public TerminalNode RPAREN() { return getToken(Java8Parser.RPAREN, 0); } public ClassBodyContext classBody() { return getRuleContext(ClassBodyContext.class,0); } @@ -6691,6 +6849,7 @@ public class Java8Parser extends Parser { } public static class EnumBodyDeclarationsContext extends ParserRuleContext { + public TerminalNode SEMI() { return getToken(Java8Parser.SEMI, 0); } public List classBodyDeclaration() { return getRuleContexts(ClassBodyDeclarationContext.class); } @@ -6803,6 +6962,7 @@ public class Java8Parser extends Parser { } public static class NormalInterfaceDeclarationContext extends ParserRuleContext { + public TerminalNode INTERFACE() { return getToken(Java8Parser.INTERFACE, 0); } public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } public InterfaceBodyContext interfaceBody() { return getRuleContext(InterfaceBodyContext.class,0); @@ -6897,6 +7057,12 @@ public class Java8Parser extends Parser { public AnnotationContext annotation() { return getRuleContext(AnnotationContext.class,0); } + public TerminalNode PUBLIC() { return getToken(Java8Parser.PUBLIC, 0); } + public TerminalNode PROTECTED() { return getToken(Java8Parser.PROTECTED, 0); } + public TerminalNode PRIVATE() { return getToken(Java8Parser.PRIVATE, 0); } + public TerminalNode ABSTRACT() { return getToken(Java8Parser.ABSTRACT, 0); } + public TerminalNode STATIC() { return getToken(Java8Parser.STATIC, 0); } + public TerminalNode STRICTFP() { return getToken(Java8Parser.STRICTFP, 0); } public InterfaceModifierContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -6983,6 +7149,7 @@ public class Java8Parser extends Parser { } public static class ExtendsInterfacesContext extends ParserRuleContext { + public TerminalNode EXTENDS() { return getToken(Java8Parser.EXTENDS, 0); } public InterfaceTypeListContext interfaceTypeList() { return getRuleContext(InterfaceTypeListContext.class,0); } @@ -7024,6 +7191,8 @@ public class Java8Parser extends Parser { } public static class InterfaceBodyContext extends ParserRuleContext { + public TerminalNode LBRACE() { return getToken(Java8Parser.LBRACE, 0); } + public TerminalNode RBRACE() { return getToken(Java8Parser.RBRACE, 0); } public List interfaceMemberDeclaration() { return getRuleContexts(InterfaceMemberDeclarationContext.class); } @@ -7095,6 +7264,7 @@ public class Java8Parser extends Parser { public InterfaceDeclarationContext interfaceDeclaration() { return getRuleContext(InterfaceDeclarationContext.class,0); } + public TerminalNode SEMI() { return getToken(Java8Parser.SEMI, 0); } public InterfaceMemberDeclarationContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -7171,6 +7341,7 @@ public class Java8Parser extends Parser { public VariableDeclaratorListContext variableDeclaratorList() { return getRuleContext(VariableDeclaratorListContext.class,0); } + public TerminalNode SEMI() { return getToken(Java8Parser.SEMI, 0); } public List constantModifier() { return getRuleContexts(ConstantModifierContext.class); } @@ -7235,6 +7406,9 @@ public class Java8Parser extends Parser { public AnnotationContext annotation() { return getRuleContext(AnnotationContext.class,0); } + public TerminalNode PUBLIC() { return getToken(Java8Parser.PUBLIC, 0); } + public TerminalNode STATIC() { return getToken(Java8Parser.STATIC, 0); } + public TerminalNode FINAL() { return getToken(Java8Parser.FINAL, 0); } public ConstantModifierContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -7368,6 +7542,11 @@ public class Java8Parser extends Parser { public AnnotationContext annotation() { return getRuleContext(AnnotationContext.class,0); } + public TerminalNode PUBLIC() { return getToken(Java8Parser.PUBLIC, 0); } + public TerminalNode ABSTRACT() { return getToken(Java8Parser.ABSTRACT, 0); } + public TerminalNode DEFAULT() { return getToken(Java8Parser.DEFAULT, 0); } + public TerminalNode STATIC() { return getToken(Java8Parser.STATIC, 0); } + public TerminalNode STRICTFP() { return getToken(Java8Parser.STRICTFP, 0); } public InterfaceMethodModifierContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -7447,6 +7626,8 @@ public class Java8Parser extends Parser { } public static class AnnotationTypeDeclarationContext extends ParserRuleContext { + public TerminalNode AT() { return getToken(Java8Parser.AT, 0); } + public TerminalNode INTERFACE() { return getToken(Java8Parser.INTERFACE, 0); } public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } public AnnotationTypeBodyContext annotationTypeBody() { return getRuleContext(AnnotationTypeBodyContext.class,0); @@ -7481,7 +7662,7 @@ public class Java8Parser extends Parser { setState(1373); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,139,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { @@ -7516,6 +7697,8 @@ public class Java8Parser extends Parser { } public static class AnnotationTypeBodyContext extends ParserRuleContext { + public TerminalNode LBRACE() { return getToken(Java8Parser.LBRACE, 0); } + public TerminalNode RBRACE() { return getToken(Java8Parser.RBRACE, 0); } public List annotationTypeMemberDeclaration() { return getRuleContexts(AnnotationTypeMemberDeclarationContext.class); } @@ -7587,6 +7770,7 @@ public class Java8Parser extends Parser { public InterfaceDeclarationContext interfaceDeclaration() { return getRuleContext(InterfaceDeclarationContext.class,0); } + public TerminalNode SEMI() { return getToken(Java8Parser.SEMI, 0); } public AnnotationTypeMemberDeclarationContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -7661,6 +7845,9 @@ public class Java8Parser extends Parser { return getRuleContext(UnannTypeContext.class,0); } public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public TerminalNode LPAREN() { return getToken(Java8Parser.LPAREN, 0); } + public TerminalNode RPAREN() { return getToken(Java8Parser.RPAREN, 0); } + public TerminalNode SEMI() { return getToken(Java8Parser.SEMI, 0); } public List annotationTypeElementModifier() { return getRuleContexts(AnnotationTypeElementModifierContext.class); } @@ -7755,6 +7942,8 @@ public class Java8Parser extends Parser { public AnnotationContext annotation() { return getRuleContext(AnnotationContext.class,0); } + public TerminalNode PUBLIC() { return getToken(Java8Parser.PUBLIC, 0); } + public TerminalNode ABSTRACT() { return getToken(Java8Parser.ABSTRACT, 0); } public AnnotationTypeElementModifierContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -7813,6 +8002,7 @@ public class Java8Parser extends Parser { } public static class DefaultValueContext extends ParserRuleContext { + public TerminalNode DEFAULT() { return getToken(Java8Parser.DEFAULT, 0); } public ElementValueContext elementValue() { return getRuleContext(ElementValueContext.class,0); } @@ -7919,9 +8109,12 @@ public class Java8Parser extends Parser { } public static class NormalAnnotationContext extends ParserRuleContext { + public TerminalNode AT() { return getToken(Java8Parser.AT, 0); } public TypeNameContext typeName() { return getRuleContext(TypeNameContext.class,0); } + public TerminalNode LPAREN() { return getToken(Java8Parser.LPAREN, 0); } + public TerminalNode RPAREN() { return getToken(Java8Parser.RPAREN, 0); } public ElementValuePairListContext elementValuePairList() { return getRuleContext(ElementValuePairListContext.class,0); } @@ -7984,6 +8177,10 @@ public class Java8Parser extends Parser { public ElementValuePairContext elementValuePair(int i) { return getRuleContext(ElementValuePairContext.class,i); } + public List COMMA() { return getTokens(Java8Parser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(Java8Parser.COMMA, i); + } public ElementValuePairListContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -8038,6 +8235,7 @@ public class Java8Parser extends Parser { public static class ElementValuePairContext extends ParserRuleContext { public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public TerminalNode ASSIGN() { return getToken(Java8Parser.ASSIGN, 0); } public ElementValueContext elementValue() { return getRuleContext(ElementValueContext.class,0); } @@ -8146,9 +8344,12 @@ public class Java8Parser extends Parser { } public static class ElementValueArrayInitializerContext extends ParserRuleContext { + public TerminalNode LBRACE() { return getToken(Java8Parser.LBRACE, 0); } + public TerminalNode RBRACE() { return getToken(Java8Parser.RBRACE, 0); } public ElementValueListContext elementValueList() { return getRuleContext(ElementValueListContext.class,0); } + public TerminalNode COMMA() { return getToken(Java8Parser.COMMA, 0); } public ElementValueArrayInitializerContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -8214,6 +8415,10 @@ public class Java8Parser extends Parser { public ElementValueContext elementValue(int i) { return getRuleContext(ElementValueContext.class,i); } + public List COMMA() { return getTokens(Java8Parser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(Java8Parser.COMMA, i); + } public ElementValueListContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -8240,7 +8445,7 @@ public class Java8Parser extends Parser { setState(1467); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,152,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { @@ -8269,6 +8474,7 @@ public class Java8Parser extends Parser { } public static class MarkerAnnotationContext extends ParserRuleContext { + public TerminalNode AT() { return getToken(Java8Parser.AT, 0); } public TypeNameContext typeName() { return getRuleContext(TypeNameContext.class,0); } @@ -8310,12 +8516,15 @@ public class Java8Parser extends Parser { } public static class SingleElementAnnotationContext extends ParserRuleContext { + public TerminalNode AT() { return getToken(Java8Parser.AT, 0); } public TypeNameContext typeName() { return getRuleContext(TypeNameContext.class,0); } + public TerminalNode LPAREN() { return getToken(Java8Parser.LPAREN, 0); } public ElementValueContext elementValue() { return getRuleContext(ElementValueContext.class,0); } + public TerminalNode RPAREN() { return getToken(Java8Parser.RPAREN, 0); } public SingleElementAnnotationContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -8360,9 +8569,12 @@ public class Java8Parser extends Parser { } public static class ArrayInitializerContext extends ParserRuleContext { + public TerminalNode LBRACE() { return getToken(Java8Parser.LBRACE, 0); } + public TerminalNode RBRACE() { return getToken(Java8Parser.RBRACE, 0); } public VariableInitializerListContext variableInitializerList() { return getRuleContext(VariableInitializerListContext.class,0); } + public TerminalNode COMMA() { return getToken(Java8Parser.COMMA, 0); } public ArrayInitializerContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -8428,6 +8640,10 @@ public class Java8Parser extends Parser { public VariableInitializerContext variableInitializer(int i) { return getRuleContext(VariableInitializerContext.class,i); } + public List COMMA() { return getTokens(Java8Parser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(Java8Parser.COMMA, i); + } public VariableInitializerListContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -8454,7 +8670,7 @@ public class Java8Parser extends Parser { setState(1493); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,155,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { @@ -8483,6 +8699,8 @@ public class Java8Parser extends Parser { } public static class BlockContext extends ParserRuleContext { + public TerminalNode LBRACE() { return getToken(Java8Parser.LBRACE, 0); } + public TerminalNode RBRACE() { return getToken(Java8Parser.RBRACE, 0); } public BlockStatementsContext blockStatements() { return getRuleContext(BlockStatementsContext.class,0); } @@ -8660,6 +8878,7 @@ public class Java8Parser extends Parser { public LocalVariableDeclarationContext localVariableDeclaration() { return getRuleContext(LocalVariableDeclarationContext.class,0); } + public TerminalNode SEMI() { return getToken(Java8Parser.SEMI, 0); } public LocalVariableDeclarationStatementContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -9184,6 +9403,7 @@ public class Java8Parser extends Parser { } public static class EmptyStatementContext extends ParserRuleContext { + public TerminalNode SEMI() { return getToken(Java8Parser.SEMI, 0); } public EmptyStatementContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -9221,6 +9441,7 @@ public class Java8Parser extends Parser { public static class LabeledStatementContext extends ParserRuleContext { public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public TerminalNode COLON() { return getToken(Java8Parser.COLON, 0); } public StatementContext statement() { return getRuleContext(StatementContext.class,0); } @@ -9265,6 +9486,7 @@ public class Java8Parser extends Parser { public static class LabeledStatementNoShortIfContext extends ParserRuleContext { public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public TerminalNode COLON() { return getToken(Java8Parser.COLON, 0); } public StatementNoShortIfContext statementNoShortIf() { return getRuleContext(StatementNoShortIfContext.class,0); } @@ -9311,6 +9533,7 @@ public class Java8Parser extends Parser { public StatementExpressionContext statementExpression() { return getRuleContext(StatementExpressionContext.class,0); } + public TerminalNode SEMI() { return getToken(Java8Parser.SEMI, 0); } public ExpressionStatementContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -9454,9 +9677,12 @@ public class Java8Parser extends Parser { } public static class IfThenStatementContext extends ParserRuleContext { + public TerminalNode IF() { return getToken(Java8Parser.IF, 0); } + public TerminalNode LPAREN() { return getToken(Java8Parser.LPAREN, 0); } public ExpressionContext expression() { return getRuleContext(ExpressionContext.class,0); } + public TerminalNode RPAREN() { return getToken(Java8Parser.RPAREN, 0); } public StatementContext statement() { return getRuleContext(StatementContext.class,0); } @@ -9504,12 +9730,16 @@ public class Java8Parser extends Parser { } public static class IfThenElseStatementContext extends ParserRuleContext { + public TerminalNode IF() { return getToken(Java8Parser.IF, 0); } + public TerminalNode LPAREN() { return getToken(Java8Parser.LPAREN, 0); } public ExpressionContext expression() { return getRuleContext(ExpressionContext.class,0); } + public TerminalNode RPAREN() { return getToken(Java8Parser.RPAREN, 0); } public StatementNoShortIfContext statementNoShortIf() { return getRuleContext(StatementNoShortIfContext.class,0); } + public TerminalNode ELSE() { return getToken(Java8Parser.ELSE, 0); } public StatementContext statement() { return getRuleContext(StatementContext.class,0); } @@ -9561,15 +9791,19 @@ public class Java8Parser extends Parser { } public static class IfThenElseStatementNoShortIfContext extends ParserRuleContext { + public TerminalNode IF() { return getToken(Java8Parser.IF, 0); } + public TerminalNode LPAREN() { return getToken(Java8Parser.LPAREN, 0); } public ExpressionContext expression() { return getRuleContext(ExpressionContext.class,0); } + public TerminalNode RPAREN() { return getToken(Java8Parser.RPAREN, 0); } public List statementNoShortIf() { return getRuleContexts(StatementNoShortIfContext.class); } public StatementNoShortIfContext statementNoShortIf(int i) { return getRuleContext(StatementNoShortIfContext.class,i); } + public TerminalNode ELSE() { return getToken(Java8Parser.ELSE, 0); } public IfThenElseStatementNoShortIfContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -9618,12 +9852,15 @@ public class Java8Parser extends Parser { } public static class AssertStatementContext extends ParserRuleContext { + public TerminalNode ASSERT() { return getToken(Java8Parser.ASSERT, 0); } public List expression() { return getRuleContexts(ExpressionContext.class); } public ExpressionContext expression(int i) { return getRuleContext(ExpressionContext.class,i); } + public TerminalNode SEMI() { return getToken(Java8Parser.SEMI, 0); } + public TerminalNode COLON() { return getToken(Java8Parser.COLON, 0); } public AssertStatementContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -9685,9 +9922,12 @@ public class Java8Parser extends Parser { } public static class SwitchStatementContext extends ParserRuleContext { + public TerminalNode SWITCH() { return getToken(Java8Parser.SWITCH, 0); } + public TerminalNode LPAREN() { return getToken(Java8Parser.LPAREN, 0); } public ExpressionContext expression() { return getRuleContext(ExpressionContext.class,0); } + public TerminalNode RPAREN() { return getToken(Java8Parser.RPAREN, 0); } public SwitchBlockContext switchBlock() { return getRuleContext(SwitchBlockContext.class,0); } @@ -9735,6 +9975,8 @@ public class Java8Parser extends Parser { } public static class SwitchBlockContext extends ParserRuleContext { + public TerminalNode LBRACE() { return getToken(Java8Parser.LBRACE, 0); } + public TerminalNode RBRACE() { return getToken(Java8Parser.RBRACE, 0); } public List switchBlockStatementGroup() { return getRuleContexts(SwitchBlockStatementGroupContext.class); } @@ -9774,7 +10016,7 @@ public class Java8Parser extends Parser { setState(1625); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,166,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { @@ -9918,12 +10160,15 @@ public class Java8Parser extends Parser { } public static class SwitchLabelContext extends ParserRuleContext { + public TerminalNode CASE() { return getToken(Java8Parser.CASE, 0); } public ConstantExpressionContext constantExpression() { return getRuleContext(ConstantExpressionContext.class,0); } + public TerminalNode COLON() { return getToken(Java8Parser.COLON, 0); } public EnumConstantNameContext enumConstantName() { return getRuleContext(EnumConstantNameContext.class,0); } + public TerminalNode DEFAULT() { return getToken(Java8Parser.DEFAULT, 0); } public SwitchLabelContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -10027,9 +10272,12 @@ public class Java8Parser extends Parser { } public static class WhileStatementContext extends ParserRuleContext { + public TerminalNode WHILE() { return getToken(Java8Parser.WHILE, 0); } + public TerminalNode LPAREN() { return getToken(Java8Parser.LPAREN, 0); } public ExpressionContext expression() { return getRuleContext(ExpressionContext.class,0); } + public TerminalNode RPAREN() { return getToken(Java8Parser.RPAREN, 0); } public StatementContext statement() { return getRuleContext(StatementContext.class,0); } @@ -10077,9 +10325,12 @@ public class Java8Parser extends Parser { } public static class WhileStatementNoShortIfContext extends ParserRuleContext { + public TerminalNode WHILE() { return getToken(Java8Parser.WHILE, 0); } + public TerminalNode LPAREN() { return getToken(Java8Parser.LPAREN, 0); } public ExpressionContext expression() { return getRuleContext(ExpressionContext.class,0); } + public TerminalNode RPAREN() { return getToken(Java8Parser.RPAREN, 0); } public StatementNoShortIfContext statementNoShortIf() { return getRuleContext(StatementNoShortIfContext.class,0); } @@ -10127,12 +10378,17 @@ public class Java8Parser extends Parser { } public static class DoStatementContext extends ParserRuleContext { + public TerminalNode DO() { return getToken(Java8Parser.DO, 0); } public StatementContext statement() { return getRuleContext(StatementContext.class,0); } + public TerminalNode WHILE() { return getToken(Java8Parser.WHILE, 0); } + public TerminalNode LPAREN() { return getToken(Java8Parser.LPAREN, 0); } public ExpressionContext expression() { return getRuleContext(ExpressionContext.class,0); } + public TerminalNode RPAREN() { return getToken(Java8Parser.RPAREN, 0); } + public TerminalNode SEMI() { return getToken(Java8Parser.SEMI, 0); } public DoStatementContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -10291,6 +10547,13 @@ public class Java8Parser extends Parser { } public static class BasicForStatementContext extends ParserRuleContext { + public TerminalNode FOR() { return getToken(Java8Parser.FOR, 0); } + public TerminalNode LPAREN() { return getToken(Java8Parser.LPAREN, 0); } + public List SEMI() { return getTokens(Java8Parser.SEMI); } + public TerminalNode SEMI(int i) { + return getToken(Java8Parser.SEMI, i); + } + public TerminalNode RPAREN() { return getToken(Java8Parser.RPAREN, 0); } public StatementContext statement() { return getRuleContext(StatementContext.class,0); } @@ -10380,6 +10643,13 @@ public class Java8Parser extends Parser { } public static class BasicForStatementNoShortIfContext extends ParserRuleContext { + public TerminalNode FOR() { return getToken(Java8Parser.FOR, 0); } + public TerminalNode LPAREN() { return getToken(Java8Parser.LPAREN, 0); } + public List SEMI() { return getTokens(Java8Parser.SEMI); } + public TerminalNode SEMI(int i) { + return getToken(Java8Parser.SEMI, i); + } + public TerminalNode RPAREN() { return getToken(Java8Parser.RPAREN, 0); } public StatementNoShortIfContext statementNoShortIf() { return getRuleContext(StatementNoShortIfContext.class,0); } @@ -10569,6 +10839,10 @@ public class Java8Parser extends Parser { public StatementExpressionContext statementExpression(int i) { return getRuleContext(StatementExpressionContext.class,i); } + public List COMMA() { return getTokens(Java8Parser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(Java8Parser.COMMA, i); + } public StatementExpressionListContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -10622,15 +10896,19 @@ public class Java8Parser extends Parser { } public static class EnhancedForStatementContext extends ParserRuleContext { + public TerminalNode FOR() { return getToken(Java8Parser.FOR, 0); } + public TerminalNode LPAREN() { return getToken(Java8Parser.LPAREN, 0); } public UnannTypeContext unannType() { return getRuleContext(UnannTypeContext.class,0); } public VariableDeclaratorIdContext variableDeclaratorId() { return getRuleContext(VariableDeclaratorIdContext.class,0); } + public TerminalNode COLON() { return getToken(Java8Parser.COLON, 0); } public ExpressionContext expression() { return getRuleContext(ExpressionContext.class,0); } + public TerminalNode RPAREN() { return getToken(Java8Parser.RPAREN, 0); } public StatementContext statement() { return getRuleContext(StatementContext.class,0); } @@ -10705,15 +10983,19 @@ public class Java8Parser extends Parser { } public static class EnhancedForStatementNoShortIfContext extends ParserRuleContext { + public TerminalNode FOR() { return getToken(Java8Parser.FOR, 0); } + public TerminalNode LPAREN() { return getToken(Java8Parser.LPAREN, 0); } public UnannTypeContext unannType() { return getRuleContext(UnannTypeContext.class,0); } public VariableDeclaratorIdContext variableDeclaratorId() { return getRuleContext(VariableDeclaratorIdContext.class,0); } + public TerminalNode COLON() { return getToken(Java8Parser.COLON, 0); } public ExpressionContext expression() { return getRuleContext(ExpressionContext.class,0); } + public TerminalNode RPAREN() { return getToken(Java8Parser.RPAREN, 0); } public StatementNoShortIfContext statementNoShortIf() { return getRuleContext(StatementNoShortIfContext.class,0); } @@ -10788,6 +11070,8 @@ public class Java8Parser extends Parser { } public static class BreakStatementContext extends ParserRuleContext { + public TerminalNode BREAK() { return getToken(Java8Parser.BREAK, 0); } + public TerminalNode SEMI() { return getToken(Java8Parser.SEMI, 0); } public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } public BreakStatementContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); @@ -10838,6 +11122,8 @@ public class Java8Parser extends Parser { } public static class ContinueStatementContext extends ParserRuleContext { + public TerminalNode CONTINUE() { return getToken(Java8Parser.CONTINUE, 0); } + public TerminalNode SEMI() { return getToken(Java8Parser.SEMI, 0); } public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } public ContinueStatementContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); @@ -10888,6 +11174,8 @@ public class Java8Parser extends Parser { } public static class ReturnStatementContext extends ParserRuleContext { + public TerminalNode RETURN() { return getToken(Java8Parser.RETURN, 0); } + public TerminalNode SEMI() { return getToken(Java8Parser.SEMI, 0); } public ExpressionContext expression() { return getRuleContext(ExpressionContext.class,0); } @@ -10940,9 +11228,11 @@ public class Java8Parser extends Parser { } public static class ThrowStatementContext extends ParserRuleContext { + public TerminalNode THROW() { return getToken(Java8Parser.THROW, 0); } public ExpressionContext expression() { return getRuleContext(ExpressionContext.class,0); } + public TerminalNode SEMI() { return getToken(Java8Parser.SEMI, 0); } public ThrowStatementContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -10983,9 +11273,12 @@ public class Java8Parser extends Parser { } public static class SynchronizedStatementContext extends ParserRuleContext { + public TerminalNode SYNCHRONIZED() { return getToken(Java8Parser.SYNCHRONIZED, 0); } + public TerminalNode LPAREN() { return getToken(Java8Parser.LPAREN, 0); } public ExpressionContext expression() { return getRuleContext(ExpressionContext.class,0); } + public TerminalNode RPAREN() { return getToken(Java8Parser.RPAREN, 0); } public BlockContext block() { return getRuleContext(BlockContext.class,0); } @@ -11033,6 +11326,7 @@ public class Java8Parser extends Parser { } public static class TryStatementContext extends ParserRuleContext { + public TerminalNode TRY() { return getToken(Java8Parser.TRY, 0); } public BlockContext block() { return getRuleContext(BlockContext.class,0); } @@ -11177,9 +11471,12 @@ public class Java8Parser extends Parser { } public static class CatchClauseContext extends ParserRuleContext { + public TerminalNode CATCH() { return getToken(Java8Parser.CATCH, 0); } + public TerminalNode LPAREN() { return getToken(Java8Parser.LPAREN, 0); } public CatchFormalParameterContext catchFormalParameter() { return getRuleContext(CatchFormalParameterContext.class,0); } + public TerminalNode RPAREN() { return getToken(Java8Parser.RPAREN, 0); } public BlockContext block() { return getRuleContext(BlockContext.class,0); } @@ -11295,6 +11592,10 @@ public class Java8Parser extends Parser { public UnannClassTypeContext unannClassType() { return getRuleContext(UnannClassTypeContext.class,0); } + public List BITOR() { return getTokens(Java8Parser.BITOR); } + public TerminalNode BITOR(int i) { + return getToken(Java8Parser.BITOR, i); + } public List classType() { return getRuleContexts(ClassTypeContext.class); } @@ -11354,6 +11655,7 @@ public class Java8Parser extends Parser { } public static class Finally_Context extends ParserRuleContext { + public TerminalNode FINALLY() { return getToken(Java8Parser.FINALLY, 0); } public BlockContext block() { return getRuleContext(BlockContext.class,0); } @@ -11395,6 +11697,7 @@ public class Java8Parser extends Parser { } public static class TryWithResourcesStatementContext extends ParserRuleContext { + public TerminalNode TRY() { return getToken(Java8Parser.TRY, 0); } public ResourceSpecificationContext resourceSpecification() { return getRuleContext(ResourceSpecificationContext.class,0); } @@ -11468,9 +11771,12 @@ public class Java8Parser extends Parser { } public static class ResourceSpecificationContext extends ParserRuleContext { + public TerminalNode LPAREN() { return getToken(Java8Parser.LPAREN, 0); } public ResourceListContext resourceList() { return getRuleContext(ResourceListContext.class,0); } + public TerminalNode RPAREN() { return getToken(Java8Parser.RPAREN, 0); } + public TerminalNode SEMI() { return getToken(Java8Parser.SEMI, 0); } public ResourceSpecificationContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -11528,6 +11834,10 @@ public class Java8Parser extends Parser { public ResourceContext resource(int i) { return getRuleContext(ResourceContext.class,i); } + public List SEMI() { return getTokens(Java8Parser.SEMI); } + public TerminalNode SEMI(int i) { + return getToken(Java8Parser.SEMI, i); + } public ResourceListContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -11554,7 +11864,7 @@ public class Java8Parser extends Parser { setState(1860); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,193,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { @@ -11589,6 +11899,7 @@ public class Java8Parser extends Parser { public VariableDeclaratorIdContext variableDeclaratorId() { return getRuleContext(VariableDeclaratorIdContext.class,0); } + public TerminalNode ASSIGN() { return getToken(Java8Parser.ASSIGN, 0); } public ExpressionContext expression() { return getRuleContext(ExpressionContext.class,0); } @@ -11707,7 +12018,7 @@ public class Java8Parser extends Parser { setState(1881); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,196,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { @@ -11740,9 +12051,23 @@ public class Java8Parser extends Parser { public TypeNameContext typeName() { return getRuleContext(TypeNameContext.class,0); } + public TerminalNode DOT() { return getToken(Java8Parser.DOT, 0); } + public TerminalNode CLASS() { return getToken(Java8Parser.CLASS, 0); } + public List LBRACK() { return getTokens(Java8Parser.LBRACK); } + public TerminalNode LBRACK(int i) { + return getToken(Java8Parser.LBRACK, i); + } + public List RBRACK() { return getTokens(Java8Parser.RBRACK); } + public TerminalNode RBRACK(int i) { + return getToken(Java8Parser.RBRACK, i); + } + public TerminalNode VOID() { return getToken(Java8Parser.VOID, 0); } + public TerminalNode THIS() { return getToken(Java8Parser.THIS, 0); } + public TerminalNode LPAREN() { return getToken(Java8Parser.LPAREN, 0); } public ExpressionContext expression() { return getRuleContext(ExpressionContext.class,0); } + public TerminalNode RPAREN() { return getToken(Java8Parser.RPAREN, 0); } public ClassInstanceCreationExpressionContext classInstanceCreationExpression() { return getRuleContext(ClassInstanceCreationExpressionContext.class,0); } @@ -11943,9 +12268,23 @@ public class Java8Parser extends Parser { public TypeNameContext typeName() { return getRuleContext(TypeNameContext.class,0); } + public TerminalNode DOT() { return getToken(Java8Parser.DOT, 0); } + public TerminalNode CLASS() { return getToken(Java8Parser.CLASS, 0); } + public List LBRACK() { return getTokens(Java8Parser.LBRACK); } + public TerminalNode LBRACK(int i) { + return getToken(Java8Parser.LBRACK, i); + } + public List RBRACK() { return getTokens(Java8Parser.RBRACK); } + public TerminalNode RBRACK(int i) { + return getToken(Java8Parser.RBRACK, i); + } + public TerminalNode VOID() { return getToken(Java8Parser.VOID, 0); } + public TerminalNode THIS() { return getToken(Java8Parser.THIS, 0); } + public TerminalNode LPAREN() { return getToken(Java8Parser.LPAREN, 0); } public ExpressionContext expression() { return getRuleContext(ExpressionContext.class,0); } + public TerminalNode RPAREN() { return getToken(Java8Parser.RPAREN, 0); } public ClassInstanceCreationExpressionContext classInstanceCreationExpression() { return getRuleContext(ClassInstanceCreationExpressionContext.class,0); } @@ -12296,12 +12635,26 @@ public class Java8Parser extends Parser { public TypeNameContext typeName() { return getRuleContext(TypeNameContext.class,0); } + public TerminalNode DOT() { return getToken(Java8Parser.DOT, 0); } + public TerminalNode CLASS() { return getToken(Java8Parser.CLASS, 0); } + public List LBRACK() { return getTokens(Java8Parser.LBRACK); } + public TerminalNode LBRACK(int i) { + return getToken(Java8Parser.LBRACK, i); + } + public List RBRACK() { return getTokens(Java8Parser.RBRACK); } + public TerminalNode RBRACK(int i) { + return getToken(Java8Parser.RBRACK, i); + } public UnannPrimitiveTypeContext unannPrimitiveType() { return getRuleContext(UnannPrimitiveTypeContext.class,0); } + public TerminalNode VOID() { return getToken(Java8Parser.VOID, 0); } + public TerminalNode THIS() { return getToken(Java8Parser.THIS, 0); } + public TerminalNode LPAREN() { return getToken(Java8Parser.LPAREN, 0); } public ExpressionContext expression() { return getRuleContext(ExpressionContext.class,0); } + public TerminalNode RPAREN() { return getToken(Java8Parser.RPAREN, 0); } public ClassInstanceCreationExpression_lfno_primaryContext classInstanceCreationExpression_lfno_primary() { return getRuleContext(ClassInstanceCreationExpression_lfno_primaryContext.class,0); } @@ -12529,12 +12882,26 @@ public class Java8Parser extends Parser { public TypeNameContext typeName() { return getRuleContext(TypeNameContext.class,0); } + public TerminalNode DOT() { return getToken(Java8Parser.DOT, 0); } + public TerminalNode CLASS() { return getToken(Java8Parser.CLASS, 0); } + public List LBRACK() { return getTokens(Java8Parser.LBRACK); } + public TerminalNode LBRACK(int i) { + return getToken(Java8Parser.LBRACK, i); + } + public List RBRACK() { return getTokens(Java8Parser.RBRACK); } + public TerminalNode RBRACK(int i) { + return getToken(Java8Parser.RBRACK, i); + } public UnannPrimitiveTypeContext unannPrimitiveType() { return getRuleContext(UnannPrimitiveTypeContext.class,0); } + public TerminalNode VOID() { return getToken(Java8Parser.VOID, 0); } + public TerminalNode THIS() { return getToken(Java8Parser.THIS, 0); } + public TerminalNode LPAREN() { return getToken(Java8Parser.LPAREN, 0); } public ExpressionContext expression() { return getRuleContext(ExpressionContext.class,0); } + public TerminalNode RPAREN() { return getToken(Java8Parser.RPAREN, 0); } public ClassInstanceCreationExpression_lfno_primaryContext classInstanceCreationExpression_lfno_primary() { return getRuleContext(ClassInstanceCreationExpression_lfno_primaryContext.class,0); } @@ -12712,10 +13079,13 @@ public class Java8Parser extends Parser { } public static class ClassInstanceCreationExpressionContext extends ParserRuleContext { + public TerminalNode NEW() { return getToken(Java8Parser.NEW, 0); } public List Identifier() { return getTokens(Java8Parser.Identifier); } public TerminalNode Identifier(int i) { return getToken(Java8Parser.Identifier, i); } + public TerminalNode LPAREN() { return getToken(Java8Parser.LPAREN, 0); } + public TerminalNode RPAREN() { return getToken(Java8Parser.RPAREN, 0); } public TypeArgumentsContext typeArguments() { return getRuleContext(TypeArgumentsContext.class,0); } @@ -12725,6 +13095,10 @@ public class Java8Parser extends Parser { public AnnotationContext annotation(int i) { return getRuleContext(AnnotationContext.class,i); } + public List DOT() { return getTokens(Java8Parser.DOT); } + public TerminalNode DOT(int i) { + return getToken(Java8Parser.DOT, i); + } public TypeArgumentsOrDiamondContext typeArgumentsOrDiamond() { return getRuleContext(TypeArgumentsOrDiamondContext.class,0); } @@ -13015,7 +13389,11 @@ public class Java8Parser extends Parser { } public static class ClassInstanceCreationExpression_lf_primaryContext extends ParserRuleContext { + public TerminalNode DOT() { return getToken(Java8Parser.DOT, 0); } + public TerminalNode NEW() { return getToken(Java8Parser.NEW, 0); } public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public TerminalNode LPAREN() { return getToken(Java8Parser.LPAREN, 0); } + public TerminalNode RPAREN() { return getToken(Java8Parser.RPAREN, 0); } public TypeArgumentsContext typeArguments() { return getRuleContext(TypeArgumentsContext.class,0); } @@ -13133,10 +13511,13 @@ public class Java8Parser extends Parser { } public static class ClassInstanceCreationExpression_lfno_primaryContext extends ParserRuleContext { + public TerminalNode NEW() { return getToken(Java8Parser.NEW, 0); } public List Identifier() { return getTokens(Java8Parser.Identifier); } public TerminalNode Identifier(int i) { return getToken(Java8Parser.Identifier, i); } + public TerminalNode LPAREN() { return getToken(Java8Parser.LPAREN, 0); } + public TerminalNode RPAREN() { return getToken(Java8Parser.RPAREN, 0); } public TypeArgumentsContext typeArguments() { return getRuleContext(TypeArgumentsContext.class,0); } @@ -13146,6 +13527,10 @@ public class Java8Parser extends Parser { public AnnotationContext annotation(int i) { return getRuleContext(AnnotationContext.class,i); } + public List DOT() { return getTokens(Java8Parser.DOT); } + public TerminalNode DOT(int i) { + return getToken(Java8Parser.DOT, i); + } public TypeArgumentsOrDiamondContext typeArgumentsOrDiamond() { return getRuleContext(TypeArgumentsOrDiamondContext.class,0); } @@ -13367,6 +13752,8 @@ public class Java8Parser extends Parser { public TypeArgumentsContext typeArguments() { return getRuleContext(TypeArgumentsContext.class,0); } + public TerminalNode LT() { return getToken(Java8Parser.LT, 0); } + public TerminalNode GT() { return getToken(Java8Parser.GT, 0); } public TypeArgumentsOrDiamondContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -13421,7 +13808,12 @@ public class Java8Parser extends Parser { public PrimaryContext primary() { return getRuleContext(PrimaryContext.class,0); } + public List DOT() { return getTokens(Java8Parser.DOT); } + public TerminalNode DOT(int i) { + return getToken(Java8Parser.DOT, i); + } public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public TerminalNode SUPER() { return getToken(Java8Parser.SUPER, 0); } public TypeNameContext typeName() { return getRuleContext(TypeNameContext.class,0); } @@ -13497,6 +13889,7 @@ public class Java8Parser extends Parser { } public static class FieldAccess_lf_primaryContext extends ParserRuleContext { + public TerminalNode DOT() { return getToken(Java8Parser.DOT, 0); } public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } public FieldAccess_lf_primaryContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); @@ -13536,6 +13929,11 @@ public class Java8Parser extends Parser { } public static class FieldAccess_lfno_primaryContext extends ParserRuleContext { + public TerminalNode SUPER() { return getToken(Java8Parser.SUPER, 0); } + public List DOT() { return getTokens(Java8Parser.DOT); } + public TerminalNode DOT(int i) { + return getToken(Java8Parser.DOT, i); + } public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } public TypeNameContext typeName() { return getRuleContext(TypeNameContext.class,0); @@ -13606,12 +14004,20 @@ public class Java8Parser extends Parser { public ExpressionNameContext expressionName() { return getRuleContext(ExpressionNameContext.class,0); } + public List LBRACK() { return getTokens(Java8Parser.LBRACK); } + public TerminalNode LBRACK(int i) { + return getToken(Java8Parser.LBRACK, i); + } public List expression() { return getRuleContexts(ExpressionContext.class); } public ExpressionContext expression(int i) { return getRuleContext(ExpressionContext.class,i); } + public List RBRACK() { return getTokens(Java8Parser.RBRACK); } + public TerminalNode RBRACK(int i) { + return getToken(Java8Parser.RBRACK, i); + } public PrimaryNoNewArray_lfno_arrayAccessContext primaryNoNewArray_lfno_arrayAccess() { return getRuleContext(PrimaryNoNewArray_lfno_arrayAccessContext.class,0); } @@ -13707,12 +14113,20 @@ public class Java8Parser extends Parser { public PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary() { return getRuleContext(PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext.class,0); } + public List LBRACK() { return getTokens(Java8Parser.LBRACK); } + public TerminalNode LBRACK(int i) { + return getToken(Java8Parser.LBRACK, i); + } public List expression() { return getRuleContexts(ExpressionContext.class); } public ExpressionContext expression(int i) { return getRuleContext(ExpressionContext.class,i); } + public List RBRACK() { return getTokens(Java8Parser.RBRACK); } + public TerminalNode RBRACK(int i) { + return getToken(Java8Parser.RBRACK, i); + } public List primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary() { return getRuleContexts(PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext.class); } @@ -13753,7 +14167,7 @@ public class Java8Parser extends Parser { setState(2284); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,250,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { @@ -13789,12 +14203,20 @@ public class Java8Parser extends Parser { public ExpressionNameContext expressionName() { return getRuleContext(ExpressionNameContext.class,0); } + public List LBRACK() { return getTokens(Java8Parser.LBRACK); } + public TerminalNode LBRACK(int i) { + return getToken(Java8Parser.LBRACK, i); + } public List expression() { return getRuleContexts(ExpressionContext.class); } public ExpressionContext expression(int i) { return getRuleContext(ExpressionContext.class,i); } + public List RBRACK() { return getTokens(Java8Parser.RBRACK); } + public TerminalNode RBRACK(int i) { + return getToken(Java8Parser.RBRACK, i); + } public PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary() { return getRuleContext(PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext.class,0); } @@ -13856,7 +14278,7 @@ public class Java8Parser extends Parser { setState(2306); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,252,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { @@ -13892,12 +14314,18 @@ public class Java8Parser extends Parser { public MethodNameContext methodName() { return getRuleContext(MethodNameContext.class,0); } + public TerminalNode LPAREN() { return getToken(Java8Parser.LPAREN, 0); } + public TerminalNode RPAREN() { return getToken(Java8Parser.RPAREN, 0); } public ArgumentListContext argumentList() { return getRuleContext(ArgumentListContext.class,0); } public TypeNameContext typeName() { return getRuleContext(TypeNameContext.class,0); } + public List DOT() { return getTokens(Java8Parser.DOT); } + public TerminalNode DOT(int i) { + return getToken(Java8Parser.DOT, i); + } public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } public TypeArgumentsContext typeArguments() { return getRuleContext(TypeArgumentsContext.class,0); @@ -13908,6 +14336,7 @@ public class Java8Parser extends Parser { public PrimaryContext primary() { return getRuleContext(PrimaryContext.class,0); } + public TerminalNode SUPER() { return getToken(Java8Parser.SUPER, 0); } public MethodInvocationContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -14144,7 +14573,10 @@ public class Java8Parser extends Parser { } public static class MethodInvocation_lf_primaryContext extends ParserRuleContext { + public TerminalNode DOT() { return getToken(Java8Parser.DOT, 0); } public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public TerminalNode LPAREN() { return getToken(Java8Parser.LPAREN, 0); } + public TerminalNode RPAREN() { return getToken(Java8Parser.RPAREN, 0); } public TypeArgumentsContext typeArguments() { return getRuleContext(TypeArgumentsContext.class,0); } @@ -14217,12 +14649,18 @@ public class Java8Parser extends Parser { public MethodNameContext methodName() { return getRuleContext(MethodNameContext.class,0); } + public TerminalNode LPAREN() { return getToken(Java8Parser.LPAREN, 0); } + public TerminalNode RPAREN() { return getToken(Java8Parser.RPAREN, 0); } public ArgumentListContext argumentList() { return getRuleContext(ArgumentListContext.class,0); } public TypeNameContext typeName() { return getRuleContext(TypeNameContext.class,0); } + public List DOT() { return getTokens(Java8Parser.DOT); } + public TerminalNode DOT(int i) { + return getToken(Java8Parser.DOT, i); + } public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } public TypeArgumentsContext typeArguments() { return getRuleContext(TypeArgumentsContext.class,0); @@ -14230,6 +14668,7 @@ public class Java8Parser extends Parser { public ExpressionNameContext expressionName() { return getRuleContext(ExpressionNameContext.class,0); } + public TerminalNode SUPER() { return getToken(Java8Parser.SUPER, 0); } public MethodInvocation_lfno_primaryContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -14437,6 +14876,10 @@ public class Java8Parser extends Parser { public ExpressionContext expression(int i) { return getRuleContext(ExpressionContext.class,i); } + public List COMMA() { return getTokens(Java8Parser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(Java8Parser.COMMA, i); + } public ArgumentListContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -14493,6 +14936,7 @@ public class Java8Parser extends Parser { public ExpressionNameContext expressionName() { return getRuleContext(ExpressionNameContext.class,0); } + public TerminalNode COLONCOLON() { return getToken(Java8Parser.COLONCOLON, 0); } public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } public TypeArgumentsContext typeArguments() { return getRuleContext(TypeArgumentsContext.class,0); @@ -14503,12 +14947,15 @@ public class Java8Parser extends Parser { public PrimaryContext primary() { return getRuleContext(PrimaryContext.class,0); } + public TerminalNode SUPER() { return getToken(Java8Parser.SUPER, 0); } public TypeNameContext typeName() { return getRuleContext(TypeNameContext.class,0); } + public TerminalNode DOT() { return getToken(Java8Parser.DOT, 0); } public ClassTypeContext classType() { return getRuleContext(ClassTypeContext.class,0); } + public TerminalNode NEW() { return getToken(Java8Parser.NEW, 0); } public ArrayTypeContext arrayType() { return getRuleContext(ArrayTypeContext.class,0); } @@ -14689,6 +15136,7 @@ public class Java8Parser extends Parser { } public static class MethodReference_lf_primaryContext extends ParserRuleContext { + public TerminalNode COLONCOLON() { return getToken(Java8Parser.COLONCOLON, 0); } public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } public TypeArgumentsContext typeArguments() { return getRuleContext(TypeArgumentsContext.class,0); @@ -14745,6 +15193,7 @@ public class Java8Parser extends Parser { public ExpressionNameContext expressionName() { return getRuleContext(ExpressionNameContext.class,0); } + public TerminalNode COLONCOLON() { return getToken(Java8Parser.COLONCOLON, 0); } public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } public TypeArgumentsContext typeArguments() { return getRuleContext(TypeArgumentsContext.class,0); @@ -14752,12 +15201,15 @@ public class Java8Parser extends Parser { public ReferenceTypeContext referenceType() { return getRuleContext(ReferenceTypeContext.class,0); } + public TerminalNode SUPER() { return getToken(Java8Parser.SUPER, 0); } public TypeNameContext typeName() { return getRuleContext(TypeNameContext.class,0); } + public TerminalNode DOT() { return getToken(Java8Parser.DOT, 0); } public ClassTypeContext classType() { return getRuleContext(ClassTypeContext.class,0); } + public TerminalNode NEW() { return getToken(Java8Parser.NEW, 0); } public ArrayTypeContext arrayType() { return getRuleContext(ArrayTypeContext.class,0); } @@ -14917,6 +15369,7 @@ public class Java8Parser extends Parser { } public static class ArrayCreationExpressionContext extends ParserRuleContext { + public TerminalNode NEW() { return getToken(Java8Parser.NEW, 0); } public PrimitiveTypeContext primitiveType() { return getRuleContext(PrimitiveTypeContext.class,0); } @@ -15067,7 +15520,7 @@ public class Java8Parser extends Parser { setState(2581); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,295,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { @@ -15094,9 +15547,11 @@ public class Java8Parser extends Parser { } public static class DimExprContext extends ParserRuleContext { + public TerminalNode LBRACK() { return getToken(Java8Parser.LBRACK, 0); } public ExpressionContext expression() { return getRuleContext(ExpressionContext.class,0); } + public TerminalNode RBRACK() { return getToken(Java8Parser.RBRACK, 0); } public List annotation() { return getRuleContexts(AnnotationContext.class); } @@ -15255,6 +15710,7 @@ public class Java8Parser extends Parser { public LambdaParametersContext lambdaParameters() { return getRuleContext(LambdaParametersContext.class,0); } + public TerminalNode ARROW() { return getToken(Java8Parser.ARROW, 0); } public LambdaBodyContext lambdaBody() { return getRuleContext(LambdaBodyContext.class,0); } @@ -15299,6 +15755,8 @@ public class Java8Parser extends Parser { public static class LambdaParametersContext extends ParserRuleContext { public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public TerminalNode LPAREN() { return getToken(Java8Parser.LPAREN, 0); } + public TerminalNode RPAREN() { return getToken(Java8Parser.RPAREN, 0); } public FormalParameterListContext formalParameterList() { return getRuleContext(FormalParameterListContext.class,0); } @@ -15370,6 +15828,10 @@ public class Java8Parser extends Parser { public TerminalNode Identifier(int i) { return getToken(Java8Parser.Identifier, i); } + public List COMMA() { return getTokens(Java8Parser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(Java8Parser.COMMA, i); + } public InferredFormalParameterListContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -15675,6 +16137,18 @@ public class Java8Parser extends Parser { } public static class AssignmentOperatorContext extends ParserRuleContext { + public TerminalNode ASSIGN() { return getToken(Java8Parser.ASSIGN, 0); } + public TerminalNode MUL_ASSIGN() { return getToken(Java8Parser.MUL_ASSIGN, 0); } + public TerminalNode DIV_ASSIGN() { return getToken(Java8Parser.DIV_ASSIGN, 0); } + public TerminalNode MOD_ASSIGN() { return getToken(Java8Parser.MOD_ASSIGN, 0); } + public TerminalNode ADD_ASSIGN() { return getToken(Java8Parser.ADD_ASSIGN, 0); } + public TerminalNode SUB_ASSIGN() { return getToken(Java8Parser.SUB_ASSIGN, 0); } + public TerminalNode LSHIFT_ASSIGN() { return getToken(Java8Parser.LSHIFT_ASSIGN, 0); } + public TerminalNode RSHIFT_ASSIGN() { return getToken(Java8Parser.RSHIFT_ASSIGN, 0); } + public TerminalNode URSHIFT_ASSIGN() { return getToken(Java8Parser.URSHIFT_ASSIGN, 0); } + public TerminalNode AND_ASSIGN() { return getToken(Java8Parser.AND_ASSIGN, 0); } + public TerminalNode XOR_ASSIGN() { return getToken(Java8Parser.XOR_ASSIGN, 0); } + public TerminalNode OR_ASSIGN() { return getToken(Java8Parser.OR_ASSIGN, 0); } public AssignmentOperatorContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -15723,9 +16197,11 @@ public class Java8Parser extends Parser { public ConditionalOrExpressionContext conditionalOrExpression() { return getRuleContext(ConditionalOrExpressionContext.class,0); } + public TerminalNode QUESTION() { return getToken(Java8Parser.QUESTION, 0); } public ExpressionContext expression() { return getRuleContext(ExpressionContext.class,0); } + public TerminalNode COLON() { return getToken(Java8Parser.COLON, 0); } public ConditionalExpressionContext conditionalExpression() { return getRuleContext(ConditionalExpressionContext.class,0); } @@ -15792,6 +16268,7 @@ public class Java8Parser extends Parser { public ConditionalOrExpressionContext conditionalOrExpression() { return getRuleContext(ConditionalOrExpressionContext.class,0); } + public TerminalNode OR() { return getToken(Java8Parser.OR, 0); } public ConditionalOrExpressionContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -15829,7 +16306,7 @@ public class Java8Parser extends Parser { setState(2656); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,305,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { if ( _parseListeners!=null ) triggerExitRuleEvent(); _prevctx = _localctx; @@ -15870,6 +16347,7 @@ public class Java8Parser extends Parser { public ConditionalAndExpressionContext conditionalAndExpression() { return getRuleContext(ConditionalAndExpressionContext.class,0); } + public TerminalNode AND() { return getToken(Java8Parser.AND, 0); } public ConditionalAndExpressionContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -15907,7 +16385,7 @@ public class Java8Parser extends Parser { setState(2667); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,306,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { if ( _parseListeners!=null ) triggerExitRuleEvent(); _prevctx = _localctx; @@ -15948,6 +16426,7 @@ public class Java8Parser extends Parser { public InclusiveOrExpressionContext inclusiveOrExpression() { return getRuleContext(InclusiveOrExpressionContext.class,0); } + public TerminalNode BITOR() { return getToken(Java8Parser.BITOR, 0); } public InclusiveOrExpressionContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -15985,7 +16464,7 @@ public class Java8Parser extends Parser { setState(2678); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,307,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { if ( _parseListeners!=null ) triggerExitRuleEvent(); _prevctx = _localctx; @@ -16026,6 +16505,7 @@ public class Java8Parser extends Parser { public ExclusiveOrExpressionContext exclusiveOrExpression() { return getRuleContext(ExclusiveOrExpressionContext.class,0); } + public TerminalNode CARET() { return getToken(Java8Parser.CARET, 0); } public ExclusiveOrExpressionContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -16063,7 +16543,7 @@ public class Java8Parser extends Parser { setState(2689); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,308,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { if ( _parseListeners!=null ) triggerExitRuleEvent(); _prevctx = _localctx; @@ -16104,6 +16584,7 @@ public class Java8Parser extends Parser { public AndExpressionContext andExpression() { return getRuleContext(AndExpressionContext.class,0); } + public TerminalNode BITAND() { return getToken(Java8Parser.BITAND, 0); } public AndExpressionContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -16141,7 +16622,7 @@ public class Java8Parser extends Parser { setState(2700); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,309,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { if ( _parseListeners!=null ) triggerExitRuleEvent(); _prevctx = _localctx; @@ -16182,6 +16663,8 @@ public class Java8Parser extends Parser { public EqualityExpressionContext equalityExpression() { return getRuleContext(EqualityExpressionContext.class,0); } + public TerminalNode EQUAL() { return getToken(Java8Parser.EQUAL, 0); } + public TerminalNode NOTEQUAL() { return getToken(Java8Parser.NOTEQUAL, 0); } public EqualityExpressionContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -16219,7 +16702,7 @@ public class Java8Parser extends Parser { setState(2714); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,311,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { if ( _parseListeners!=null ) triggerExitRuleEvent(); _prevctx = _localctx; @@ -16278,6 +16761,11 @@ public class Java8Parser extends Parser { public RelationalExpressionContext relationalExpression() { return getRuleContext(RelationalExpressionContext.class,0); } + public TerminalNode LT() { return getToken(Java8Parser.LT, 0); } + public TerminalNode GT() { return getToken(Java8Parser.GT, 0); } + public TerminalNode LE() { return getToken(Java8Parser.LE, 0); } + public TerminalNode GE() { return getToken(Java8Parser.GE, 0); } + public TerminalNode INSTANCEOF() { return getToken(Java8Parser.INSTANCEOF, 0); } public ReferenceTypeContext referenceType() { return getRuleContext(ReferenceTypeContext.class,0); } @@ -16318,7 +16806,7 @@ public class Java8Parser extends Parser { setState(2737); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,313,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { if ( _parseListeners!=null ) triggerExitRuleEvent(); _prevctx = _localctx; @@ -16413,6 +16901,14 @@ public class Java8Parser extends Parser { public ShiftExpressionContext shiftExpression() { return getRuleContext(ShiftExpressionContext.class,0); } + public List LT() { return getTokens(Java8Parser.LT); } + public TerminalNode LT(int i) { + return getToken(Java8Parser.LT, i); + } + public List GT() { return getTokens(Java8Parser.GT); } + public TerminalNode GT(int i) { + return getToken(Java8Parser.GT, i); + } public ShiftExpressionContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -16450,7 +16946,7 @@ public class Java8Parser extends Parser { setState(2758); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,315,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { if ( _parseListeners!=null ) triggerExitRuleEvent(); _prevctx = _localctx; @@ -16529,6 +17025,8 @@ public class Java8Parser extends Parser { public AdditiveExpressionContext additiveExpression() { return getRuleContext(AdditiveExpressionContext.class,0); } + public TerminalNode ADD() { return getToken(Java8Parser.ADD, 0); } + public TerminalNode SUB() { return getToken(Java8Parser.SUB, 0); } public AdditiveExpressionContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -16566,7 +17064,7 @@ public class Java8Parser extends Parser { setState(2772); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,317,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { if ( _parseListeners!=null ) triggerExitRuleEvent(); _prevctx = _localctx; @@ -16625,6 +17123,9 @@ public class Java8Parser extends Parser { public MultiplicativeExpressionContext multiplicativeExpression() { return getRuleContext(MultiplicativeExpressionContext.class,0); } + public TerminalNode MUL() { return getToken(Java8Parser.MUL, 0); } + public TerminalNode DIV() { return getToken(Java8Parser.DIV, 0); } + public TerminalNode MOD() { return getToken(Java8Parser.MOD, 0); } public MultiplicativeExpressionContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -16662,7 +17163,7 @@ public class Java8Parser extends Parser { setState(2789); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,319,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { if ( _parseListeners!=null ) triggerExitRuleEvent(); _prevctx = _localctx; @@ -16733,9 +17234,11 @@ public class Java8Parser extends Parser { public PreDecrementExpressionContext preDecrementExpression() { return getRuleContext(PreDecrementExpressionContext.class,0); } + public TerminalNode ADD() { return getToken(Java8Parser.ADD, 0); } public UnaryExpressionContext unaryExpression() { return getRuleContext(UnaryExpressionContext.class,0); } + public TerminalNode SUB() { return getToken(Java8Parser.SUB, 0); } public UnaryExpressionNotPlusMinusContext unaryExpressionNotPlusMinus() { return getRuleContext(UnaryExpressionNotPlusMinusContext.class,0); } @@ -16837,6 +17340,7 @@ public class Java8Parser extends Parser { } public static class PreIncrementExpressionContext extends ParserRuleContext { + public TerminalNode INC() { return getToken(Java8Parser.INC, 0); } public UnaryExpressionContext unaryExpression() { return getRuleContext(UnaryExpressionContext.class,0); } @@ -16878,6 +17382,7 @@ public class Java8Parser extends Parser { } public static class PreDecrementExpressionContext extends ParserRuleContext { + public TerminalNode DEC() { return getToken(Java8Parser.DEC, 0); } public UnaryExpressionContext unaryExpression() { return getRuleContext(UnaryExpressionContext.class,0); } @@ -16922,9 +17427,11 @@ public class Java8Parser extends Parser { public PostfixExpressionContext postfixExpression() { return getRuleContext(PostfixExpressionContext.class,0); } + public TerminalNode TILDE() { return getToken(Java8Parser.TILDE, 0); } public UnaryExpressionContext unaryExpression() { return getRuleContext(UnaryExpressionContext.class,0); } + public TerminalNode BANG() { return getToken(Java8Parser.BANG, 0); } public CastExpressionContext castExpression() { return getRuleContext(CastExpressionContext.class,0); } @@ -17053,7 +17560,7 @@ public class Java8Parser extends Parser { setState(2823); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,324,_ctx); - while ( _alt!=2 && _alt!= ATN.INVALID_ALT_NUMBER ) { + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { setState(2821); @@ -17097,6 +17604,7 @@ public class Java8Parser extends Parser { public PostfixExpressionContext postfixExpression() { return getRuleContext(PostfixExpressionContext.class,0); } + public TerminalNode INC() { return getToken(Java8Parser.INC, 0); } public PostIncrementExpressionContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -17135,6 +17643,7 @@ public class Java8Parser extends Parser { } public static class PostIncrementExpression_lf_postfixExpressionContext extends ParserRuleContext { + public TerminalNode INC() { return getToken(Java8Parser.INC, 0); } public PostIncrementExpression_lf_postfixExpressionContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -17174,6 +17683,7 @@ public class Java8Parser extends Parser { public PostfixExpressionContext postfixExpression() { return getRuleContext(PostfixExpressionContext.class,0); } + public TerminalNode DEC() { return getToken(Java8Parser.DEC, 0); } public PostDecrementExpressionContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -17212,6 +17722,7 @@ public class Java8Parser extends Parser { } public static class PostDecrementExpression_lf_postfixExpressionContext extends ParserRuleContext { + public TerminalNode DEC() { return getToken(Java8Parser.DEC, 0); } public PostDecrementExpression_lf_postfixExpressionContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @@ -17248,9 +17759,11 @@ public class Java8Parser extends Parser { } public static class CastExpressionContext extends ParserRuleContext { + public TerminalNode LPAREN() { return getToken(Java8Parser.LPAREN, 0); } public PrimitiveTypeContext primitiveType() { return getRuleContext(PrimitiveTypeContext.class,0); } + public TerminalNode RPAREN() { return getToken(Java8Parser.RPAREN, 0); } public UnaryExpressionContext unaryExpression() { return getRuleContext(UnaryExpressionContext.class,0); }