Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
chapi.ast.antlr.TypeScriptParser Maven / Gradle / Ivy
// Generated from TypeScriptParser.g4 by ANTLR 4.9.3
package chapi.ast.antlr;
import org.antlr.v4.runtime.atn.*;
import org.antlr.v4.runtime.dfa.DFA;
import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.misc.*;
import org.antlr.v4.runtime.tree.*;
import java.util.List;
import java.util.Iterator;
import java.util.ArrayList;
@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
public class TypeScriptParser extends TypeScriptParserBase {
static { RuntimeMetaData.checkVersion("4.9.3", RuntimeMetaData.VERSION); }
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
JsxComment=1, MultiLineComment=2, SingleLineComment=3, RegularExpressionLiteral=4,
OpenBracket=5, CloseBracket=6, OpenParen=7, CloseParen=8, OpenBrace=9,
TemplateCloseBrace=10, CloseBrace=11, SemiColon=12, Comma=13, Assign=14,
QuestionMark=15, Colon=16, Ellipsis=17, Dot=18, PlusPlus=19, MinusMinus=20,
Plus=21, Minus=22, BitNot=23, Not=24, Multiply=25, Divide=26, Modulus=27,
Power=28, NullCoalesce=29, Hashtag=30, RightShiftArithmetic=31, LeftShiftArithmetic=32,
RightShiftLogical=33, LessThan=34, MoreThan=35, LessThanEquals=36, GreaterThanEquals=37,
Equals_=38, NotEquals=39, IdentityEquals=40, IdentityNotEquals=41, BitAnd=42,
BitXOr=43, BitOr=44, And=45, Or=46, MultiplyAssign=47, DivideAssign=48,
ModulusAssign=49, PlusAssign=50, MinusAssign=51, LeftShiftArithmeticAssign=52,
RightShiftArithmeticAssign=53, RightShiftLogicalAssign=54, BitAndAssign=55,
BitXorAssign=56, BitOrAssign=57, ARROW=58, Lodash=59, Dollar=60, NullLiteral=61,
BooleanLiteral=62, DecimalLiteral=63, HexIntegerLiteral=64, OctalIntegerLiteral=65,
OctalIntegerLiteral2=66, BinaryIntegerLiteral=67, Break=68, Do=69, Instanceof=70,
Typeof=71, Keyof=72, Case=73, Else=74, New=75, Var=76, Catch=77, Finally=78,
Return=79, Void=80, Continue=81, For=82, Switch=83, While=84, Debugger=85,
Function_=86, This=87, With=88, Default=89, If=90, Throw=91, Delete=92,
In=93, Try=94, As=95, From=96, ReadOnly=97, Async=98, Of=99, Await=100,
Class=101, Enum=102, Extends=103, Super=104, Const=105, Export=106, Import=107,
Implements=108, Let=109, Private=110, Public=111, Interface=112, Package=113,
Protected=114, Static=115, Yield=116, Any=117, Number=118, Boolean=119,
String=120, Symbol=121, TypeAlias=122, Get=123, Set=124, Constructor=125,
Namespace=126, Require=127, Module=128, Declare=129, Unknown=130, Undefined=131,
Abstract=132, Is=133, At=134, Identifier=135, StringLiteral=136, BackTick=137,
WhiteSpaces=138, LineTerminator=139, HtmlComment=140, CDataComment=141,
UnexpectedCharacter=142, TemplateStringStartExpression=143, TemplateStringAtom=144,
TagOpen=145, TagClose=146, TagSlashClose=147, TagSlash=148, TagName=149,
AttributeValue=150, Attribute=151;
public static final int
RULE_initializer = 0, RULE_bindingPattern = 1, RULE_typeParameters = 2,
RULE_typeParameterList = 3, RULE_typeParameter = 4, RULE_constraint = 5,
RULE_typeArguments = 6, RULE_typeArgumentList = 7, RULE_typeArgument = 8,
RULE_type_ = 9, RULE_unionOrIntersectionOrPrimaryType = 10, RULE_primaryType = 11,
RULE_predefinedType = 12, RULE_typeReference = 13, RULE_nestedTypeGeneric = 14,
RULE_typeGeneric = 15, RULE_typeIncludeGeneric = 16, RULE_typeName = 17,
RULE_objectType = 18, RULE_typeBody = 19, RULE_typeMemberList = 20, RULE_typeMember = 21,
RULE_arrayType = 22, RULE_tupleType = 23, RULE_tupleElementTypes = 24,
RULE_functionType = 25, RULE_constructorType = 26, RULE_typeQuery = 27,
RULE_typeQueryExpression = 28, RULE_propertySignature = 29, RULE_typeAnnotation = 30,
RULE_callSignature = 31, RULE_parameterList = 32, RULE_parameter = 33,
RULE_requiredParameter = 34, RULE_optionalParameter = 35, RULE_restParameter = 36,
RULE_identifierOrPattern = 37, RULE_accessibilityModifier = 38, RULE_constructSignature = 39,
RULE_indexSignature = 40, RULE_enumSignature = 41, RULE_methodSignature = 42,
RULE_typeAliasDeclaration = 43, RULE_constructorDeclaration = 44, RULE_interfaceDeclaration = 45,
RULE_interfaceExtendsClause = 46, RULE_classOrInterfaceTypeList = 47,
RULE_enumDeclaration = 48, RULE_enumBody = 49, RULE_enumMemberList = 50,
RULE_enumMember = 51, RULE_namespaceDeclaration = 52, RULE_namespaceName = 53,
RULE_importAliasDeclaration = 54, RULE_importAll = 55, RULE_decoratorList = 56,
RULE_decorator = 57, RULE_decoratorMemberExpression = 58, RULE_decoratorCallExpression = 59,
RULE_program = 60, RULE_sourceElement = 61, RULE_statement = 62, RULE_block = 63,
RULE_statementList = 64, RULE_abstractDeclaration = 65, RULE_importStatement = 66,
RULE_fromBlock = 67, RULE_moduleItems = 68, RULE_importDefault = 69, RULE_aliasName = 70,
RULE_importNamespace = 71, RULE_exportStatement = 72, RULE_importFrom = 73,
RULE_exportFromBlock = 74, RULE_declaration = 75, RULE_variableStatement = 76,
RULE_variableDeclarationList = 77, RULE_variableDeclaration = 78, RULE_emptyStatement_ = 79,
RULE_expressionStatement = 80, RULE_ifStatement = 81, RULE_iterationStatement = 82,
RULE_varModifier = 83, RULE_continueStatement = 84, RULE_breakStatement = 85,
RULE_returnStatement = 86, RULE_htmlElements = 87, RULE_htmlElement = 88,
RULE_htmlContent = 89, RULE_htmlTagStartName = 90, RULE_htmlTagClosingName = 91,
RULE_htmlTagName = 92, RULE_htmlAttribute = 93, RULE_htmlAttributeName = 94,
RULE_htmlChardata = 95, RULE_htmlAttributeValue = 96, RULE_objectExpressionSequence = 97,
RULE_yieldStatement = 98, RULE_withStatement = 99, RULE_switchStatement = 100,
RULE_caseBlock = 101, RULE_caseClauses = 102, RULE_caseClause = 103, RULE_defaultClause = 104,
RULE_labelledStatement = 105, RULE_throwStatement = 106, RULE_tryStatement = 107,
RULE_catchProduction = 108, RULE_finallyProduction = 109, RULE_debuggerStatement = 110,
RULE_functionDeclaration = 111, RULE_classDeclaration = 112, RULE_classHeritage = 113,
RULE_classTail = 114, RULE_classExtendsClause = 115, RULE_implementsClause = 116,
RULE_classElement = 117, RULE_propertyMemberDeclaration = 118, RULE_propertyMemberBase = 119,
RULE_indexMemberDeclaration = 120, RULE_generatorMethod = 121, RULE_generatorFunctionDeclaration = 122,
RULE_generatorBlock = 123, RULE_generatorDefinition = 124, RULE_iteratorBlock = 125,
RULE_iteratorDefinition = 126, RULE_formalParameterList = 127, RULE_formalParameterArg = 128,
RULE_lastFormalParameterArg = 129, RULE_functionBody = 130, RULE_sourceElements = 131,
RULE_arrayLiteral = 132, RULE_elementList = 133, RULE_arrayElement = 134,
RULE_objectLiteral = 135, RULE_propertyAssignment = 136, RULE_getAccessor = 137,
RULE_setAccessor = 138, RULE_propertyName = 139, RULE_arguments = 140,
RULE_argumentList = 141, RULE_argument = 142, RULE_expressionSequence = 143,
RULE_functionExpressionDeclaration = 144, RULE_jsxArrowFunction = 145,
RULE_singleExpression = 146, RULE_asExpression = 147, RULE_arrowFunctionDeclaration = 148,
RULE_arrowFunctionParameters = 149, RULE_arrowFunctionBody = 150, RULE_assignmentOperator = 151,
RULE_literal = 152, RULE_templateStringLiteral = 153, RULE_templateStringAtom = 154,
RULE_numericLiteral = 155, RULE_identifierName = 156, RULE_identifierOrKeyWord = 157,
RULE_defaultKeyWord = 158, RULE_reservedWord = 159, RULE_keyword = 160,
RULE_getter = 161, RULE_setter = 162, RULE_eos = 163;
private static String[] makeRuleNames() {
return new String[] {
"initializer", "bindingPattern", "typeParameters", "typeParameterList",
"typeParameter", "constraint", "typeArguments", "typeArgumentList", "typeArgument",
"type_", "unionOrIntersectionOrPrimaryType", "primaryType", "predefinedType",
"typeReference", "nestedTypeGeneric", "typeGeneric", "typeIncludeGeneric",
"typeName", "objectType", "typeBody", "typeMemberList", "typeMember",
"arrayType", "tupleType", "tupleElementTypes", "functionType", "constructorType",
"typeQuery", "typeQueryExpression", "propertySignature", "typeAnnotation",
"callSignature", "parameterList", "parameter", "requiredParameter", "optionalParameter",
"restParameter", "identifierOrPattern", "accessibilityModifier", "constructSignature",
"indexSignature", "enumSignature", "methodSignature", "typeAliasDeclaration",
"constructorDeclaration", "interfaceDeclaration", "interfaceExtendsClause",
"classOrInterfaceTypeList", "enumDeclaration", "enumBody", "enumMemberList",
"enumMember", "namespaceDeclaration", "namespaceName", "importAliasDeclaration",
"importAll", "decoratorList", "decorator", "decoratorMemberExpression",
"decoratorCallExpression", "program", "sourceElement", "statement", "block",
"statementList", "abstractDeclaration", "importStatement", "fromBlock",
"moduleItems", "importDefault", "aliasName", "importNamespace", "exportStatement",
"importFrom", "exportFromBlock", "declaration", "variableStatement",
"variableDeclarationList", "variableDeclaration", "emptyStatement_",
"expressionStatement", "ifStatement", "iterationStatement", "varModifier",
"continueStatement", "breakStatement", "returnStatement", "htmlElements",
"htmlElement", "htmlContent", "htmlTagStartName", "htmlTagClosingName",
"htmlTagName", "htmlAttribute", "htmlAttributeName", "htmlChardata",
"htmlAttributeValue", "objectExpressionSequence", "yieldStatement", "withStatement",
"switchStatement", "caseBlock", "caseClauses", "caseClause", "defaultClause",
"labelledStatement", "throwStatement", "tryStatement", "catchProduction",
"finallyProduction", "debuggerStatement", "functionDeclaration", "classDeclaration",
"classHeritage", "classTail", "classExtendsClause", "implementsClause",
"classElement", "propertyMemberDeclaration", "propertyMemberBase", "indexMemberDeclaration",
"generatorMethod", "generatorFunctionDeclaration", "generatorBlock",
"generatorDefinition", "iteratorBlock", "iteratorDefinition", "formalParameterList",
"formalParameterArg", "lastFormalParameterArg", "functionBody", "sourceElements",
"arrayLiteral", "elementList", "arrayElement", "objectLiteral", "propertyAssignment",
"getAccessor", "setAccessor", "propertyName", "arguments", "argumentList",
"argument", "expressionSequence", "functionExpressionDeclaration", "jsxArrowFunction",
"singleExpression", "asExpression", "arrowFunctionDeclaration", "arrowFunctionParameters",
"arrowFunctionBody", "assignmentOperator", "literal", "templateStringLiteral",
"templateStringAtom", "numericLiteral", "identifierName", "identifierOrKeyWord",
"defaultKeyWord", "reservedWord", "keyword", "getter", "setter", "eos"
};
}
public static final String[] ruleNames = makeRuleNames();
private static String[] makeLiteralNames() {
return new String[] {
null, null, null, null, null, "'['", "']'", "'('", "')'", "'{'", null,
"'}'", "';'", "','", "'='", "'?'", "':'", "'...'", "'.'", "'++'", "'--'",
"'+'", "'-'", "'~'", "'!'", "'*'", "'/'", "'%'", "'**'", "'??'", "'#'",
"'>>'", "'<<'", "'>>>'", "'<'", "'>'", "'<='", "'>='", "'=='", "'!='",
"'==='", "'!=='", "'&'", "'^'", "'|'", "'&&'", "'||'", "'*='", "'/='",
"'%='", "'+='", "'-='", "'<<='", "'>>='", "'>>>='", "'&='", "'^='", "'|='",
"'=>'", "'_'", "'$'", "'null'", null, null, null, null, null, null, "'break'",
"'do'", "'instanceof'", "'typeof'", "'keyof'", "'case'", "'else'", "'new'",
"'var'", "'catch'", "'finally'", "'return'", "'void'", "'continue'",
"'for'", "'switch'", "'while'", "'debugger'", "'function'", "'this'",
"'with'", "'default'", "'if'", "'throw'", "'delete'", "'in'", "'try'",
"'as'", "'from'", "'readonly'", "'async'", "'of'", "'await'", "'class'",
"'enum'", "'extends'", "'super'", "'const'", "'export'", "'import'",
"'implements'", "'let'", "'private'", "'public'", "'interface'", "'package'",
"'protected'", "'static'", "'yield'", "'any'", "'number'", "'boolean'",
"'string'", "'symbol'", "'type'", "'get'", "'set'", "'constructor'",
"'namespace'", "'require'", "'module'", "'declare'", "'unknown'", "'undefined'",
"'abstract'", "'is'", "'@'", null, null, null, null, null, null, null,
null, "'${'", null, null, null, "'/>'"
};
}
private static final String[] _LITERAL_NAMES = makeLiteralNames();
private static String[] makeSymbolicNames() {
return new String[] {
null, "JsxComment", "MultiLineComment", "SingleLineComment", "RegularExpressionLiteral",
"OpenBracket", "CloseBracket", "OpenParen", "CloseParen", "OpenBrace",
"TemplateCloseBrace", "CloseBrace", "SemiColon", "Comma", "Assign", "QuestionMark",
"Colon", "Ellipsis", "Dot", "PlusPlus", "MinusMinus", "Plus", "Minus",
"BitNot", "Not", "Multiply", "Divide", "Modulus", "Power", "NullCoalesce",
"Hashtag", "RightShiftArithmetic", "LeftShiftArithmetic", "RightShiftLogical",
"LessThan", "MoreThan", "LessThanEquals", "GreaterThanEquals", "Equals_",
"NotEquals", "IdentityEquals", "IdentityNotEquals", "BitAnd", "BitXOr",
"BitOr", "And", "Or", "MultiplyAssign", "DivideAssign", "ModulusAssign",
"PlusAssign", "MinusAssign", "LeftShiftArithmeticAssign", "RightShiftArithmeticAssign",
"RightShiftLogicalAssign", "BitAndAssign", "BitXorAssign", "BitOrAssign",
"ARROW", "Lodash", "Dollar", "NullLiteral", "BooleanLiteral", "DecimalLiteral",
"HexIntegerLiteral", "OctalIntegerLiteral", "OctalIntegerLiteral2", "BinaryIntegerLiteral",
"Break", "Do", "Instanceof", "Typeof", "Keyof", "Case", "Else", "New",
"Var", "Catch", "Finally", "Return", "Void", "Continue", "For", "Switch",
"While", "Debugger", "Function_", "This", "With", "Default", "If", "Throw",
"Delete", "In", "Try", "As", "From", "ReadOnly", "Async", "Of", "Await",
"Class", "Enum", "Extends", "Super", "Const", "Export", "Import", "Implements",
"Let", "Private", "Public", "Interface", "Package", "Protected", "Static",
"Yield", "Any", "Number", "Boolean", "String", "Symbol", "TypeAlias",
"Get", "Set", "Constructor", "Namespace", "Require", "Module", "Declare",
"Unknown", "Undefined", "Abstract", "Is", "At", "Identifier", "StringLiteral",
"BackTick", "WhiteSpaces", "LineTerminator", "HtmlComment", "CDataComment",
"UnexpectedCharacter", "TemplateStringStartExpression", "TemplateStringAtom",
"TagOpen", "TagClose", "TagSlashClose", "TagSlash", "TagName", "AttributeValue",
"Attribute"
};
}
private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames();
public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
/**
* @deprecated Use {@link #VOCABULARY} instead.
*/
@Deprecated
public static final String[] tokenNames;
static {
tokenNames = new String[_SYMBOLIC_NAMES.length];
for (int i = 0; i < tokenNames.length; i++) {
tokenNames[i] = VOCABULARY.getLiteralName(i);
if (tokenNames[i] == null) {
tokenNames[i] = VOCABULARY.getSymbolicName(i);
}
if (tokenNames[i] == null) {
tokenNames[i] = "";
}
}
}
@Override
@Deprecated
public String[] getTokenNames() {
return tokenNames;
}
@Override
public Vocabulary getVocabulary() {
return VOCABULARY;
}
@Override
public String getGrammarFileName() { return "TypeScriptParser.g4"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
public TypeScriptParser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
public static class InitializerContext extends ParserRuleContext {
public TerminalNode Assign() { return getToken(TypeScriptParser.Assign, 0); }
public SingleExpressionContext singleExpression() {
return getRuleContext(SingleExpressionContext.class,0);
}
public InitializerContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_initializer; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterInitializer(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitInitializer(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitInitializer(this);
else return visitor.visitChildren(this);
}
}
public final InitializerContext initializer() throws RecognitionException {
InitializerContext _localctx = new InitializerContext(_ctx, getState());
enterRule(_localctx, 0, RULE_initializer);
try {
enterOuterAlt(_localctx, 1);
{
setState(328);
match(Assign);
setState(329);
singleExpression(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BindingPatternContext extends ParserRuleContext {
public ArrayLiteralContext arrayLiteral() {
return getRuleContext(ArrayLiteralContext.class,0);
}
public ObjectLiteralContext objectLiteral() {
return getRuleContext(ObjectLiteralContext.class,0);
}
public BindingPatternContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_bindingPattern; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterBindingPattern(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitBindingPattern(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitBindingPattern(this);
else return visitor.visitChildren(this);
}
}
public final BindingPatternContext bindingPattern() throws RecognitionException {
BindingPatternContext _localctx = new BindingPatternContext(_ctx, getState());
enterRule(_localctx, 2, RULE_bindingPattern);
try {
enterOuterAlt(_localctx, 1);
{
setState(333);
_errHandler.sync(this);
switch (_input.LA(1)) {
case OpenBracket:
{
setState(331);
arrayLiteral();
}
break;
case OpenBrace:
{
setState(332);
objectLiteral();
}
break;
default:
throw new NoViableAltException(this);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeParametersContext extends ParserRuleContext {
public TerminalNode LessThan() { return getToken(TypeScriptParser.LessThan, 0); }
public TerminalNode MoreThan() { return getToken(TypeScriptParser.MoreThan, 0); }
public TypeParameterListContext typeParameterList() {
return getRuleContext(TypeParameterListContext.class,0);
}
public TypeParametersContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeParameters; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTypeParameters(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTypeParameters(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitTypeParameters(this);
else return visitor.visitChildren(this);
}
}
public final TypeParametersContext typeParameters() throws RecognitionException {
TypeParametersContext _localctx = new TypeParametersContext(_ctx, getState());
enterRule(_localctx, 4, RULE_typeParameters);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(335);
match(LessThan);
setState(337);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LessThan || _la==Identifier) {
{
setState(336);
typeParameterList();
}
}
setState(339);
match(MoreThan);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeParameterListContext extends ParserRuleContext {
public List typeParameter() {
return getRuleContexts(TypeParameterContext.class);
}
public TypeParameterContext typeParameter(int i) {
return getRuleContext(TypeParameterContext.class,i);
}
public List Comma() { return getTokens(TypeScriptParser.Comma); }
public TerminalNode Comma(int i) {
return getToken(TypeScriptParser.Comma, i);
}
public TypeParameterListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeParameterList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTypeParameterList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTypeParameterList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitTypeParameterList(this);
else return visitor.visitChildren(this);
}
}
public final TypeParameterListContext typeParameterList() throws RecognitionException {
TypeParameterListContext _localctx = new TypeParameterListContext(_ctx, getState());
enterRule(_localctx, 6, RULE_typeParameterList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(341);
typeParameter();
setState(346);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==Comma) {
{
{
setState(342);
match(Comma);
setState(343);
typeParameter();
}
}
setState(348);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeParameterContext extends ParserRuleContext {
public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); }
public ConstraintContext constraint() {
return getRuleContext(ConstraintContext.class,0);
}
public TerminalNode Assign() { return getToken(TypeScriptParser.Assign, 0); }
public ObjectTypeContext objectType() {
return getRuleContext(ObjectTypeContext.class,0);
}
public IdentifierOrKeyWordContext identifierOrKeyWord() {
return getRuleContext(IdentifierOrKeyWordContext.class,0);
}
public TypeIncludeGenericContext typeIncludeGeneric() {
return getRuleContext(TypeIncludeGenericContext.class,0);
}
public PrimaryTypeContext primaryType() {
return getRuleContext(PrimaryTypeContext.class,0);
}
public TypeParametersContext typeParameters() {
return getRuleContext(TypeParametersContext.class,0);
}
public TypeParameterContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeParameter; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTypeParameter(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTypeParameter(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitTypeParameter(this);
else return visitor.visitChildren(this);
}
}
public final TypeParameterContext typeParameter() throws RecognitionException {
TypeParameterContext _localctx = new TypeParameterContext(_ctx, getState());
enterRule(_localctx, 8, RULE_typeParameter);
int _la;
try {
setState(369);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,6,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(349);
match(Identifier);
setState(351);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Extends) {
{
setState(350);
constraint();
}
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(353);
match(Identifier);
setState(354);
match(Assign);
setState(355);
objectType();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(356);
match(Identifier);
setState(357);
match(Assign);
setState(358);
identifierOrKeyWord();
setState(360);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LessThan) {
{
setState(359);
typeIncludeGeneric();
}
}
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(362);
match(Identifier);
setState(363);
match(Assign);
setState(364);
primaryType(0);
setState(366);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LessThan) {
{
setState(365);
typeIncludeGeneric();
}
}
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(368);
typeParameters();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ConstraintContext extends ParserRuleContext {
public TerminalNode Extends() { return getToken(TypeScriptParser.Extends, 0); }
public Type_Context type_() {
return getRuleContext(Type_Context.class,0);
}
public ConstraintContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_constraint; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterConstraint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitConstraint(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitConstraint(this);
else return visitor.visitChildren(this);
}
}
public final ConstraintContext constraint() throws RecognitionException {
ConstraintContext _localctx = new ConstraintContext(_ctx, getState());
enterRule(_localctx, 10, RULE_constraint);
try {
enterOuterAlt(_localctx, 1);
{
setState(371);
match(Extends);
setState(372);
type_();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeArgumentsContext extends ParserRuleContext {
public TerminalNode LessThan() { return getToken(TypeScriptParser.LessThan, 0); }
public TerminalNode MoreThan() { return getToken(TypeScriptParser.MoreThan, 0); }
public TypeArgumentListContext typeArgumentList() {
return getRuleContext(TypeArgumentListContext.class,0);
}
public TypeArgumentsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeArguments; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTypeArguments(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTypeArguments(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitTypeArguments(this);
else return visitor.visitChildren(this);
}
}
public final TypeArgumentsContext typeArguments() throws RecognitionException {
TypeArgumentsContext _localctx = new TypeArgumentsContext(_ctx, getState());
enterRule(_localctx, 12, RULE_typeArguments);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(374);
match(LessThan);
setState(376);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << OpenBracket) | (1L << OpenParen) | (1L << OpenBrace) | (1L << LessThan) | (1L << BitOr) | (1L << Lodash) | (1L << Dollar) | (1L << NullLiteral) | (1L << BooleanLiteral) | (1L << DecimalLiteral))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (HexIntegerLiteral - 64)) | (1L << (OctalIntegerLiteral - 64)) | (1L << (OctalIntegerLiteral2 - 64)) | (1L << (BinaryIntegerLiteral - 64)) | (1L << (Break - 64)) | (1L << (Do - 64)) | (1L << (Instanceof - 64)) | (1L << (Typeof - 64)) | (1L << (Keyof - 64)) | (1L << (Case - 64)) | (1L << (Else - 64)) | (1L << (New - 64)) | (1L << (Var - 64)) | (1L << (Catch - 64)) | (1L << (Finally - 64)) | (1L << (Return - 64)) | (1L << (Void - 64)) | (1L << (Continue - 64)) | (1L << (For - 64)) | (1L << (Switch - 64)) | (1L << (While - 64)) | (1L << (Debugger - 64)) | (1L << (Function_ - 64)) | (1L << (This - 64)) | (1L << (With - 64)) | (1L << (Default - 64)) | (1L << (If - 64)) | (1L << (Throw - 64)) | (1L << (Delete - 64)) | (1L << (In - 64)) | (1L << (Try - 64)) | (1L << (From - 64)) | (1L << (ReadOnly - 64)) | (1L << (Async - 64)) | (1L << (Class - 64)) | (1L << (Enum - 64)) | (1L << (Extends - 64)) | (1L << (Super - 64)) | (1L << (Const - 64)) | (1L << (Export - 64)) | (1L << (Import - 64)) | (1L << (Implements - 64)) | (1L << (Let - 64)) | (1L << (Private - 64)) | (1L << (Public - 64)) | (1L << (Interface - 64)) | (1L << (Package - 64)) | (1L << (Protected - 64)) | (1L << (Static - 64)) | (1L << (Yield - 64)) | (1L << (Any - 64)) | (1L << (Number - 64)) | (1L << (Boolean - 64)) | (1L << (String - 64)) | (1L << (Symbol - 64)) | (1L << (TypeAlias - 64)) | (1L << (Get - 64)) | (1L << (Set - 64)) | (1L << (Namespace - 64)) | (1L << (Require - 64)))) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & ((1L << (Module - 128)) | (1L << (Undefined - 128)) | (1L << (Is - 128)) | (1L << (Identifier - 128)) | (1L << (StringLiteral - 128)))) != 0)) {
{
setState(375);
typeArgumentList();
}
}
setState(378);
match(MoreThan);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeArgumentListContext extends ParserRuleContext {
public List typeArgument() {
return getRuleContexts(TypeArgumentContext.class);
}
public TypeArgumentContext typeArgument(int i) {
return getRuleContext(TypeArgumentContext.class,i);
}
public List Comma() { return getTokens(TypeScriptParser.Comma); }
public TerminalNode Comma(int i) {
return getToken(TypeScriptParser.Comma, i);
}
public TypeArgumentListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeArgumentList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTypeArgumentList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTypeArgumentList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitTypeArgumentList(this);
else return visitor.visitChildren(this);
}
}
public final TypeArgumentListContext typeArgumentList() throws RecognitionException {
TypeArgumentListContext _localctx = new TypeArgumentListContext(_ctx, getState());
enterRule(_localctx, 14, RULE_typeArgumentList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(380);
typeArgument();
setState(385);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==Comma) {
{
{
setState(381);
match(Comma);
setState(382);
typeArgument();
}
}
setState(387);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeArgumentContext extends ParserRuleContext {
public Type_Context type_() {
return getRuleContext(Type_Context.class,0);
}
public TypeArgumentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeArgument; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTypeArgument(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTypeArgument(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitTypeArgument(this);
else return visitor.visitChildren(this);
}
}
public final TypeArgumentContext typeArgument() throws RecognitionException {
TypeArgumentContext _localctx = new TypeArgumentContext(_ctx, getState());
enterRule(_localctx, 16, RULE_typeArgument);
try {
enterOuterAlt(_localctx, 1);
{
setState(388);
type_();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Type_Context extends ParserRuleContext {
public UnionOrIntersectionOrPrimaryTypeContext unionOrIntersectionOrPrimaryType() {
return getRuleContext(UnionOrIntersectionOrPrimaryTypeContext.class,0);
}
public List Keyof() { return getTokens(TypeScriptParser.Keyof); }
public TerminalNode Keyof(int i) {
return getToken(TypeScriptParser.Keyof, i);
}
public List Typeof() { return getTokens(TypeScriptParser.Typeof); }
public TerminalNode Typeof(int i) {
return getToken(TypeScriptParser.Typeof, i);
}
public FunctionTypeContext functionType() {
return getRuleContext(FunctionTypeContext.class,0);
}
public ConstructorTypeContext constructorType() {
return getRuleContext(ConstructorTypeContext.class,0);
}
public TypeGenericContext typeGeneric() {
return getRuleContext(TypeGenericContext.class,0);
}
public List propertyName() {
return getRuleContexts(PropertyNameContext.class);
}
public PropertyNameContext propertyName(int i) {
return getRuleContext(PropertyNameContext.class,i);
}
public List BitOr() { return getTokens(TypeScriptParser.BitOr); }
public TerminalNode BitOr(int i) {
return getToken(TypeScriptParser.BitOr, i);
}
public Type_Context(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_type_; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterType_(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitType_(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitType_(this);
else return visitor.visitChildren(this);
}
}
public final Type_Context type_() throws RecognitionException {
Type_Context _localctx = new Type_Context(_ctx, getState());
enterRule(_localctx, 18, RULE_type_);
int _la;
try {
int _alt;
setState(412);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(393);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,9,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(390);
_la = _input.LA(1);
if ( !(_la==Typeof || _la==Keyof) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
}
setState(395);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,9,_ctx);
}
setState(396);
unionOrIntersectionOrPrimaryType(0);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(397);
unionOrIntersectionOrPrimaryType(0);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(398);
functionType();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(399);
constructorType();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(400);
typeGeneric();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(402);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==BitOr) {
{
setState(401);
match(BitOr);
}
}
setState(404);
propertyName();
setState(409);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,11,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(405);
match(BitOr);
{
setState(406);
propertyName();
}
}
}
}
setState(411);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,11,_ctx);
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class UnionOrIntersectionOrPrimaryTypeContext extends ParserRuleContext {
public UnionOrIntersectionOrPrimaryTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unionOrIntersectionOrPrimaryType; }
public UnionOrIntersectionOrPrimaryTypeContext() { }
public void copyFrom(UnionOrIntersectionOrPrimaryTypeContext ctx) {
super.copyFrom(ctx);
}
}
public static class IntersectionContext extends UnionOrIntersectionOrPrimaryTypeContext {
public List unionOrIntersectionOrPrimaryType() {
return getRuleContexts(UnionOrIntersectionOrPrimaryTypeContext.class);
}
public UnionOrIntersectionOrPrimaryTypeContext unionOrIntersectionOrPrimaryType(int i) {
return getRuleContext(UnionOrIntersectionOrPrimaryTypeContext.class,i);
}
public TerminalNode BitAnd() { return getToken(TypeScriptParser.BitAnd, 0); }
public IntersectionContext(UnionOrIntersectionOrPrimaryTypeContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterIntersection(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitIntersection(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitIntersection(this);
else return visitor.visitChildren(this);
}
}
public static class PrimaryContext extends UnionOrIntersectionOrPrimaryTypeContext {
public PrimaryTypeContext primaryType() {
return getRuleContext(PrimaryTypeContext.class,0);
}
public PrimaryContext(UnionOrIntersectionOrPrimaryTypeContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterPrimary(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitPrimary(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitPrimary(this);
else return visitor.visitChildren(this);
}
}
public static class UnionContext extends UnionOrIntersectionOrPrimaryTypeContext {
public List unionOrIntersectionOrPrimaryType() {
return getRuleContexts(UnionOrIntersectionOrPrimaryTypeContext.class);
}
public UnionOrIntersectionOrPrimaryTypeContext unionOrIntersectionOrPrimaryType(int i) {
return getRuleContext(UnionOrIntersectionOrPrimaryTypeContext.class,i);
}
public TerminalNode BitOr() { return getToken(TypeScriptParser.BitOr, 0); }
public UnionContext(UnionOrIntersectionOrPrimaryTypeContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterUnion(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitUnion(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitUnion(this);
else return visitor.visitChildren(this);
}
}
public final UnionOrIntersectionOrPrimaryTypeContext unionOrIntersectionOrPrimaryType() throws RecognitionException {
return unionOrIntersectionOrPrimaryType(0);
}
private UnionOrIntersectionOrPrimaryTypeContext unionOrIntersectionOrPrimaryType(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
UnionOrIntersectionOrPrimaryTypeContext _localctx = new UnionOrIntersectionOrPrimaryTypeContext(_ctx, _parentState);
UnionOrIntersectionOrPrimaryTypeContext _prevctx = _localctx;
int _startState = 20;
enterRecursionRule(_localctx, 20, RULE_unionOrIntersectionOrPrimaryType, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
_localctx = new PrimaryContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(415);
primaryType(0);
}
_ctx.stop = _input.LT(-1);
setState(425);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,14,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(423);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,13,_ctx) ) {
case 1:
{
_localctx = new UnionContext(new UnionOrIntersectionOrPrimaryTypeContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_unionOrIntersectionOrPrimaryType);
setState(417);
if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
setState(418);
match(BitOr);
setState(419);
unionOrIntersectionOrPrimaryType(4);
}
break;
case 2:
{
_localctx = new IntersectionContext(new UnionOrIntersectionOrPrimaryTypeContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_unionOrIntersectionOrPrimaryType);
setState(420);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(421);
match(BitAnd);
setState(422);
unionOrIntersectionOrPrimaryType(3);
}
break;
}
}
}
setState(427);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,14,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class PrimaryTypeContext extends ParserRuleContext {
public PrimaryTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_primaryType; }
public PrimaryTypeContext() { }
public void copyFrom(PrimaryTypeContext ctx) {
super.copyFrom(ctx);
}
}
public static class RedefinitionOfTypeContext extends PrimaryTypeContext {
public TypeReferenceContext typeReference() {
return getRuleContext(TypeReferenceContext.class,0);
}
public TerminalNode Is() { return getToken(TypeScriptParser.Is, 0); }
public PrimaryTypeContext primaryType() {
return getRuleContext(PrimaryTypeContext.class,0);
}
public RedefinitionOfTypeContext(PrimaryTypeContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterRedefinitionOfType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitRedefinitionOfType(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitRedefinitionOfType(this);
else return visitor.visitChildren(this);
}
}
public static class PredefinedPrimTypeContext extends PrimaryTypeContext {
public PredefinedTypeContext predefinedType() {
return getRuleContext(PredefinedTypeContext.class,0);
}
public PredefinedPrimTypeContext(PrimaryTypeContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterPredefinedPrimType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitPredefinedPrimType(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitPredefinedPrimType(this);
else return visitor.visitChildren(this);
}
}
public static class RedefinitionOfThisTypeContext extends PrimaryTypeContext {
public TerminalNode This() { return getToken(TypeScriptParser.This, 0); }
public TerminalNode Is() { return getToken(TypeScriptParser.Is, 0); }
public PrimaryTypeContext primaryType() {
return getRuleContext(PrimaryTypeContext.class,0);
}
public RedefinitionOfThisTypeContext(PrimaryTypeContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterRedefinitionOfThisType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitRedefinitionOfThisType(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitRedefinitionOfThisType(this);
else return visitor.visitChildren(this);
}
}
public static class ArrayPrimTypeContext extends PrimaryTypeContext {
public PrimaryTypeContext primaryType() {
return getRuleContext(PrimaryTypeContext.class,0);
}
public TerminalNode OpenBracket() { return getToken(TypeScriptParser.OpenBracket, 0); }
public TerminalNode CloseBracket() { return getToken(TypeScriptParser.CloseBracket, 0); }
public ArrayPrimTypeContext(PrimaryTypeContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterArrayPrimType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitArrayPrimType(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitArrayPrimType(this);
else return visitor.visitChildren(this);
}
}
public static class SingleExprPrimTypeContext extends PrimaryTypeContext {
public PrimaryTypeContext primaryType() {
return getRuleContext(PrimaryTypeContext.class,0);
}
public TerminalNode OpenBracket() { return getToken(TypeScriptParser.OpenBracket, 0); }
public SingleExpressionContext singleExpression() {
return getRuleContext(SingleExpressionContext.class,0);
}
public TerminalNode CloseBracket() { return getToken(TypeScriptParser.CloseBracket, 0); }
public SingleExprPrimTypeContext(PrimaryTypeContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterSingleExprPrimType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitSingleExprPrimType(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitSingleExprPrimType(this);
else return visitor.visitChildren(this);
}
}
public static class ParenthesizedPrimTypeContext extends PrimaryTypeContext {
public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); }
public Type_Context type_() {
return getRuleContext(Type_Context.class,0);
}
public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); }
public ParenthesizedPrimTypeContext(PrimaryTypeContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterParenthesizedPrimType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitParenthesizedPrimType(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitParenthesizedPrimType(this);
else return visitor.visitChildren(this);
}
}
public static class ThisPrimTypeContext extends PrimaryTypeContext {
public TerminalNode This() { return getToken(TypeScriptParser.This, 0); }
public ThisPrimTypeContext(PrimaryTypeContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterThisPrimType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitThisPrimType(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitThisPrimType(this);
else return visitor.visitChildren(this);
}
}
public static class TuplePrimTypeContext extends PrimaryTypeContext {
public TerminalNode OpenBracket() { return getToken(TypeScriptParser.OpenBracket, 0); }
public TupleElementTypesContext tupleElementTypes() {
return getRuleContext(TupleElementTypesContext.class,0);
}
public TerminalNode CloseBracket() { return getToken(TypeScriptParser.CloseBracket, 0); }
public TuplePrimTypeContext(PrimaryTypeContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTuplePrimType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTuplePrimType(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitTuplePrimType(this);
else return visitor.visitChildren(this);
}
}
public static class ObjectPrimTypeContext extends PrimaryTypeContext {
public ObjectTypeContext objectType() {
return getRuleContext(ObjectTypeContext.class,0);
}
public ObjectPrimTypeContext(PrimaryTypeContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterObjectPrimType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitObjectPrimType(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitObjectPrimType(this);
else return visitor.visitChildren(this);
}
}
public static class ReferencePrimTypeContext extends PrimaryTypeContext {
public TypeReferenceContext typeReference() {
return getRuleContext(TypeReferenceContext.class,0);
}
public ReferencePrimTypeContext(PrimaryTypeContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterReferencePrimType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitReferencePrimType(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitReferencePrimType(this);
else return visitor.visitChildren(this);
}
}
public static class QueryPrimTypeContext extends PrimaryTypeContext {
public TypeQueryContext typeQuery() {
return getRuleContext(TypeQueryContext.class,0);
}
public QueryPrimTypeContext(PrimaryTypeContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterQueryPrimType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitQueryPrimType(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitQueryPrimType(this);
else return visitor.visitChildren(this);
}
}
public final PrimaryTypeContext primaryType() throws RecognitionException {
return primaryType(0);
}
private PrimaryTypeContext primaryType(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
PrimaryTypeContext _localctx = new PrimaryTypeContext(_ctx, _parentState);
PrimaryTypeContext _prevctx = _localctx;
int _startState = 22;
enterRecursionRule(_localctx, 22, RULE_primaryType, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(449);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,15,_ctx) ) {
case 1:
{
_localctx = new ParenthesizedPrimTypeContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(429);
match(OpenParen);
setState(430);
type_();
setState(431);
match(CloseParen);
}
break;
case 2:
{
_localctx = new PredefinedPrimTypeContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(433);
predefinedType();
}
break;
case 3:
{
_localctx = new ReferencePrimTypeContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(434);
typeReference();
}
break;
case 4:
{
_localctx = new ObjectPrimTypeContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(435);
objectType();
}
break;
case 5:
{
_localctx = new TuplePrimTypeContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(436);
match(OpenBracket);
setState(437);
tupleElementTypes();
setState(438);
match(CloseBracket);
}
break;
case 6:
{
_localctx = new QueryPrimTypeContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(440);
typeQuery();
}
break;
case 7:
{
_localctx = new ThisPrimTypeContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(441);
match(This);
}
break;
case 8:
{
_localctx = new RedefinitionOfThisTypeContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(442);
match(This);
setState(443);
match(Is);
setState(444);
primaryType(3);
}
break;
case 9:
{
_localctx = new RedefinitionOfTypeContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(445);
typeReference();
setState(446);
match(Is);
setState(447);
primaryType(2);
}
break;
}
_ctx.stop = _input.LT(-1);
setState(463);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,17,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(461);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,16,_ctx) ) {
case 1:
{
_localctx = new ArrayPrimTypeContext(new PrimaryTypeContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_primaryType);
setState(451);
if (!(precpred(_ctx, 7))) throw new FailedPredicateException(this, "precpred(_ctx, 7)");
setState(452);
if (!(notLineTerminator())) throw new FailedPredicateException(this, "notLineTerminator()");
setState(453);
match(OpenBracket);
setState(454);
match(CloseBracket);
}
break;
case 2:
{
_localctx = new SingleExprPrimTypeContext(new PrimaryTypeContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_primaryType);
setState(455);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(456);
if (!(notLineTerminator())) throw new FailedPredicateException(this, "notLineTerminator()");
setState(457);
match(OpenBracket);
setState(458);
singleExpression(0);
setState(459);
match(CloseBracket);
}
break;
}
}
}
setState(465);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,17,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class PredefinedTypeContext extends ParserRuleContext {
public TerminalNode Any() { return getToken(TypeScriptParser.Any, 0); }
public TerminalNode Number() { return getToken(TypeScriptParser.Number, 0); }
public TerminalNode Boolean() { return getToken(TypeScriptParser.Boolean, 0); }
public TerminalNode String() { return getToken(TypeScriptParser.String, 0); }
public TerminalNode Symbol() { return getToken(TypeScriptParser.Symbol, 0); }
public TerminalNode Void() { return getToken(TypeScriptParser.Void, 0); }
public TerminalNode NullLiteral() { return getToken(TypeScriptParser.NullLiteral, 0); }
public TerminalNode StringLiteral() { return getToken(TypeScriptParser.StringLiteral, 0); }
public TerminalNode Undefined() { return getToken(TypeScriptParser.Undefined, 0); }
public PredefinedTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_predefinedType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterPredefinedType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitPredefinedType(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitPredefinedType(this);
else return visitor.visitChildren(this);
}
}
public final PredefinedTypeContext predefinedType() throws RecognitionException {
PredefinedTypeContext _localctx = new PredefinedTypeContext(_ctx, getState());
enterRule(_localctx, 24, RULE_predefinedType);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(466);
_la = _input.LA(1);
if ( !(_la==NullLiteral || ((((_la - 80)) & ~0x3f) == 0 && ((1L << (_la - 80)) & ((1L << (Void - 80)) | (1L << (Any - 80)) | (1L << (Number - 80)) | (1L << (Boolean - 80)) | (1L << (String - 80)) | (1L << (Symbol - 80)) | (1L << (Undefined - 80)) | (1L << (StringLiteral - 80)))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeReferenceContext extends ParserRuleContext {
public TypeNameContext typeName() {
return getRuleContext(TypeNameContext.class,0);
}
public NestedTypeGenericContext nestedTypeGeneric() {
return getRuleContext(NestedTypeGenericContext.class,0);
}
public TypeReferenceContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeReference; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTypeReference(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTypeReference(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitTypeReference(this);
else return visitor.visitChildren(this);
}
}
public final TypeReferenceContext typeReference() throws RecognitionException {
TypeReferenceContext _localctx = new TypeReferenceContext(_ctx, getState());
enterRule(_localctx, 26, RULE_typeReference);
try {
enterOuterAlt(_localctx, 1);
{
setState(468);
typeName();
setState(470);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,18,_ctx) ) {
case 1:
{
setState(469);
nestedTypeGeneric();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NestedTypeGenericContext extends ParserRuleContext {
public TypeIncludeGenericContext typeIncludeGeneric() {
return getRuleContext(TypeIncludeGenericContext.class,0);
}
public TypeGenericContext typeGeneric() {
return getRuleContext(TypeGenericContext.class,0);
}
public NestedTypeGenericContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_nestedTypeGeneric; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterNestedTypeGeneric(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitNestedTypeGeneric(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitNestedTypeGeneric(this);
else return visitor.visitChildren(this);
}
}
public final NestedTypeGenericContext nestedTypeGeneric() throws RecognitionException {
NestedTypeGenericContext _localctx = new NestedTypeGenericContext(_ctx, getState());
enterRule(_localctx, 28, RULE_nestedTypeGeneric);
try {
setState(474);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,19,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(472);
typeIncludeGeneric();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(473);
typeGeneric();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeGenericContext extends ParserRuleContext {
public TerminalNode LessThan() { return getToken(TypeScriptParser.LessThan, 0); }
public TypeArgumentListContext typeArgumentList() {
return getRuleContext(TypeArgumentListContext.class,0);
}
public TerminalNode MoreThan() { return getToken(TypeScriptParser.MoreThan, 0); }
public TypeGenericContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeGeneric; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTypeGeneric(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTypeGeneric(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitTypeGeneric(this);
else return visitor.visitChildren(this);
}
}
public final TypeGenericContext typeGeneric() throws RecognitionException {
TypeGenericContext _localctx = new TypeGenericContext(_ctx, getState());
enterRule(_localctx, 30, RULE_typeGeneric);
try {
enterOuterAlt(_localctx, 1);
{
setState(476);
match(LessThan);
setState(477);
typeArgumentList();
setState(478);
match(MoreThan);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeIncludeGenericContext extends ParserRuleContext {
public List LessThan() { return getTokens(TypeScriptParser.LessThan); }
public TerminalNode LessThan(int i) {
return getToken(TypeScriptParser.LessThan, i);
}
public List typeArgumentList() {
return getRuleContexts(TypeArgumentListContext.class);
}
public TypeArgumentListContext typeArgumentList(int i) {
return getRuleContext(TypeArgumentListContext.class,i);
}
public List MoreThan() { return getTokens(TypeScriptParser.MoreThan); }
public TerminalNode MoreThan(int i) {
return getToken(TypeScriptParser.MoreThan, i);
}
public BindingPatternContext bindingPattern() {
return getRuleContext(BindingPatternContext.class,0);
}
public TerminalNode RightShiftArithmetic() { return getToken(TypeScriptParser.RightShiftArithmetic, 0); }
public TypeIncludeGenericContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeIncludeGeneric; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTypeIncludeGeneric(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTypeIncludeGeneric(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitTypeIncludeGeneric(this);
else return visitor.visitChildren(this);
}
}
public final TypeIncludeGenericContext typeIncludeGeneric() throws RecognitionException {
TypeIncludeGenericContext _localctx = new TypeIncludeGenericContext(_ctx, getState());
enterRule(_localctx, 32, RULE_typeIncludeGeneric);
try {
enterOuterAlt(_localctx, 1);
{
setState(480);
match(LessThan);
setState(481);
typeArgumentList();
setState(482);
match(LessThan);
setState(483);
typeArgumentList();
setState(489);
_errHandler.sync(this);
switch (_input.LA(1)) {
case MoreThan:
{
setState(484);
match(MoreThan);
setState(485);
bindingPattern();
setState(486);
match(MoreThan);
}
break;
case RightShiftArithmetic:
{
setState(488);
match(RightShiftArithmetic);
}
break;
default:
throw new NoViableAltException(this);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeNameContext extends ParserRuleContext {
public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); }
public NamespaceNameContext namespaceName() {
return getRuleContext(NamespaceNameContext.class,0);
}
public TypeNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTypeName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTypeName(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitTypeName(this);
else return visitor.visitChildren(this);
}
}
public final TypeNameContext typeName() throws RecognitionException {
TypeNameContext _localctx = new TypeNameContext(_ctx, getState());
enterRule(_localctx, 34, RULE_typeName);
try {
setState(493);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,21,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(491);
match(Identifier);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(492);
namespaceName();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ObjectTypeContext extends ParserRuleContext {
public TerminalNode OpenBrace() { return getToken(TypeScriptParser.OpenBrace, 0); }
public TerminalNode CloseBrace() { return getToken(TypeScriptParser.CloseBrace, 0); }
public TypeBodyContext typeBody() {
return getRuleContext(TypeBodyContext.class,0);
}
public ObjectTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_objectType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterObjectType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitObjectType(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitObjectType(this);
else return visitor.visitChildren(this);
}
}
public final ObjectTypeContext objectType() throws RecognitionException {
ObjectTypeContext _localctx = new ObjectTypeContext(_ctx, getState());
enterRule(_localctx, 36, RULE_objectType);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(495);
match(OpenBrace);
setState(497);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << OpenBracket) | (1L << OpenParen) | (1L << LessThan) | (1L << Lodash) | (1L << Dollar) | (1L << NullLiteral) | (1L << BooleanLiteral) | (1L << DecimalLiteral))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (HexIntegerLiteral - 64)) | (1L << (OctalIntegerLiteral - 64)) | (1L << (OctalIntegerLiteral2 - 64)) | (1L << (BinaryIntegerLiteral - 64)) | (1L << (Break - 64)) | (1L << (Do - 64)) | (1L << (Instanceof - 64)) | (1L << (Typeof - 64)) | (1L << (Keyof - 64)) | (1L << (Case - 64)) | (1L << (Else - 64)) | (1L << (New - 64)) | (1L << (Var - 64)) | (1L << (Catch - 64)) | (1L << (Finally - 64)) | (1L << (Return - 64)) | (1L << (Void - 64)) | (1L << (Continue - 64)) | (1L << (For - 64)) | (1L << (Switch - 64)) | (1L << (While - 64)) | (1L << (Debugger - 64)) | (1L << (Function_ - 64)) | (1L << (This - 64)) | (1L << (With - 64)) | (1L << (Default - 64)) | (1L << (If - 64)) | (1L << (Throw - 64)) | (1L << (Delete - 64)) | (1L << (In - 64)) | (1L << (Try - 64)) | (1L << (From - 64)) | (1L << (ReadOnly - 64)) | (1L << (Async - 64)) | (1L << (Class - 64)) | (1L << (Enum - 64)) | (1L << (Extends - 64)) | (1L << (Super - 64)) | (1L << (Const - 64)) | (1L << (Export - 64)) | (1L << (Import - 64)) | (1L << (Implements - 64)) | (1L << (Let - 64)) | (1L << (Private - 64)) | (1L << (Public - 64)) | (1L << (Interface - 64)) | (1L << (Package - 64)) | (1L << (Protected - 64)) | (1L << (Static - 64)) | (1L << (Yield - 64)) | (1L << (Any - 64)) | (1L << (Number - 64)) | (1L << (Boolean - 64)) | (1L << (String - 64)) | (1L << (Symbol - 64)) | (1L << (TypeAlias - 64)) | (1L << (Get - 64)) | (1L << (Set - 64)) | (1L << (Namespace - 64)) | (1L << (Require - 64)))) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & ((1L << (Module - 128)) | (1L << (Undefined - 128)) | (1L << (Is - 128)) | (1L << (Identifier - 128)) | (1L << (StringLiteral - 128)))) != 0)) {
{
setState(496);
typeBody();
}
}
setState(499);
match(CloseBrace);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeBodyContext extends ParserRuleContext {
public TypeMemberListContext typeMemberList() {
return getRuleContext(TypeMemberListContext.class,0);
}
public TerminalNode SemiColon() { return getToken(TypeScriptParser.SemiColon, 0); }
public TerminalNode Comma() { return getToken(TypeScriptParser.Comma, 0); }
public TypeBodyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeBody; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTypeBody(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTypeBody(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitTypeBody(this);
else return visitor.visitChildren(this);
}
}
public final TypeBodyContext typeBody() throws RecognitionException {
TypeBodyContext _localctx = new TypeBodyContext(_ctx, getState());
enterRule(_localctx, 38, RULE_typeBody);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(501);
typeMemberList();
setState(503);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SemiColon || _la==Comma) {
{
setState(502);
_la = _input.LA(1);
if ( !(_la==SemiColon || _la==Comma) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeMemberListContext extends ParserRuleContext {
public List typeMember() {
return getRuleContexts(TypeMemberContext.class);
}
public TypeMemberContext typeMember(int i) {
return getRuleContext(TypeMemberContext.class,i);
}
public List SemiColon() { return getTokens(TypeScriptParser.SemiColon); }
public TerminalNode SemiColon(int i) {
return getToken(TypeScriptParser.SemiColon, i);
}
public List Comma() { return getTokens(TypeScriptParser.Comma); }
public TerminalNode Comma(int i) {
return getToken(TypeScriptParser.Comma, i);
}
public TypeMemberListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeMemberList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTypeMemberList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTypeMemberList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitTypeMemberList(this);
else return visitor.visitChildren(this);
}
}
public final TypeMemberListContext typeMemberList() throws RecognitionException {
TypeMemberListContext _localctx = new TypeMemberListContext(_ctx, getState());
enterRule(_localctx, 40, RULE_typeMemberList);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(505);
typeMember();
setState(510);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,24,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(506);
_la = _input.LA(1);
if ( !(_la==SemiColon || _la==Comma) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(507);
typeMember();
}
}
}
setState(512);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,24,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeMemberContext extends ParserRuleContext {
public PropertySignatureContext propertySignature() {
return getRuleContext(PropertySignatureContext.class,0);
}
public CallSignatureContext callSignature() {
return getRuleContext(CallSignatureContext.class,0);
}
public ConstructSignatureContext constructSignature() {
return getRuleContext(ConstructSignatureContext.class,0);
}
public IndexSignatureContext indexSignature() {
return getRuleContext(IndexSignatureContext.class,0);
}
public MethodSignatureContext methodSignature() {
return getRuleContext(MethodSignatureContext.class,0);
}
public TerminalNode ARROW() { return getToken(TypeScriptParser.ARROW, 0); }
public Type_Context type_() {
return getRuleContext(Type_Context.class,0);
}
public EnumSignatureContext enumSignature() {
return getRuleContext(EnumSignatureContext.class,0);
}
public TerminalNode OpenBracket() { return getToken(TypeScriptParser.OpenBracket, 0); }
public List typeReference() {
return getRuleContexts(TypeReferenceContext.class);
}
public TypeReferenceContext typeReference(int i) {
return getRuleContext(TypeReferenceContext.class,i);
}
public TerminalNode In() { return getToken(TypeScriptParser.In, 0); }
public TerminalNode CloseBracket() { return getToken(TypeScriptParser.CloseBracket, 0); }
public TypeAnnotationContext typeAnnotation() {
return getRuleContext(TypeAnnotationContext.class,0);
}
public List Keyof() { return getTokens(TypeScriptParser.Keyof); }
public TerminalNode Keyof(int i) {
return getToken(TypeScriptParser.Keyof, i);
}
public List Typeof() { return getTokens(TypeScriptParser.Typeof); }
public TerminalNode Typeof(int i) {
return getToken(TypeScriptParser.Typeof, i);
}
public TypeMemberContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeMember; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTypeMember(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTypeMember(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitTypeMember(this);
else return visitor.visitChildren(this);
}
}
public final TypeMemberContext typeMember() throws RecognitionException {
TypeMemberContext _localctx = new TypeMemberContext(_ctx, getState());
enterRule(_localctx, 42, RULE_typeMember);
int _la;
try {
setState(536);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,27,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(513);
propertySignature();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(514);
callSignature();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(515);
constructSignature();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(516);
indexSignature();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(517);
methodSignature();
setState(520);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ARROW) {
{
setState(518);
match(ARROW);
setState(519);
type_();
}
}
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(522);
enumSignature();
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(523);
match(OpenBracket);
setState(524);
typeReference();
setState(525);
match(In);
setState(529);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==Typeof || _la==Keyof) {
{
{
setState(526);
_la = _input.LA(1);
if ( !(_la==Typeof || _la==Keyof) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(531);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(532);
typeReference();
setState(533);
match(CloseBracket);
setState(534);
typeAnnotation();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ArrayTypeContext extends ParserRuleContext {
public PrimaryTypeContext primaryType() {
return getRuleContext(PrimaryTypeContext.class,0);
}
public TerminalNode OpenBracket() { return getToken(TypeScriptParser.OpenBracket, 0); }
public TerminalNode CloseBracket() { return getToken(TypeScriptParser.CloseBracket, 0); }
public ArrayTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_arrayType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterArrayType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitArrayType(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitArrayType(this);
else return visitor.visitChildren(this);
}
}
public final ArrayTypeContext arrayType() throws RecognitionException {
ArrayTypeContext _localctx = new ArrayTypeContext(_ctx, getState());
enterRule(_localctx, 44, RULE_arrayType);
try {
enterOuterAlt(_localctx, 1);
{
setState(538);
primaryType(0);
setState(539);
if (!(notLineTerminator())) throw new FailedPredicateException(this, "notLineTerminator()");
setState(540);
match(OpenBracket);
setState(541);
match(CloseBracket);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TupleTypeContext extends ParserRuleContext {
public TerminalNode OpenBracket() { return getToken(TypeScriptParser.OpenBracket, 0); }
public TupleElementTypesContext tupleElementTypes() {
return getRuleContext(TupleElementTypesContext.class,0);
}
public TerminalNode CloseBracket() { return getToken(TypeScriptParser.CloseBracket, 0); }
public TupleTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_tupleType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTupleType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTupleType(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitTupleType(this);
else return visitor.visitChildren(this);
}
}
public final TupleTypeContext tupleType() throws RecognitionException {
TupleTypeContext _localctx = new TupleTypeContext(_ctx, getState());
enterRule(_localctx, 46, RULE_tupleType);
try {
enterOuterAlt(_localctx, 1);
{
setState(543);
match(OpenBracket);
setState(544);
tupleElementTypes();
setState(545);
match(CloseBracket);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TupleElementTypesContext extends ParserRuleContext {
public List type_() {
return getRuleContexts(Type_Context.class);
}
public Type_Context type_(int i) {
return getRuleContext(Type_Context.class,i);
}
public List Comma() { return getTokens(TypeScriptParser.Comma); }
public TerminalNode Comma(int i) {
return getToken(TypeScriptParser.Comma, i);
}
public TupleElementTypesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_tupleElementTypes; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTupleElementTypes(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTupleElementTypes(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitTupleElementTypes(this);
else return visitor.visitChildren(this);
}
}
public final TupleElementTypesContext tupleElementTypes() throws RecognitionException {
TupleElementTypesContext _localctx = new TupleElementTypesContext(_ctx, getState());
enterRule(_localctx, 48, RULE_tupleElementTypes);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(547);
type_();
setState(552);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==Comma) {
{
{
setState(548);
match(Comma);
setState(549);
type_();
}
}
setState(554);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FunctionTypeContext extends ParserRuleContext {
public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); }
public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); }
public TerminalNode ARROW() { return getToken(TypeScriptParser.ARROW, 0); }
public Type_Context type_() {
return getRuleContext(Type_Context.class,0);
}
public TypeParametersContext typeParameters() {
return getRuleContext(TypeParametersContext.class,0);
}
public ParameterListContext parameterList() {
return getRuleContext(ParameterListContext.class,0);
}
public FunctionTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_functionType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterFunctionType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitFunctionType(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitFunctionType(this);
else return visitor.visitChildren(this);
}
}
public final FunctionTypeContext functionType() throws RecognitionException {
FunctionTypeContext _localctx = new FunctionTypeContext(_ctx, getState());
enterRule(_localctx, 50, RULE_functionType);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(556);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LessThan) {
{
setState(555);
typeParameters();
}
}
setState(558);
match(OpenParen);
setState(560);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << OpenBracket) | (1L << OpenBrace) | (1L << Ellipsis) | (1L << Lodash) | (1L << Dollar) | (1L << NullLiteral) | (1L << BooleanLiteral))) != 0) || ((((_la - 68)) & ~0x3f) == 0 && ((1L << (_la - 68)) & ((1L << (Break - 68)) | (1L << (Do - 68)) | (1L << (Instanceof - 68)) | (1L << (Typeof - 68)) | (1L << (Keyof - 68)) | (1L << (Case - 68)) | (1L << (Else - 68)) | (1L << (New - 68)) | (1L << (Var - 68)) | (1L << (Catch - 68)) | (1L << (Finally - 68)) | (1L << (Return - 68)) | (1L << (Void - 68)) | (1L << (Continue - 68)) | (1L << (For - 68)) | (1L << (Switch - 68)) | (1L << (While - 68)) | (1L << (Debugger - 68)) | (1L << (Function_ - 68)) | (1L << (This - 68)) | (1L << (With - 68)) | (1L << (If - 68)) | (1L << (Throw - 68)) | (1L << (Delete - 68)) | (1L << (In - 68)) | (1L << (Try - 68)) | (1L << (From - 68)) | (1L << (ReadOnly - 68)) | (1L << (Async - 68)) | (1L << (Class - 68)) | (1L << (Enum - 68)) | (1L << (Extends - 68)) | (1L << (Super - 68)) | (1L << (Const - 68)) | (1L << (Export - 68)) | (1L << (Import - 68)) | (1L << (Implements - 68)) | (1L << (Let - 68)) | (1L << (Private - 68)) | (1L << (Public - 68)) | (1L << (Interface - 68)) | (1L << (Package - 68)) | (1L << (Protected - 68)) | (1L << (Static - 68)) | (1L << (Yield - 68)) | (1L << (Any - 68)) | (1L << (Number - 68)) | (1L << (Boolean - 68)) | (1L << (String - 68)) | (1L << (TypeAlias - 68)) | (1L << (Get - 68)) | (1L << (Set - 68)) | (1L << (Namespace - 68)) | (1L << (Require - 68)) | (1L << (Module - 68)) | (1L << (Undefined - 68)))) != 0) || ((((_la - 133)) & ~0x3f) == 0 && ((1L << (_la - 133)) & ((1L << (Is - 133)) | (1L << (At - 133)) | (1L << (Identifier - 133)))) != 0)) {
{
setState(559);
parameterList();
}
}
setState(562);
match(CloseParen);
setState(563);
match(ARROW);
setState(564);
type_();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ConstructorTypeContext extends ParserRuleContext {
public TerminalNode New() { return getToken(TypeScriptParser.New, 0); }
public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); }
public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); }
public TerminalNode ARROW() { return getToken(TypeScriptParser.ARROW, 0); }
public Type_Context type_() {
return getRuleContext(Type_Context.class,0);
}
public TypeParametersContext typeParameters() {
return getRuleContext(TypeParametersContext.class,0);
}
public ParameterListContext parameterList() {
return getRuleContext(ParameterListContext.class,0);
}
public ConstructorTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_constructorType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterConstructorType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitConstructorType(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitConstructorType(this);
else return visitor.visitChildren(this);
}
}
public final ConstructorTypeContext constructorType() throws RecognitionException {
ConstructorTypeContext _localctx = new ConstructorTypeContext(_ctx, getState());
enterRule(_localctx, 52, RULE_constructorType);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(566);
match(New);
setState(568);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LessThan) {
{
setState(567);
typeParameters();
}
}
setState(570);
match(OpenParen);
setState(572);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << OpenBracket) | (1L << OpenBrace) | (1L << Ellipsis) | (1L << Lodash) | (1L << Dollar) | (1L << NullLiteral) | (1L << BooleanLiteral))) != 0) || ((((_la - 68)) & ~0x3f) == 0 && ((1L << (_la - 68)) & ((1L << (Break - 68)) | (1L << (Do - 68)) | (1L << (Instanceof - 68)) | (1L << (Typeof - 68)) | (1L << (Keyof - 68)) | (1L << (Case - 68)) | (1L << (Else - 68)) | (1L << (New - 68)) | (1L << (Var - 68)) | (1L << (Catch - 68)) | (1L << (Finally - 68)) | (1L << (Return - 68)) | (1L << (Void - 68)) | (1L << (Continue - 68)) | (1L << (For - 68)) | (1L << (Switch - 68)) | (1L << (While - 68)) | (1L << (Debugger - 68)) | (1L << (Function_ - 68)) | (1L << (This - 68)) | (1L << (With - 68)) | (1L << (If - 68)) | (1L << (Throw - 68)) | (1L << (Delete - 68)) | (1L << (In - 68)) | (1L << (Try - 68)) | (1L << (From - 68)) | (1L << (ReadOnly - 68)) | (1L << (Async - 68)) | (1L << (Class - 68)) | (1L << (Enum - 68)) | (1L << (Extends - 68)) | (1L << (Super - 68)) | (1L << (Const - 68)) | (1L << (Export - 68)) | (1L << (Import - 68)) | (1L << (Implements - 68)) | (1L << (Let - 68)) | (1L << (Private - 68)) | (1L << (Public - 68)) | (1L << (Interface - 68)) | (1L << (Package - 68)) | (1L << (Protected - 68)) | (1L << (Static - 68)) | (1L << (Yield - 68)) | (1L << (Any - 68)) | (1L << (Number - 68)) | (1L << (Boolean - 68)) | (1L << (String - 68)) | (1L << (TypeAlias - 68)) | (1L << (Get - 68)) | (1L << (Set - 68)) | (1L << (Namespace - 68)) | (1L << (Require - 68)) | (1L << (Module - 68)) | (1L << (Undefined - 68)))) != 0) || ((((_la - 133)) & ~0x3f) == 0 && ((1L << (_la - 133)) & ((1L << (Is - 133)) | (1L << (At - 133)) | (1L << (Identifier - 133)))) != 0)) {
{
setState(571);
parameterList();
}
}
setState(574);
match(CloseParen);
setState(575);
match(ARROW);
setState(576);
type_();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeQueryContext extends ParserRuleContext {
public TypeQueryExpressionContext typeQueryExpression() {
return getRuleContext(TypeQueryExpressionContext.class,0);
}
public List Typeof() { return getTokens(TypeScriptParser.Typeof); }
public TerminalNode Typeof(int i) {
return getToken(TypeScriptParser.Typeof, i);
}
public TypeQueryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeQuery; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTypeQuery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTypeQuery(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitTypeQuery(this);
else return visitor.visitChildren(this);
}
}
public final TypeQueryContext typeQuery() throws RecognitionException {
TypeQueryContext _localctx = new TypeQueryContext(_ctx, getState());
enterRule(_localctx, 54, RULE_typeQuery);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(581);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,33,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(578);
match(Typeof);
}
}
}
setState(583);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,33,_ctx);
}
setState(584);
typeQueryExpression();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeQueryExpressionContext extends ParserRuleContext {
public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); }
public List identifierName() {
return getRuleContexts(IdentifierNameContext.class);
}
public IdentifierNameContext identifierName(int i) {
return getRuleContext(IdentifierNameContext.class,i);
}
public List Dot() { return getTokens(TypeScriptParser.Dot); }
public TerminalNode Dot(int i) {
return getToken(TypeScriptParser.Dot, i);
}
public List Not() { return getTokens(TypeScriptParser.Not); }
public TerminalNode Not(int i) {
return getToken(TypeScriptParser.Not, i);
}
public TypeQueryExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeQueryExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTypeQueryExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTypeQueryExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitTypeQueryExpression(this);
else return visitor.visitChildren(this);
}
}
public final TypeQueryExpressionContext typeQueryExpression() throws RecognitionException {
TypeQueryExpressionContext _localctx = new TypeQueryExpressionContext(_ctx, getState());
enterRule(_localctx, 56, RULE_typeQueryExpression);
int _la;
try {
int _alt;
setState(599);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,36,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(586);
match(Identifier);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(593);
_errHandler.sync(this);
_alt = 1;
do {
switch (_alt) {
case 1:
{
{
setState(587);
identifierName();
setState(589);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Not) {
{
setState(588);
match(Not);
}
}
setState(591);
match(Dot);
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(595);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,35,_ctx);
} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
setState(597);
identifierName();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PropertySignatureContext extends ParserRuleContext {
public PropertyNameContext propertyName() {
return getRuleContext(PropertyNameContext.class,0);
}
public TerminalNode ReadOnly() { return getToken(TypeScriptParser.ReadOnly, 0); }
public TerminalNode QuestionMark() { return getToken(TypeScriptParser.QuestionMark, 0); }
public TypeAnnotationContext typeAnnotation() {
return getRuleContext(TypeAnnotationContext.class,0);
}
public TerminalNode ARROW() { return getToken(TypeScriptParser.ARROW, 0); }
public Type_Context type_() {
return getRuleContext(Type_Context.class,0);
}
public PropertySignatureContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_propertySignature; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterPropertySignature(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitPropertySignature(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitPropertySignature(this);
else return visitor.visitChildren(this);
}
}
public final PropertySignatureContext propertySignature() throws RecognitionException {
PropertySignatureContext _localctx = new PropertySignatureContext(_ctx, getState());
enterRule(_localctx, 58, RULE_propertySignature);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(602);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,37,_ctx) ) {
case 1:
{
setState(601);
match(ReadOnly);
}
break;
}
setState(604);
propertyName();
setState(606);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==QuestionMark) {
{
setState(605);
match(QuestionMark);
}
}
setState(609);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Colon) {
{
setState(608);
typeAnnotation();
}
}
setState(613);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ARROW) {
{
setState(611);
match(ARROW);
setState(612);
type_();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeAnnotationContext extends ParserRuleContext {
public TerminalNode Colon() { return getToken(TypeScriptParser.Colon, 0); }
public Type_Context type_() {
return getRuleContext(Type_Context.class,0);
}
public TypeAnnotationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeAnnotation; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTypeAnnotation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTypeAnnotation(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitTypeAnnotation(this);
else return visitor.visitChildren(this);
}
}
public final TypeAnnotationContext typeAnnotation() throws RecognitionException {
TypeAnnotationContext _localctx = new TypeAnnotationContext(_ctx, getState());
enterRule(_localctx, 60, RULE_typeAnnotation);
try {
enterOuterAlt(_localctx, 1);
{
setState(615);
match(Colon);
setState(616);
type_();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CallSignatureContext extends ParserRuleContext {
public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); }
public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); }
public TypeParametersContext typeParameters() {
return getRuleContext(TypeParametersContext.class,0);
}
public ParameterListContext parameterList() {
return getRuleContext(ParameterListContext.class,0);
}
public TerminalNode Comma() { return getToken(TypeScriptParser.Comma, 0); }
public TypeAnnotationContext typeAnnotation() {
return getRuleContext(TypeAnnotationContext.class,0);
}
public CallSignatureContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_callSignature; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterCallSignature(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitCallSignature(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitCallSignature(this);
else return visitor.visitChildren(this);
}
}
public final CallSignatureContext callSignature() throws RecognitionException {
CallSignatureContext _localctx = new CallSignatureContext(_ctx, getState());
enterRule(_localctx, 62, RULE_callSignature);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(619);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LessThan) {
{
setState(618);
typeParameters();
}
}
setState(621);
match(OpenParen);
setState(623);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << OpenBracket) | (1L << OpenBrace) | (1L << Ellipsis) | (1L << Lodash) | (1L << Dollar) | (1L << NullLiteral) | (1L << BooleanLiteral))) != 0) || ((((_la - 68)) & ~0x3f) == 0 && ((1L << (_la - 68)) & ((1L << (Break - 68)) | (1L << (Do - 68)) | (1L << (Instanceof - 68)) | (1L << (Typeof - 68)) | (1L << (Keyof - 68)) | (1L << (Case - 68)) | (1L << (Else - 68)) | (1L << (New - 68)) | (1L << (Var - 68)) | (1L << (Catch - 68)) | (1L << (Finally - 68)) | (1L << (Return - 68)) | (1L << (Void - 68)) | (1L << (Continue - 68)) | (1L << (For - 68)) | (1L << (Switch - 68)) | (1L << (While - 68)) | (1L << (Debugger - 68)) | (1L << (Function_ - 68)) | (1L << (This - 68)) | (1L << (With - 68)) | (1L << (If - 68)) | (1L << (Throw - 68)) | (1L << (Delete - 68)) | (1L << (In - 68)) | (1L << (Try - 68)) | (1L << (From - 68)) | (1L << (ReadOnly - 68)) | (1L << (Async - 68)) | (1L << (Class - 68)) | (1L << (Enum - 68)) | (1L << (Extends - 68)) | (1L << (Super - 68)) | (1L << (Const - 68)) | (1L << (Export - 68)) | (1L << (Import - 68)) | (1L << (Implements - 68)) | (1L << (Let - 68)) | (1L << (Private - 68)) | (1L << (Public - 68)) | (1L << (Interface - 68)) | (1L << (Package - 68)) | (1L << (Protected - 68)) | (1L << (Static - 68)) | (1L << (Yield - 68)) | (1L << (Any - 68)) | (1L << (Number - 68)) | (1L << (Boolean - 68)) | (1L << (String - 68)) | (1L << (TypeAlias - 68)) | (1L << (Get - 68)) | (1L << (Set - 68)) | (1L << (Namespace - 68)) | (1L << (Require - 68)) | (1L << (Module - 68)) | (1L << (Undefined - 68)))) != 0) || ((((_la - 133)) & ~0x3f) == 0 && ((1L << (_la - 133)) & ((1L << (Is - 133)) | (1L << (At - 133)) | (1L << (Identifier - 133)))) != 0)) {
{
setState(622);
parameterList();
}
}
setState(626);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Comma) {
{
setState(625);
match(Comma);
}
}
setState(628);
match(CloseParen);
setState(630);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,44,_ctx) ) {
case 1:
{
setState(629);
typeAnnotation();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ParameterListContext extends ParserRuleContext {
public ParameterListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_parameterList; }
public ParameterListContext() { }
public void copyFrom(ParameterListContext ctx) {
super.copyFrom(ctx);
}
}
public static class NormalParameterContext extends ParameterListContext {
public List parameter() {
return getRuleContexts(ParameterContext.class);
}
public ParameterContext parameter(int i) {
return getRuleContext(ParameterContext.class,i);
}
public List Comma() { return getTokens(TypeScriptParser.Comma); }
public TerminalNode Comma(int i) {
return getToken(TypeScriptParser.Comma, i);
}
public RestParameterContext restParameter() {
return getRuleContext(RestParameterContext.class,0);
}
public NormalParameterContext(ParameterListContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterNormalParameter(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitNormalParameter(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitNormalParameter(this);
else return visitor.visitChildren(this);
}
}
public static class OnlyRestParameterContext extends ParameterListContext {
public RestParameterContext restParameter() {
return getRuleContext(RestParameterContext.class,0);
}
public OnlyRestParameterContext(ParameterListContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterOnlyRestParameter(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitOnlyRestParameter(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitOnlyRestParameter(this);
else return visitor.visitChildren(this);
}
}
public final ParameterListContext parameterList() throws RecognitionException {
ParameterListContext _localctx = new ParameterListContext(_ctx, getState());
enterRule(_localctx, 64, RULE_parameterList);
try {
int _alt;
setState(645);
_errHandler.sync(this);
switch (_input.LA(1)) {
case Ellipsis:
_localctx = new OnlyRestParameterContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(632);
restParameter();
}
break;
case OpenBracket:
case OpenBrace:
case Lodash:
case Dollar:
case NullLiteral:
case BooleanLiteral:
case Break:
case Do:
case Instanceof:
case Typeof:
case Keyof:
case Case:
case Else:
case New:
case Var:
case Catch:
case Finally:
case Return:
case Void:
case Continue:
case For:
case Switch:
case While:
case Debugger:
case Function_:
case This:
case With:
case If:
case Throw:
case Delete:
case In:
case Try:
case From:
case ReadOnly:
case Async:
case Class:
case Enum:
case Extends:
case Super:
case Const:
case Export:
case Import:
case Implements:
case Let:
case Private:
case Public:
case Interface:
case Package:
case Protected:
case Static:
case Yield:
case Any:
case Number:
case Boolean:
case String:
case TypeAlias:
case Get:
case Set:
case Namespace:
case Require:
case Module:
case Undefined:
case Is:
case At:
case Identifier:
_localctx = new NormalParameterContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(633);
parameter();
setState(638);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,45,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(634);
match(Comma);
setState(635);
parameter();
}
}
}
setState(640);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,45,_ctx);
}
setState(643);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,46,_ctx) ) {
case 1:
{
setState(641);
match(Comma);
setState(642);
restParameter();
}
break;
}
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ParameterContext extends ParserRuleContext {
public RequiredParameterContext requiredParameter() {
return getRuleContext(RequiredParameterContext.class,0);
}
public OptionalParameterContext optionalParameter() {
return getRuleContext(OptionalParameterContext.class,0);
}
public ParameterContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_parameter; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterParameter(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitParameter(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitParameter(this);
else return visitor.visitChildren(this);
}
}
public final ParameterContext parameter() throws RecognitionException {
ParameterContext _localctx = new ParameterContext(_ctx, getState());
enterRule(_localctx, 66, RULE_parameter);
try {
setState(649);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,48,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(647);
requiredParameter();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(648);
optionalParameter();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RequiredParameterContext extends ParserRuleContext {
public IdentifierOrPatternContext identifierOrPattern() {
return getRuleContext(IdentifierOrPatternContext.class,0);
}
public DecoratorListContext decoratorList() {
return getRuleContext(DecoratorListContext.class,0);
}
public AccessibilityModifierContext accessibilityModifier() {
return getRuleContext(AccessibilityModifierContext.class,0);
}
public TypeAnnotationContext typeAnnotation() {
return getRuleContext(TypeAnnotationContext.class,0);
}
public RequiredParameterContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_requiredParameter; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterRequiredParameter(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitRequiredParameter(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitRequiredParameter(this);
else return visitor.visitChildren(this);
}
}
public final RequiredParameterContext requiredParameter() throws RecognitionException {
RequiredParameterContext _localctx = new RequiredParameterContext(_ctx, getState());
enterRule(_localctx, 68, RULE_requiredParameter);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(652);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==At) {
{
setState(651);
decoratorList();
}
}
setState(655);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,50,_ctx) ) {
case 1:
{
setState(654);
accessibilityModifier();
}
break;
}
setState(657);
identifierOrPattern();
setState(659);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Colon) {
{
setState(658);
typeAnnotation();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OptionalParameterContext extends ParserRuleContext {
public IdentifierOrPatternContext identifierOrPattern() {
return getRuleContext(IdentifierOrPatternContext.class,0);
}
public DecoratorListContext decoratorList() {
return getRuleContext(DecoratorListContext.class,0);
}
public TerminalNode QuestionMark() { return getToken(TypeScriptParser.QuestionMark, 0); }
public InitializerContext initializer() {
return getRuleContext(InitializerContext.class,0);
}
public AccessibilityModifierContext accessibilityModifier() {
return getRuleContext(AccessibilityModifierContext.class,0);
}
public TypeAnnotationContext typeAnnotation() {
return getRuleContext(TypeAnnotationContext.class,0);
}
public OptionalParameterContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_optionalParameter; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterOptionalParameter(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitOptionalParameter(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitOptionalParameter(this);
else return visitor.visitChildren(this);
}
}
public final OptionalParameterContext optionalParameter() throws RecognitionException {
OptionalParameterContext _localctx = new OptionalParameterContext(_ctx, getState());
enterRule(_localctx, 70, RULE_optionalParameter);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(662);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==At) {
{
setState(661);
decoratorList();
}
}
{
setState(665);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,53,_ctx) ) {
case 1:
{
setState(664);
accessibilityModifier();
}
break;
}
setState(667);
identifierOrPattern();
setState(676);
_errHandler.sync(this);
switch (_input.LA(1)) {
case QuestionMark:
{
setState(668);
match(QuestionMark);
setState(670);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Colon) {
{
setState(669);
typeAnnotation();
}
}
}
break;
case Assign:
case Colon:
{
setState(673);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Colon) {
{
setState(672);
typeAnnotation();
}
}
setState(675);
initializer();
}
break;
default:
throw new NoViableAltException(this);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RestParameterContext extends ParserRuleContext {
public TerminalNode Ellipsis() { return getToken(TypeScriptParser.Ellipsis, 0); }
public SingleExpressionContext singleExpression() {
return getRuleContext(SingleExpressionContext.class,0);
}
public TypeAnnotationContext typeAnnotation() {
return getRuleContext(TypeAnnotationContext.class,0);
}
public RestParameterContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_restParameter; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterRestParameter(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitRestParameter(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitRestParameter(this);
else return visitor.visitChildren(this);
}
}
public final RestParameterContext restParameter() throws RecognitionException {
RestParameterContext _localctx = new RestParameterContext(_ctx, getState());
enterRule(_localctx, 72, RULE_restParameter);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(678);
match(Ellipsis);
setState(679);
singleExpression(0);
setState(681);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Colon) {
{
setState(680);
typeAnnotation();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class IdentifierOrPatternContext extends ParserRuleContext {
public IdentifierNameContext identifierName() {
return getRuleContext(IdentifierNameContext.class,0);
}
public BindingPatternContext bindingPattern() {
return getRuleContext(BindingPatternContext.class,0);
}
public IdentifierOrPatternContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_identifierOrPattern; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterIdentifierOrPattern(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitIdentifierOrPattern(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitIdentifierOrPattern(this);
else return visitor.visitChildren(this);
}
}
public final IdentifierOrPatternContext identifierOrPattern() throws RecognitionException {
IdentifierOrPatternContext _localctx = new IdentifierOrPatternContext(_ctx, getState());
enterRule(_localctx, 74, RULE_identifierOrPattern);
try {
setState(685);
_errHandler.sync(this);
switch (_input.LA(1)) {
case Lodash:
case Dollar:
case NullLiteral:
case BooleanLiteral:
case Break:
case Do:
case Instanceof:
case Typeof:
case Keyof:
case Case:
case Else:
case New:
case Var:
case Catch:
case Finally:
case Return:
case Void:
case Continue:
case For:
case Switch:
case While:
case Debugger:
case Function_:
case This:
case With:
case If:
case Throw:
case Delete:
case In:
case Try:
case From:
case ReadOnly:
case Async:
case Class:
case Enum:
case Extends:
case Super:
case Const:
case Export:
case Import:
case Implements:
case Let:
case Private:
case Public:
case Interface:
case Package:
case Protected:
case Static:
case Yield:
case Any:
case Number:
case Boolean:
case String:
case TypeAlias:
case Get:
case Set:
case Namespace:
case Require:
case Module:
case Undefined:
case Is:
case Identifier:
enterOuterAlt(_localctx, 1);
{
setState(683);
identifierName();
}
break;
case OpenBracket:
case OpenBrace:
enterOuterAlt(_localctx, 2);
{
setState(684);
bindingPattern();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AccessibilityModifierContext extends ParserRuleContext {
public TerminalNode Public() { return getToken(TypeScriptParser.Public, 0); }
public TerminalNode Private() { return getToken(TypeScriptParser.Private, 0); }
public TerminalNode Protected() { return getToken(TypeScriptParser.Protected, 0); }
public AccessibilityModifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_accessibilityModifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterAccessibilityModifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitAccessibilityModifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitAccessibilityModifier(this);
else return visitor.visitChildren(this);
}
}
public final AccessibilityModifierContext accessibilityModifier() throws RecognitionException {
AccessibilityModifierContext _localctx = new AccessibilityModifierContext(_ctx, getState());
enterRule(_localctx, 76, RULE_accessibilityModifier);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(687);
_la = _input.LA(1);
if ( !(((((_la - 110)) & ~0x3f) == 0 && ((1L << (_la - 110)) & ((1L << (Private - 110)) | (1L << (Public - 110)) | (1L << (Protected - 110)))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ConstructSignatureContext extends ParserRuleContext {
public TerminalNode New() { return getToken(TypeScriptParser.New, 0); }
public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); }
public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); }
public TypeParametersContext typeParameters() {
return getRuleContext(TypeParametersContext.class,0);
}
public ParameterListContext parameterList() {
return getRuleContext(ParameterListContext.class,0);
}
public TypeAnnotationContext typeAnnotation() {
return getRuleContext(TypeAnnotationContext.class,0);
}
public ConstructSignatureContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_constructSignature; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterConstructSignature(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitConstructSignature(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitConstructSignature(this);
else return visitor.visitChildren(this);
}
}
public final ConstructSignatureContext constructSignature() throws RecognitionException {
ConstructSignatureContext _localctx = new ConstructSignatureContext(_ctx, getState());
enterRule(_localctx, 78, RULE_constructSignature);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(689);
match(New);
setState(691);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LessThan) {
{
setState(690);
typeParameters();
}
}
setState(693);
match(OpenParen);
setState(695);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << OpenBracket) | (1L << OpenBrace) | (1L << Ellipsis) | (1L << Lodash) | (1L << Dollar) | (1L << NullLiteral) | (1L << BooleanLiteral))) != 0) || ((((_la - 68)) & ~0x3f) == 0 && ((1L << (_la - 68)) & ((1L << (Break - 68)) | (1L << (Do - 68)) | (1L << (Instanceof - 68)) | (1L << (Typeof - 68)) | (1L << (Keyof - 68)) | (1L << (Case - 68)) | (1L << (Else - 68)) | (1L << (New - 68)) | (1L << (Var - 68)) | (1L << (Catch - 68)) | (1L << (Finally - 68)) | (1L << (Return - 68)) | (1L << (Void - 68)) | (1L << (Continue - 68)) | (1L << (For - 68)) | (1L << (Switch - 68)) | (1L << (While - 68)) | (1L << (Debugger - 68)) | (1L << (Function_ - 68)) | (1L << (This - 68)) | (1L << (With - 68)) | (1L << (If - 68)) | (1L << (Throw - 68)) | (1L << (Delete - 68)) | (1L << (In - 68)) | (1L << (Try - 68)) | (1L << (From - 68)) | (1L << (ReadOnly - 68)) | (1L << (Async - 68)) | (1L << (Class - 68)) | (1L << (Enum - 68)) | (1L << (Extends - 68)) | (1L << (Super - 68)) | (1L << (Const - 68)) | (1L << (Export - 68)) | (1L << (Import - 68)) | (1L << (Implements - 68)) | (1L << (Let - 68)) | (1L << (Private - 68)) | (1L << (Public - 68)) | (1L << (Interface - 68)) | (1L << (Package - 68)) | (1L << (Protected - 68)) | (1L << (Static - 68)) | (1L << (Yield - 68)) | (1L << (Any - 68)) | (1L << (Number - 68)) | (1L << (Boolean - 68)) | (1L << (String - 68)) | (1L << (TypeAlias - 68)) | (1L << (Get - 68)) | (1L << (Set - 68)) | (1L << (Namespace - 68)) | (1L << (Require - 68)) | (1L << (Module - 68)) | (1L << (Undefined - 68)))) != 0) || ((((_la - 133)) & ~0x3f) == 0 && ((1L << (_la - 133)) & ((1L << (Is - 133)) | (1L << (At - 133)) | (1L << (Identifier - 133)))) != 0)) {
{
setState(694);
parameterList();
}
}
setState(697);
match(CloseParen);
setState(699);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Colon) {
{
setState(698);
typeAnnotation();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class IndexSignatureContext extends ParserRuleContext {
public TerminalNode OpenBracket() { return getToken(TypeScriptParser.OpenBracket, 0); }
public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); }
public TerminalNode Colon() { return getToken(TypeScriptParser.Colon, 0); }
public TerminalNode CloseBracket() { return getToken(TypeScriptParser.CloseBracket, 0); }
public TypeAnnotationContext typeAnnotation() {
return getRuleContext(TypeAnnotationContext.class,0);
}
public TerminalNode Number() { return getToken(TypeScriptParser.Number, 0); }
public TerminalNode String() { return getToken(TypeScriptParser.String, 0); }
public IndexSignatureContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_indexSignature; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterIndexSignature(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitIndexSignature(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitIndexSignature(this);
else return visitor.visitChildren(this);
}
}
public final IndexSignatureContext indexSignature() throws RecognitionException {
IndexSignatureContext _localctx = new IndexSignatureContext(_ctx, getState());
enterRule(_localctx, 80, RULE_indexSignature);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(701);
match(OpenBracket);
setState(702);
match(Identifier);
setState(703);
match(Colon);
setState(704);
_la = _input.LA(1);
if ( !(_la==Number || _la==String) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(705);
match(CloseBracket);
setState(706);
typeAnnotation();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EnumSignatureContext extends ParserRuleContext {
public IdentifierOrKeyWordContext identifierOrKeyWord() {
return getRuleContext(IdentifierOrKeyWordContext.class,0);
}
public TerminalNode Colon() { return getToken(TypeScriptParser.Colon, 0); }
public List type_() {
return getRuleContexts(Type_Context.class);
}
public Type_Context type_(int i) {
return getRuleContext(Type_Context.class,i);
}
public TerminalNode QuestionMark() { return getToken(TypeScriptParser.QuestionMark, 0); }
public List BitOr() { return getTokens(TypeScriptParser.BitOr); }
public TerminalNode BitOr(int i) {
return getToken(TypeScriptParser.BitOr, i);
}
public EnumSignatureContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_enumSignature; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterEnumSignature(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitEnumSignature(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitEnumSignature(this);
else return visitor.visitChildren(this);
}
}
public final EnumSignatureContext enumSignature() throws RecognitionException {
EnumSignatureContext _localctx = new EnumSignatureContext(_ctx, getState());
enterRule(_localctx, 82, RULE_enumSignature);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(708);
identifierOrKeyWord();
setState(710);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==QuestionMark) {
{
setState(709);
match(QuestionMark);
}
}
setState(712);
match(Colon);
setState(714);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,63,_ctx) ) {
case 1:
{
setState(713);
match(BitOr);
}
break;
}
setState(716);
type_();
setState(721);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==BitOr) {
{
{
setState(717);
match(BitOr);
setState(718);
type_();
}
}
setState(723);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MethodSignatureContext extends ParserRuleContext {
public PropertyNameContext propertyName() {
return getRuleContext(PropertyNameContext.class,0);
}
public CallSignatureContext callSignature() {
return getRuleContext(CallSignatureContext.class,0);
}
public TerminalNode QuestionMark() { return getToken(TypeScriptParser.QuestionMark, 0); }
public MethodSignatureContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_methodSignature; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterMethodSignature(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitMethodSignature(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitMethodSignature(this);
else return visitor.visitChildren(this);
}
}
public final MethodSignatureContext methodSignature() throws RecognitionException {
MethodSignatureContext _localctx = new MethodSignatureContext(_ctx, getState());
enterRule(_localctx, 84, RULE_methodSignature);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(724);
propertyName();
setState(726);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==QuestionMark) {
{
setState(725);
match(QuestionMark);
}
}
setState(728);
callSignature();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeAliasDeclarationContext extends ParserRuleContext {
public TerminalNode TypeAlias() { return getToken(TypeScriptParser.TypeAlias, 0); }
public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); }
public TerminalNode Assign() { return getToken(TypeScriptParser.Assign, 0); }
public Type_Context type_() {
return getRuleContext(Type_Context.class,0);
}
public TypeParametersContext typeParameters() {
return getRuleContext(TypeParametersContext.class,0);
}
public TerminalNode SemiColon() { return getToken(TypeScriptParser.SemiColon, 0); }
public TypeAliasDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeAliasDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTypeAliasDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTypeAliasDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitTypeAliasDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final TypeAliasDeclarationContext typeAliasDeclaration() throws RecognitionException {
TypeAliasDeclarationContext _localctx = new TypeAliasDeclarationContext(_ctx, getState());
enterRule(_localctx, 86, RULE_typeAliasDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(730);
match(TypeAlias);
setState(731);
match(Identifier);
setState(733);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LessThan) {
{
setState(732);
typeParameters();
}
}
setState(735);
match(Assign);
setState(736);
type_();
setState(738);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,67,_ctx) ) {
case 1:
{
setState(737);
match(SemiColon);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ConstructorDeclarationContext extends ParserRuleContext {
public TerminalNode Constructor() { return getToken(TypeScriptParser.Constructor, 0); }
public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); }
public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); }
public AccessibilityModifierContext accessibilityModifier() {
return getRuleContext(AccessibilityModifierContext.class,0);
}
public FormalParameterListContext formalParameterList() {
return getRuleContext(FormalParameterListContext.class,0);
}
public TerminalNode SemiColon() { return getToken(TypeScriptParser.SemiColon, 0); }
public TerminalNode OpenBrace() { return getToken(TypeScriptParser.OpenBrace, 0); }
public FunctionBodyContext functionBody() {
return getRuleContext(FunctionBodyContext.class,0);
}
public TerminalNode CloseBrace() { return getToken(TypeScriptParser.CloseBrace, 0); }
public ConstructorDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_constructorDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterConstructorDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitConstructorDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitConstructorDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final ConstructorDeclarationContext constructorDeclaration() throws RecognitionException {
ConstructorDeclarationContext _localctx = new ConstructorDeclarationContext(_ctx, getState());
enterRule(_localctx, 88, RULE_constructorDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(741);
_errHandler.sync(this);
_la = _input.LA(1);
if (((((_la - 110)) & ~0x3f) == 0 && ((1L << (_la - 110)) & ((1L << (Private - 110)) | (1L << (Public - 110)) | (1L << (Protected - 110)))) != 0)) {
{
setState(740);
accessibilityModifier();
}
}
setState(743);
match(Constructor);
setState(744);
match(OpenParen);
setState(746);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << OpenBracket) | (1L << OpenBrace) | (1L << Ellipsis) | (1L << Lodash))) != 0) || ((((_la - 110)) & ~0x3f) == 0 && ((1L << (_la - 110)) & ((1L << (Private - 110)) | (1L << (Public - 110)) | (1L << (Protected - 110)) | (1L << (Any - 110)) | (1L << (TypeAlias - 110)) | (1L << (Require - 110)) | (1L << (Module - 110)) | (1L << (At - 110)) | (1L << (Identifier - 110)))) != 0)) {
{
setState(745);
formalParameterList();
}
}
setState(748);
match(CloseParen);
setState(754);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,70,_ctx) ) {
case 1:
{
{
setState(749);
match(OpenBrace);
setState(750);
functionBody();
setState(751);
match(CloseBrace);
}
}
break;
case 2:
{
setState(753);
match(SemiColon);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class InterfaceDeclarationContext extends ParserRuleContext {
public TerminalNode Interface() { return getToken(TypeScriptParser.Interface, 0); }
public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); }
public ObjectTypeContext objectType() {
return getRuleContext(ObjectTypeContext.class,0);
}
public TerminalNode Export() { return getToken(TypeScriptParser.Export, 0); }
public TerminalNode Declare() { return getToken(TypeScriptParser.Declare, 0); }
public TypeParametersContext typeParameters() {
return getRuleContext(TypeParametersContext.class,0);
}
public InterfaceExtendsClauseContext interfaceExtendsClause() {
return getRuleContext(InterfaceExtendsClauseContext.class,0);
}
public TerminalNode SemiColon() { return getToken(TypeScriptParser.SemiColon, 0); }
public InterfaceDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_interfaceDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterInterfaceDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitInterfaceDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitInterfaceDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final InterfaceDeclarationContext interfaceDeclaration() throws RecognitionException {
InterfaceDeclarationContext _localctx = new InterfaceDeclarationContext(_ctx, getState());
enterRule(_localctx, 90, RULE_interfaceDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(757);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Export) {
{
setState(756);
match(Export);
}
}
setState(760);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Declare) {
{
setState(759);
match(Declare);
}
}
setState(762);
match(Interface);
setState(763);
match(Identifier);
setState(765);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LessThan) {
{
setState(764);
typeParameters();
}
}
setState(768);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Extends) {
{
setState(767);
interfaceExtendsClause();
}
}
setState(770);
objectType();
setState(772);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,75,_ctx) ) {
case 1:
{
setState(771);
match(SemiColon);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class InterfaceExtendsClauseContext extends ParserRuleContext {
public TerminalNode Extends() { return getToken(TypeScriptParser.Extends, 0); }
public ClassOrInterfaceTypeListContext classOrInterfaceTypeList() {
return getRuleContext(ClassOrInterfaceTypeListContext.class,0);
}
public InterfaceExtendsClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_interfaceExtendsClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterInterfaceExtendsClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitInterfaceExtendsClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitInterfaceExtendsClause(this);
else return visitor.visitChildren(this);
}
}
public final InterfaceExtendsClauseContext interfaceExtendsClause() throws RecognitionException {
InterfaceExtendsClauseContext _localctx = new InterfaceExtendsClauseContext(_ctx, getState());
enterRule(_localctx, 92, RULE_interfaceExtendsClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(774);
match(Extends);
setState(775);
classOrInterfaceTypeList();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ClassOrInterfaceTypeListContext extends ParserRuleContext {
public List typeReference() {
return getRuleContexts(TypeReferenceContext.class);
}
public TypeReferenceContext typeReference(int i) {
return getRuleContext(TypeReferenceContext.class,i);
}
public List Comma() { return getTokens(TypeScriptParser.Comma); }
public TerminalNode Comma(int i) {
return getToken(TypeScriptParser.Comma, i);
}
public ClassOrInterfaceTypeListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_classOrInterfaceTypeList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterClassOrInterfaceTypeList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitClassOrInterfaceTypeList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitClassOrInterfaceTypeList(this);
else return visitor.visitChildren(this);
}
}
public final ClassOrInterfaceTypeListContext classOrInterfaceTypeList() throws RecognitionException {
ClassOrInterfaceTypeListContext _localctx = new ClassOrInterfaceTypeListContext(_ctx, getState());
enterRule(_localctx, 94, RULE_classOrInterfaceTypeList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(777);
typeReference();
setState(782);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==Comma) {
{
{
setState(778);
match(Comma);
setState(779);
typeReference();
}
}
setState(784);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EnumDeclarationContext extends ParserRuleContext {
public TerminalNode Enum() { return getToken(TypeScriptParser.Enum, 0); }
public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); }
public TerminalNode OpenBrace() { return getToken(TypeScriptParser.OpenBrace, 0); }
public TerminalNode CloseBrace() { return getToken(TypeScriptParser.CloseBrace, 0); }
public TerminalNode Const() { return getToken(TypeScriptParser.Const, 0); }
public EnumBodyContext enumBody() {
return getRuleContext(EnumBodyContext.class,0);
}
public EnumDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_enumDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterEnumDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitEnumDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitEnumDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final EnumDeclarationContext enumDeclaration() throws RecognitionException {
EnumDeclarationContext _localctx = new EnumDeclarationContext(_ctx, getState());
enterRule(_localctx, 96, RULE_enumDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(786);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Const) {
{
setState(785);
match(Const);
}
}
setState(788);
match(Enum);
setState(789);
match(Identifier);
setState(790);
match(OpenBrace);
setState(792);
_errHandler.sync(this);
_la = _input.LA(1);
if (((((_la - 59)) & ~0x3f) == 0 && ((1L << (_la - 59)) & ((1L << (Lodash - 59)) | (1L << (Dollar - 59)) | (1L << (NullLiteral - 59)) | (1L << (BooleanLiteral - 59)) | (1L << (DecimalLiteral - 59)) | (1L << (HexIntegerLiteral - 59)) | (1L << (OctalIntegerLiteral - 59)) | (1L << (OctalIntegerLiteral2 - 59)) | (1L << (BinaryIntegerLiteral - 59)) | (1L << (Break - 59)) | (1L << (Do - 59)) | (1L << (Instanceof - 59)) | (1L << (Typeof - 59)) | (1L << (Keyof - 59)) | (1L << (Case - 59)) | (1L << (Else - 59)) | (1L << (New - 59)) | (1L << (Var - 59)) | (1L << (Catch - 59)) | (1L << (Finally - 59)) | (1L << (Return - 59)) | (1L << (Void - 59)) | (1L << (Continue - 59)) | (1L << (For - 59)) | (1L << (Switch - 59)) | (1L << (While - 59)) | (1L << (Debugger - 59)) | (1L << (Function_ - 59)) | (1L << (This - 59)) | (1L << (With - 59)) | (1L << (Default - 59)) | (1L << (If - 59)) | (1L << (Throw - 59)) | (1L << (Delete - 59)) | (1L << (In - 59)) | (1L << (Try - 59)) | (1L << (From - 59)) | (1L << (ReadOnly - 59)) | (1L << (Async - 59)) | (1L << (Class - 59)) | (1L << (Enum - 59)) | (1L << (Extends - 59)) | (1L << (Super - 59)) | (1L << (Const - 59)) | (1L << (Export - 59)) | (1L << (Import - 59)) | (1L << (Implements - 59)) | (1L << (Let - 59)) | (1L << (Private - 59)) | (1L << (Public - 59)) | (1L << (Interface - 59)) | (1L << (Package - 59)) | (1L << (Protected - 59)) | (1L << (Static - 59)) | (1L << (Yield - 59)) | (1L << (Any - 59)) | (1L << (Number - 59)) | (1L << (Boolean - 59)) | (1L << (String - 59)) | (1L << (Symbol - 59)) | (1L << (TypeAlias - 59)))) != 0) || ((((_la - 123)) & ~0x3f) == 0 && ((1L << (_la - 123)) & ((1L << (Get - 123)) | (1L << (Set - 123)) | (1L << (Namespace - 123)) | (1L << (Require - 123)) | (1L << (Module - 123)) | (1L << (Undefined - 123)) | (1L << (Is - 123)) | (1L << (Identifier - 123)) | (1L << (StringLiteral - 123)))) != 0)) {
{
setState(791);
enumBody();
}
}
setState(794);
match(CloseBrace);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EnumBodyContext extends ParserRuleContext {
public EnumMemberListContext enumMemberList() {
return getRuleContext(EnumMemberListContext.class,0);
}
public TerminalNode Comma() { return getToken(TypeScriptParser.Comma, 0); }
public EnumBodyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_enumBody; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterEnumBody(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitEnumBody(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitEnumBody(this);
else return visitor.visitChildren(this);
}
}
public final EnumBodyContext enumBody() throws RecognitionException {
EnumBodyContext _localctx = new EnumBodyContext(_ctx, getState());
enterRule(_localctx, 98, RULE_enumBody);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(796);
enumMemberList();
setState(798);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Comma) {
{
setState(797);
match(Comma);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EnumMemberListContext extends ParserRuleContext {
public List enumMember() {
return getRuleContexts(EnumMemberContext.class);
}
public EnumMemberContext enumMember(int i) {
return getRuleContext(EnumMemberContext.class,i);
}
public List Comma() { return getTokens(TypeScriptParser.Comma); }
public TerminalNode Comma(int i) {
return getToken(TypeScriptParser.Comma, i);
}
public EnumMemberListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_enumMemberList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterEnumMemberList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitEnumMemberList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitEnumMemberList(this);
else return visitor.visitChildren(this);
}
}
public final EnumMemberListContext enumMemberList() throws RecognitionException {
EnumMemberListContext _localctx = new EnumMemberListContext(_ctx, getState());
enterRule(_localctx, 100, RULE_enumMemberList);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(800);
enumMember();
setState(805);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,80,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(801);
match(Comma);
setState(802);
enumMember();
}
}
}
setState(807);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,80,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EnumMemberContext extends ParserRuleContext {
public PropertyNameContext propertyName() {
return getRuleContext(PropertyNameContext.class,0);
}
public TerminalNode Assign() { return getToken(TypeScriptParser.Assign, 0); }
public SingleExpressionContext singleExpression() {
return getRuleContext(SingleExpressionContext.class,0);
}
public EnumMemberContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_enumMember; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterEnumMember(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitEnumMember(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitEnumMember(this);
else return visitor.visitChildren(this);
}
}
public final EnumMemberContext enumMember() throws RecognitionException {
EnumMemberContext _localctx = new EnumMemberContext(_ctx, getState());
enterRule(_localctx, 102, RULE_enumMember);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(808);
propertyName();
setState(811);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Assign) {
{
setState(809);
match(Assign);
setState(810);
singleExpression(0);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NamespaceDeclarationContext extends ParserRuleContext {
public TerminalNode Namespace() { return getToken(TypeScriptParser.Namespace, 0); }
public NamespaceNameContext namespaceName() {
return getRuleContext(NamespaceNameContext.class,0);
}
public TerminalNode OpenBrace() { return getToken(TypeScriptParser.OpenBrace, 0); }
public TerminalNode CloseBrace() { return getToken(TypeScriptParser.CloseBrace, 0); }
public StatementListContext statementList() {
return getRuleContext(StatementListContext.class,0);
}
public NamespaceDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_namespaceDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterNamespaceDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitNamespaceDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitNamespaceDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final NamespaceDeclarationContext namespaceDeclaration() throws RecognitionException {
NamespaceDeclarationContext _localctx = new NamespaceDeclarationContext(_ctx, getState());
enterRule(_localctx, 104, RULE_namespaceDeclaration);
try {
enterOuterAlt(_localctx, 1);
{
setState(813);
match(Namespace);
setState(814);
namespaceName();
setState(815);
match(OpenBrace);
setState(817);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,82,_ctx) ) {
case 1:
{
setState(816);
statementList();
}
break;
}
setState(819);
match(CloseBrace);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NamespaceNameContext extends ParserRuleContext {
public List Identifier() { return getTokens(TypeScriptParser.Identifier); }
public TerminalNode Identifier(int i) {
return getToken(TypeScriptParser.Identifier, i);
}
public List Dot() { return getTokens(TypeScriptParser.Dot); }
public TerminalNode Dot(int i) {
return getToken(TypeScriptParser.Dot, i);
}
public NamespaceNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_namespaceName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterNamespaceName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitNamespaceName(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitNamespaceName(this);
else return visitor.visitChildren(this);
}
}
public final NamespaceNameContext namespaceName() throws RecognitionException {
NamespaceNameContext _localctx = new NamespaceNameContext(_ctx, getState());
enterRule(_localctx, 106, RULE_namespaceName);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(821);
match(Identifier);
setState(830);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,84,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(823);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(822);
match(Dot);
}
}
setState(825);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==Dot );
setState(827);
match(Identifier);
}
}
}
setState(832);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,84,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ImportAliasDeclarationContext extends ParserRuleContext {
public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); }
public TerminalNode Assign() { return getToken(TypeScriptParser.Assign, 0); }
public NamespaceNameContext namespaceName() {
return getRuleContext(NamespaceNameContext.class,0);
}
public TerminalNode SemiColon() { return getToken(TypeScriptParser.SemiColon, 0); }
public TerminalNode Require() { return getToken(TypeScriptParser.Require, 0); }
public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); }
public TerminalNode StringLiteral() { return getToken(TypeScriptParser.StringLiteral, 0); }
public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); }
public ImportAliasDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_importAliasDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterImportAliasDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitImportAliasDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitImportAliasDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final ImportAliasDeclarationContext importAliasDeclaration() throws RecognitionException {
ImportAliasDeclarationContext _localctx = new ImportAliasDeclarationContext(_ctx, getState());
enterRule(_localctx, 108, RULE_importAliasDeclaration);
try {
setState(845);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,85,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(833);
match(Identifier);
setState(834);
match(Assign);
setState(835);
namespaceName();
setState(836);
match(SemiColon);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(838);
match(Identifier);
setState(839);
match(Assign);
setState(840);
match(Require);
setState(841);
match(OpenParen);
setState(842);
match(StringLiteral);
setState(843);
match(CloseParen);
setState(844);
match(SemiColon);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ImportAllContext extends ParserRuleContext {
public TerminalNode StringLiteral() { return getToken(TypeScriptParser.StringLiteral, 0); }
public ImportAllContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_importAll; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterImportAll(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitImportAll(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitImportAll(this);
else return visitor.visitChildren(this);
}
}
public final ImportAllContext importAll() throws RecognitionException {
ImportAllContext _localctx = new ImportAllContext(_ctx, getState());
enterRule(_localctx, 110, RULE_importAll);
try {
enterOuterAlt(_localctx, 1);
{
setState(847);
match(StringLiteral);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DecoratorListContext extends ParserRuleContext {
public List decorator() {
return getRuleContexts(DecoratorContext.class);
}
public DecoratorContext decorator(int i) {
return getRuleContext(DecoratorContext.class,i);
}
public DecoratorListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_decoratorList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterDecoratorList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitDecoratorList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitDecoratorList(this);
else return visitor.visitChildren(this);
}
}
public final DecoratorListContext decoratorList() throws RecognitionException {
DecoratorListContext _localctx = new DecoratorListContext(_ctx, getState());
enterRule(_localctx, 112, RULE_decoratorList);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(850);
_errHandler.sync(this);
_alt = 1;
do {
switch (_alt) {
case 1:
{
{
setState(849);
decorator();
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(852);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,86,_ctx);
} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DecoratorContext extends ParserRuleContext {
public TerminalNode At() { return getToken(TypeScriptParser.At, 0); }
public DecoratorMemberExpressionContext decoratorMemberExpression() {
return getRuleContext(DecoratorMemberExpressionContext.class,0);
}
public DecoratorCallExpressionContext decoratorCallExpression() {
return getRuleContext(DecoratorCallExpressionContext.class,0);
}
public DecoratorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_decorator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterDecorator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitDecorator(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitDecorator(this);
else return visitor.visitChildren(this);
}
}
public final DecoratorContext decorator() throws RecognitionException {
DecoratorContext _localctx = new DecoratorContext(_ctx, getState());
enterRule(_localctx, 114, RULE_decorator);
try {
enterOuterAlt(_localctx, 1);
{
setState(854);
match(At);
setState(857);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,87,_ctx) ) {
case 1:
{
setState(855);
decoratorMemberExpression(0);
}
break;
case 2:
{
setState(856);
decoratorCallExpression();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DecoratorMemberExpressionContext extends ParserRuleContext {
public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); }
public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); }
public SingleExpressionContext singleExpression() {
return getRuleContext(SingleExpressionContext.class,0);
}
public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); }
public DecoratorMemberExpressionContext decoratorMemberExpression() {
return getRuleContext(DecoratorMemberExpressionContext.class,0);
}
public TerminalNode Dot() { return getToken(TypeScriptParser.Dot, 0); }
public IdentifierNameContext identifierName() {
return getRuleContext(IdentifierNameContext.class,0);
}
public DecoratorMemberExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_decoratorMemberExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterDecoratorMemberExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitDecoratorMemberExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitDecoratorMemberExpression(this);
else return visitor.visitChildren(this);
}
}
public final DecoratorMemberExpressionContext decoratorMemberExpression() throws RecognitionException {
return decoratorMemberExpression(0);
}
private DecoratorMemberExpressionContext decoratorMemberExpression(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
DecoratorMemberExpressionContext _localctx = new DecoratorMemberExpressionContext(_ctx, _parentState);
DecoratorMemberExpressionContext _prevctx = _localctx;
int _startState = 116;
enterRecursionRule(_localctx, 116, RULE_decoratorMemberExpression, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(865);
_errHandler.sync(this);
switch (_input.LA(1)) {
case Identifier:
{
setState(860);
match(Identifier);
}
break;
case OpenParen:
{
setState(861);
match(OpenParen);
setState(862);
singleExpression(0);
setState(863);
match(CloseParen);
}
break;
default:
throw new NoViableAltException(this);
}
_ctx.stop = _input.LT(-1);
setState(872);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,89,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new DecoratorMemberExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_decoratorMemberExpression);
setState(867);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(868);
match(Dot);
setState(869);
identifierName();
}
}
}
setState(874);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,89,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class DecoratorCallExpressionContext extends ParserRuleContext {
public DecoratorMemberExpressionContext decoratorMemberExpression() {
return getRuleContext(DecoratorMemberExpressionContext.class,0);
}
public ArgumentsContext arguments() {
return getRuleContext(ArgumentsContext.class,0);
}
public DecoratorCallExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_decoratorCallExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterDecoratorCallExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitDecoratorCallExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitDecoratorCallExpression(this);
else return visitor.visitChildren(this);
}
}
public final DecoratorCallExpressionContext decoratorCallExpression() throws RecognitionException {
DecoratorCallExpressionContext _localctx = new DecoratorCallExpressionContext(_ctx, getState());
enterRule(_localctx, 118, RULE_decoratorCallExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(875);
decoratorMemberExpression(0);
setState(876);
arguments();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ProgramContext extends ParserRuleContext {
public TerminalNode EOF() { return getToken(TypeScriptParser.EOF, 0); }
public SourceElementsContext sourceElements() {
return getRuleContext(SourceElementsContext.class,0);
}
public ProgramContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_program; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterProgram(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitProgram(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitProgram(this);
else return visitor.visitChildren(this);
}
}
public final ProgramContext program() throws RecognitionException {
ProgramContext _localctx = new ProgramContext(_ctx, getState());
enterRule(_localctx, 120, RULE_program);
try {
enterOuterAlt(_localctx, 1);
{
setState(879);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,90,_ctx) ) {
case 1:
{
setState(878);
sourceElements();
}
break;
}
setState(881);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SourceElementContext extends ParserRuleContext {
public StatementContext statement() {
return getRuleContext(StatementContext.class,0);
}
public TerminalNode Export() { return getToken(TypeScriptParser.Export, 0); }
public SourceElementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_sourceElement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterSourceElement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitSourceElement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitSourceElement(this);
else return visitor.visitChildren(this);
}
}
public final SourceElementContext sourceElement() throws RecognitionException {
SourceElementContext _localctx = new SourceElementContext(_ctx, getState());
enterRule(_localctx, 122, RULE_sourceElement);
try {
enterOuterAlt(_localctx, 1);
{
setState(884);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,91,_ctx) ) {
case 1:
{
setState(883);
match(Export);
}
break;
}
setState(886);
statement();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StatementContext extends ParserRuleContext {
public BlockContext block() {
return getRuleContext(BlockContext.class,0);
}
public ImportStatementContext importStatement() {
return getRuleContext(ImportStatementContext.class,0);
}
public ExportStatementContext exportStatement() {
return getRuleContext(ExportStatementContext.class,0);
}
public EmptyStatement_Context emptyStatement_() {
return getRuleContext(EmptyStatement_Context.class,0);
}
public AbstractDeclarationContext abstractDeclaration() {
return getRuleContext(AbstractDeclarationContext.class,0);
}
public DecoratorListContext decoratorList() {
return getRuleContext(DecoratorListContext.class,0);
}
public ClassDeclarationContext classDeclaration() {
return getRuleContext(ClassDeclarationContext.class,0);
}
public InterfaceDeclarationContext interfaceDeclaration() {
return getRuleContext(InterfaceDeclarationContext.class,0);
}
public NamespaceDeclarationContext namespaceDeclaration() {
return getRuleContext(NamespaceDeclarationContext.class,0);
}
public IfStatementContext ifStatement() {
return getRuleContext(IfStatementContext.class,0);
}
public IterationStatementContext iterationStatement() {
return getRuleContext(IterationStatementContext.class,0);
}
public ContinueStatementContext continueStatement() {
return getRuleContext(ContinueStatementContext.class,0);
}
public BreakStatementContext breakStatement() {
return getRuleContext(BreakStatementContext.class,0);
}
public ReturnStatementContext returnStatement() {
return getRuleContext(ReturnStatementContext.class,0);
}
public YieldStatementContext yieldStatement() {
return getRuleContext(YieldStatementContext.class,0);
}
public WithStatementContext withStatement() {
return getRuleContext(WithStatementContext.class,0);
}
public LabelledStatementContext labelledStatement() {
return getRuleContext(LabelledStatementContext.class,0);
}
public SwitchStatementContext switchStatement() {
return getRuleContext(SwitchStatementContext.class,0);
}
public ThrowStatementContext throwStatement() {
return getRuleContext(ThrowStatementContext.class,0);
}
public TryStatementContext tryStatement() {
return getRuleContext(TryStatementContext.class,0);
}
public DebuggerStatementContext debuggerStatement() {
return getRuleContext(DebuggerStatementContext.class,0);
}
public FunctionDeclarationContext functionDeclaration() {
return getRuleContext(FunctionDeclarationContext.class,0);
}
public ArrowFunctionDeclarationContext arrowFunctionDeclaration() {
return getRuleContext(ArrowFunctionDeclarationContext.class,0);
}
public GeneratorFunctionDeclarationContext generatorFunctionDeclaration() {
return getRuleContext(GeneratorFunctionDeclarationContext.class,0);
}
public VariableStatementContext variableStatement() {
return getRuleContext(VariableStatementContext.class,0);
}
public TypeAliasDeclarationContext typeAliasDeclaration() {
return getRuleContext(TypeAliasDeclarationContext.class,0);
}
public EnumDeclarationContext enumDeclaration() {
return getRuleContext(EnumDeclarationContext.class,0);
}
public ExpressionStatementContext expressionStatement() {
return getRuleContext(ExpressionStatementContext.class,0);
}
public TerminalNode Export() { return getToken(TypeScriptParser.Export, 0); }
public StatementContext statement() {
return getRuleContext(StatementContext.class,0);
}
public StatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_statement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitStatement(this);
else return visitor.visitChildren(this);
}
}
public final StatementContext statement() throws RecognitionException {
StatementContext _localctx = new StatementContext(_ctx, getState());
enterRule(_localctx, 124, RULE_statement);
try {
setState(918);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,92,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(888);
block();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(889);
importStatement();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(890);
exportStatement();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(891);
emptyStatement_();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(892);
abstractDeclaration();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(893);
decoratorList();
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(894);
classDeclaration();
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(895);
interfaceDeclaration();
}
break;
case 9:
enterOuterAlt(_localctx, 9);
{
setState(896);
namespaceDeclaration();
}
break;
case 10:
enterOuterAlt(_localctx, 10);
{
setState(897);
ifStatement();
}
break;
case 11:
enterOuterAlt(_localctx, 11);
{
setState(898);
iterationStatement();
}
break;
case 12:
enterOuterAlt(_localctx, 12);
{
setState(899);
continueStatement();
}
break;
case 13:
enterOuterAlt(_localctx, 13);
{
setState(900);
breakStatement();
}
break;
case 14:
enterOuterAlt(_localctx, 14);
{
setState(901);
returnStatement();
}
break;
case 15:
enterOuterAlt(_localctx, 15);
{
setState(902);
yieldStatement();
}
break;
case 16:
enterOuterAlt(_localctx, 16);
{
setState(903);
withStatement();
}
break;
case 17:
enterOuterAlt(_localctx, 17);
{
setState(904);
labelledStatement();
}
break;
case 18:
enterOuterAlt(_localctx, 18);
{
setState(905);
switchStatement();
}
break;
case 19:
enterOuterAlt(_localctx, 19);
{
setState(906);
throwStatement();
}
break;
case 20:
enterOuterAlt(_localctx, 20);
{
setState(907);
tryStatement();
}
break;
case 21:
enterOuterAlt(_localctx, 21);
{
setState(908);
debuggerStatement();
}
break;
case 22:
enterOuterAlt(_localctx, 22);
{
setState(909);
functionDeclaration();
}
break;
case 23:
enterOuterAlt(_localctx, 23);
{
setState(910);
arrowFunctionDeclaration();
}
break;
case 24:
enterOuterAlt(_localctx, 24);
{
setState(911);
generatorFunctionDeclaration();
}
break;
case 25:
enterOuterAlt(_localctx, 25);
{
setState(912);
variableStatement();
}
break;
case 26:
enterOuterAlt(_localctx, 26);
{
setState(913);
typeAliasDeclaration();
}
break;
case 27:
enterOuterAlt(_localctx, 27);
{
setState(914);
enumDeclaration();
}
break;
case 28:
enterOuterAlt(_localctx, 28);
{
setState(915);
expressionStatement();
}
break;
case 29:
enterOuterAlt(_localctx, 29);
{
setState(916);
match(Export);
setState(917);
statement();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BlockContext extends ParserRuleContext {
public TerminalNode OpenBrace() { return getToken(TypeScriptParser.OpenBrace, 0); }
public TerminalNode CloseBrace() { return getToken(TypeScriptParser.CloseBrace, 0); }
public StatementListContext statementList() {
return getRuleContext(StatementListContext.class,0);
}
public BlockContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_block; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterBlock(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitBlock(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitBlock(this);
else return visitor.visitChildren(this);
}
}
public final BlockContext block() throws RecognitionException {
BlockContext _localctx = new BlockContext(_ctx, getState());
enterRule(_localctx, 126, RULE_block);
try {
enterOuterAlt(_localctx, 1);
{
setState(920);
match(OpenBrace);
setState(922);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,93,_ctx) ) {
case 1:
{
setState(921);
statementList();
}
break;
}
setState(924);
match(CloseBrace);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StatementListContext extends ParserRuleContext {
public List statement() {
return getRuleContexts(StatementContext.class);
}
public StatementContext statement(int i) {
return getRuleContext(StatementContext.class,i);
}
public StatementListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_statementList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterStatementList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitStatementList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitStatementList(this);
else return visitor.visitChildren(this);
}
}
public final StatementListContext statementList() throws RecognitionException {
StatementListContext _localctx = new StatementListContext(_ctx, getState());
enterRule(_localctx, 128, RULE_statementList);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(927);
_errHandler.sync(this);
_alt = 1;
do {
switch (_alt) {
case 1:
{
{
setState(926);
statement();
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(929);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,94,_ctx);
} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AbstractDeclarationContext extends ParserRuleContext {
public TerminalNode Abstract() { return getToken(TypeScriptParser.Abstract, 0); }
public EosContext eos() {
return getRuleContext(EosContext.class,0);
}
public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); }
public CallSignatureContext callSignature() {
return getRuleContext(CallSignatureContext.class,0);
}
public VariableStatementContext variableStatement() {
return getRuleContext(VariableStatementContext.class,0);
}
public AbstractDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_abstractDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterAbstractDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitAbstractDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitAbstractDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final AbstractDeclarationContext abstractDeclaration() throws RecognitionException {
AbstractDeclarationContext _localctx = new AbstractDeclarationContext(_ctx, getState());
enterRule(_localctx, 130, RULE_abstractDeclaration);
try {
enterOuterAlt(_localctx, 1);
{
setState(931);
match(Abstract);
setState(935);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,95,_ctx) ) {
case 1:
{
setState(932);
match(Identifier);
setState(933);
callSignature();
}
break;
case 2:
{
setState(934);
variableStatement();
}
break;
}
setState(937);
eos();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ImportStatementContext extends ParserRuleContext {
public TerminalNode Import() { return getToken(TypeScriptParser.Import, 0); }
public FromBlockContext fromBlock() {
return getRuleContext(FromBlockContext.class,0);
}
public ImportAliasDeclarationContext importAliasDeclaration() {
return getRuleContext(ImportAliasDeclarationContext.class,0);
}
public ImportAllContext importAll() {
return getRuleContext(ImportAllContext.class,0);
}
public ImportStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_importStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterImportStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitImportStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitImportStatement(this);
else return visitor.visitChildren(this);
}
}
public final ImportStatementContext importStatement() throws RecognitionException {
ImportStatementContext _localctx = new ImportStatementContext(_ctx, getState());
enterRule(_localctx, 132, RULE_importStatement);
try {
enterOuterAlt(_localctx, 1);
{
setState(939);
match(Import);
setState(943);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,96,_ctx) ) {
case 1:
{
setState(940);
fromBlock();
}
break;
case 2:
{
setState(941);
importAliasDeclaration();
}
break;
case 3:
{
setState(942);
importAll();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FromBlockContext extends ParserRuleContext {
public TerminalNode From() { return getToken(TypeScriptParser.From, 0); }
public TerminalNode StringLiteral() { return getToken(TypeScriptParser.StringLiteral, 0); }
public EosContext eos() {
return getRuleContext(EosContext.class,0);
}
public TerminalNode Dollar() { return getToken(TypeScriptParser.Dollar, 0); }
public TerminalNode Lodash() { return getToken(TypeScriptParser.Lodash, 0); }
public ImportNamespaceContext importNamespace() {
return getRuleContext(ImportNamespaceContext.class,0);
}
public ModuleItemsContext moduleItems() {
return getRuleContext(ModuleItemsContext.class,0);
}
public ImportDefaultContext importDefault() {
return getRuleContext(ImportDefaultContext.class,0);
}
public FromBlockContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_fromBlock; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterFromBlock(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitFromBlock(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitFromBlock(this);
else return visitor.visitChildren(this);
}
}
public final FromBlockContext fromBlock() throws RecognitionException {
FromBlockContext _localctx = new FromBlockContext(_ctx, getState());
enterRule(_localctx, 134, RULE_fromBlock);
try {
setState(959);
_errHandler.sync(this);
switch (_input.LA(1)) {
case OpenBrace:
case Multiply:
case Lodash:
case Dollar:
case NullLiteral:
case BooleanLiteral:
case Break:
case Do:
case Instanceof:
case Typeof:
case Keyof:
case Case:
case Else:
case New:
case Var:
case Catch:
case Finally:
case Return:
case Void:
case Continue:
case For:
case Switch:
case While:
case Debugger:
case Function_:
case This:
case With:
case If:
case Throw:
case Delete:
case In:
case Try:
case From:
case ReadOnly:
case Async:
case Class:
case Enum:
case Extends:
case Super:
case Const:
case Export:
case Import:
case Implements:
case Let:
case Private:
case Public:
case Interface:
case Package:
case Protected:
case Static:
case Yield:
case Any:
case Number:
case Boolean:
case String:
case TypeAlias:
case Get:
case Set:
case Namespace:
case Require:
case Module:
case Undefined:
case Is:
case Identifier:
enterOuterAlt(_localctx, 1);
{
setState(946);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,97,_ctx) ) {
case 1:
{
setState(945);
importDefault();
}
break;
}
setState(952);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,98,_ctx) ) {
case 1:
{
setState(948);
match(Dollar);
}
break;
case 2:
{
setState(949);
match(Lodash);
}
break;
case 3:
{
setState(950);
importNamespace();
}
break;
case 4:
{
setState(951);
moduleItems();
}
break;
}
setState(954);
match(From);
setState(955);
match(StringLiteral);
setState(956);
eos();
}
break;
case StringLiteral:
enterOuterAlt(_localctx, 2);
{
setState(957);
match(StringLiteral);
setState(958);
eos();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ModuleItemsContext extends ParserRuleContext {
public TerminalNode OpenBrace() { return getToken(TypeScriptParser.OpenBrace, 0); }
public TerminalNode CloseBrace() { return getToken(TypeScriptParser.CloseBrace, 0); }
public List aliasName() {
return getRuleContexts(AliasNameContext.class);
}
public AliasNameContext aliasName(int i) {
return getRuleContext(AliasNameContext.class,i);
}
public List Comma() { return getTokens(TypeScriptParser.Comma); }
public TerminalNode Comma(int i) {
return getToken(TypeScriptParser.Comma, i);
}
public ModuleItemsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_moduleItems; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterModuleItems(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitModuleItems(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitModuleItems(this);
else return visitor.visitChildren(this);
}
}
public final ModuleItemsContext moduleItems() throws RecognitionException {
ModuleItemsContext _localctx = new ModuleItemsContext(_ctx, getState());
enterRule(_localctx, 136, RULE_moduleItems);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(961);
match(OpenBrace);
setState(967);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,100,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(962);
aliasName();
setState(963);
match(Comma);
}
}
}
setState(969);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,100,_ctx);
}
setState(974);
_errHandler.sync(this);
_la = _input.LA(1);
if (((((_la - 59)) & ~0x3f) == 0 && ((1L << (_la - 59)) & ((1L << (Lodash - 59)) | (1L << (Dollar - 59)) | (1L << (NullLiteral - 59)) | (1L << (BooleanLiteral - 59)) | (1L << (Break - 59)) | (1L << (Do - 59)) | (1L << (Instanceof - 59)) | (1L << (Typeof - 59)) | (1L << (Keyof - 59)) | (1L << (Case - 59)) | (1L << (Else - 59)) | (1L << (New - 59)) | (1L << (Var - 59)) | (1L << (Catch - 59)) | (1L << (Finally - 59)) | (1L << (Return - 59)) | (1L << (Void - 59)) | (1L << (Continue - 59)) | (1L << (For - 59)) | (1L << (Switch - 59)) | (1L << (While - 59)) | (1L << (Debugger - 59)) | (1L << (Function_ - 59)) | (1L << (This - 59)) | (1L << (With - 59)) | (1L << (If - 59)) | (1L << (Throw - 59)) | (1L << (Delete - 59)) | (1L << (In - 59)) | (1L << (Try - 59)) | (1L << (From - 59)) | (1L << (ReadOnly - 59)) | (1L << (Async - 59)) | (1L << (Class - 59)) | (1L << (Enum - 59)) | (1L << (Extends - 59)) | (1L << (Super - 59)) | (1L << (Const - 59)) | (1L << (Export - 59)) | (1L << (Import - 59)) | (1L << (Implements - 59)) | (1L << (Let - 59)) | (1L << (Private - 59)) | (1L << (Public - 59)) | (1L << (Interface - 59)) | (1L << (Package - 59)) | (1L << (Protected - 59)) | (1L << (Static - 59)) | (1L << (Yield - 59)) | (1L << (Any - 59)) | (1L << (Number - 59)) | (1L << (Boolean - 59)) | (1L << (String - 59)) | (1L << (TypeAlias - 59)))) != 0) || ((((_la - 123)) & ~0x3f) == 0 && ((1L << (_la - 123)) & ((1L << (Get - 123)) | (1L << (Set - 123)) | (1L << (Namespace - 123)) | (1L << (Require - 123)) | (1L << (Module - 123)) | (1L << (Undefined - 123)) | (1L << (Is - 123)) | (1L << (Identifier - 123)))) != 0)) {
{
setState(970);
aliasName();
setState(972);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Comma) {
{
setState(971);
match(Comma);
}
}
}
}
setState(976);
match(CloseBrace);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ImportDefaultContext extends ParserRuleContext {
public AliasNameContext aliasName() {
return getRuleContext(AliasNameContext.class,0);
}
public TerminalNode Comma() { return getToken(TypeScriptParser.Comma, 0); }
public ImportDefaultContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_importDefault; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterImportDefault(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitImportDefault(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitImportDefault(this);
else return visitor.visitChildren(this);
}
}
public final ImportDefaultContext importDefault() throws RecognitionException {
ImportDefaultContext _localctx = new ImportDefaultContext(_ctx, getState());
enterRule(_localctx, 138, RULE_importDefault);
try {
enterOuterAlt(_localctx, 1);
{
setState(978);
aliasName();
setState(979);
match(Comma);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AliasNameContext extends ParserRuleContext {
public List identifierName() {
return getRuleContexts(IdentifierNameContext.class);
}
public IdentifierNameContext identifierName(int i) {
return getRuleContext(IdentifierNameContext.class,i);
}
public TerminalNode As() { return getToken(TypeScriptParser.As, 0); }
public AliasNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_aliasName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterAliasName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitAliasName(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitAliasName(this);
else return visitor.visitChildren(this);
}
}
public final AliasNameContext aliasName() throws RecognitionException {
AliasNameContext _localctx = new AliasNameContext(_ctx, getState());
enterRule(_localctx, 140, RULE_aliasName);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(981);
identifierName();
setState(984);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==As) {
{
setState(982);
match(As);
setState(983);
identifierName();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ImportNamespaceContext extends ParserRuleContext {
public TerminalNode Multiply() { return getToken(TypeScriptParser.Multiply, 0); }
public List identifierName() {
return getRuleContexts(IdentifierNameContext.class);
}
public IdentifierNameContext identifierName(int i) {
return getRuleContext(IdentifierNameContext.class,i);
}
public TerminalNode As() { return getToken(TypeScriptParser.As, 0); }
public ImportNamespaceContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_importNamespace; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterImportNamespace(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitImportNamespace(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitImportNamespace(this);
else return visitor.visitChildren(this);
}
}
public final ImportNamespaceContext importNamespace() throws RecognitionException {
ImportNamespaceContext _localctx = new ImportNamespaceContext(_ctx, getState());
enterRule(_localctx, 142, RULE_importNamespace);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(988);
_errHandler.sync(this);
switch (_input.LA(1)) {
case Multiply:
{
setState(986);
match(Multiply);
}
break;
case Lodash:
case Dollar:
case NullLiteral:
case BooleanLiteral:
case Break:
case Do:
case Instanceof:
case Typeof:
case Keyof:
case Case:
case Else:
case New:
case Var:
case Catch:
case Finally:
case Return:
case Void:
case Continue:
case For:
case Switch:
case While:
case Debugger:
case Function_:
case This:
case With:
case If:
case Throw:
case Delete:
case In:
case Try:
case From:
case ReadOnly:
case Async:
case Class:
case Enum:
case Extends:
case Super:
case Const:
case Export:
case Import:
case Implements:
case Let:
case Private:
case Public:
case Interface:
case Package:
case Protected:
case Static:
case Yield:
case Any:
case Number:
case Boolean:
case String:
case TypeAlias:
case Get:
case Set:
case Namespace:
case Require:
case Module:
case Undefined:
case Is:
case Identifier:
{
setState(987);
identifierName();
}
break;
default:
throw new NoViableAltException(this);
}
setState(992);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==As) {
{
setState(990);
match(As);
setState(991);
identifierName();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExportStatementContext extends ParserRuleContext {
public ExportStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_exportStatement; }
public ExportStatementContext() { }
public void copyFrom(ExportStatementContext ctx) {
super.copyFrom(ctx);
}
}
public static class ExportDefaultDeclarationContext extends ExportStatementContext {
public TerminalNode Export() { return getToken(TypeScriptParser.Export, 0); }
public TerminalNode Default() { return getToken(TypeScriptParser.Default, 0); }
public SingleExpressionContext singleExpression() {
return getRuleContext(SingleExpressionContext.class,0);
}
public EosContext eos() {
return getRuleContext(EosContext.class,0);
}
public ExportDefaultDeclarationContext(ExportStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterExportDefaultDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitExportDefaultDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitExportDefaultDeclaration(this);
else return visitor.visitChildren(this);
}
}
public static class ExportDeclarationContext extends ExportStatementContext {
public TerminalNode Export() { return getToken(TypeScriptParser.Export, 0); }
public EosContext eos() {
return getRuleContext(EosContext.class,0);
}
public ExportFromBlockContext exportFromBlock() {
return getRuleContext(ExportFromBlockContext.class,0);
}
public DeclarationContext declaration() {
return getRuleContext(DeclarationContext.class,0);
}
public ExportDeclarationContext(ExportStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterExportDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitExportDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitExportDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final ExportStatementContext exportStatement() throws RecognitionException {
ExportStatementContext _localctx = new ExportStatementContext(_ctx, getState());
enterRule(_localctx, 144, RULE_exportStatement);
try {
setState(1006);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,107,_ctx) ) {
case 1:
_localctx = new ExportDeclarationContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(994);
match(Export);
setState(997);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,106,_ctx) ) {
case 1:
{
setState(995);
exportFromBlock();
}
break;
case 2:
{
setState(996);
declaration();
}
break;
}
setState(999);
eos();
}
break;
case 2:
_localctx = new ExportDefaultDeclarationContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(1001);
match(Export);
setState(1002);
match(Default);
setState(1003);
singleExpression(0);
setState(1004);
eos();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ImportFromContext extends ParserRuleContext {
public TerminalNode From() { return getToken(TypeScriptParser.From, 0); }
public TerminalNode StringLiteral() { return getToken(TypeScriptParser.StringLiteral, 0); }
public ImportFromContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_importFrom; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterImportFrom(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitImportFrom(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitImportFrom(this);
else return visitor.visitChildren(this);
}
}
public final ImportFromContext importFrom() throws RecognitionException {
ImportFromContext _localctx = new ImportFromContext(_ctx, getState());
enterRule(_localctx, 146, RULE_importFrom);
try {
enterOuterAlt(_localctx, 1);
{
setState(1008);
match(From);
setState(1009);
match(StringLiteral);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExportFromBlockContext extends ParserRuleContext {
public ImportNamespaceContext importNamespace() {
return getRuleContext(ImportNamespaceContext.class,0);
}
public ImportFromContext importFrom() {
return getRuleContext(ImportFromContext.class,0);
}
public EosContext eos() {
return getRuleContext(EosContext.class,0);
}
public ModuleItemsContext moduleItems() {
return getRuleContext(ModuleItemsContext.class,0);
}
public ExportFromBlockContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_exportFromBlock; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterExportFromBlock(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitExportFromBlock(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitExportFromBlock(this);
else return visitor.visitChildren(this);
}
}
public final ExportFromBlockContext exportFromBlock() throws RecognitionException {
ExportFromBlockContext _localctx = new ExportFromBlockContext(_ctx, getState());
enterRule(_localctx, 148, RULE_exportFromBlock);
try {
setState(1021);
_errHandler.sync(this);
switch (_input.LA(1)) {
case Multiply:
case Lodash:
case Dollar:
case NullLiteral:
case BooleanLiteral:
case Break:
case Do:
case Instanceof:
case Typeof:
case Keyof:
case Case:
case Else:
case New:
case Var:
case Catch:
case Finally:
case Return:
case Void:
case Continue:
case For:
case Switch:
case While:
case Debugger:
case Function_:
case This:
case With:
case If:
case Throw:
case Delete:
case In:
case Try:
case From:
case ReadOnly:
case Async:
case Class:
case Enum:
case Extends:
case Super:
case Const:
case Export:
case Import:
case Implements:
case Let:
case Private:
case Public:
case Interface:
case Package:
case Protected:
case Static:
case Yield:
case Any:
case Number:
case Boolean:
case String:
case TypeAlias:
case Get:
case Set:
case Namespace:
case Require:
case Module:
case Undefined:
case Is:
case Identifier:
enterOuterAlt(_localctx, 1);
{
setState(1011);
importNamespace();
setState(1012);
importFrom();
setState(1013);
eos();
}
break;
case OpenBrace:
enterOuterAlt(_localctx, 2);
{
setState(1015);
moduleItems();
setState(1017);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,108,_ctx) ) {
case 1:
{
setState(1016);
importFrom();
}
break;
}
setState(1019);
eos();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DeclarationContext extends ParserRuleContext {
public VariableStatementContext variableStatement() {
return getRuleContext(VariableStatementContext.class,0);
}
public ClassDeclarationContext classDeclaration() {
return getRuleContext(ClassDeclarationContext.class,0);
}
public FunctionDeclarationContext functionDeclaration() {
return getRuleContext(FunctionDeclarationContext.class,0);
}
public DeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_declaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final DeclarationContext declaration() throws RecognitionException {
DeclarationContext _localctx = new DeclarationContext(_ctx, getState());
enterRule(_localctx, 150, RULE_declaration);
try {
setState(1026);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,110,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1023);
variableStatement();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1024);
classDeclaration();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1025);
functionDeclaration();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class VariableStatementContext extends ParserRuleContext {
public BindingPatternContext bindingPattern() {
return getRuleContext(BindingPatternContext.class,0);
}
public InitializerContext initializer() {
return getRuleContext(InitializerContext.class,0);
}
public TypeAnnotationContext typeAnnotation() {
return getRuleContext(TypeAnnotationContext.class,0);
}
public TerminalNode SemiColon() { return getToken(TypeScriptParser.SemiColon, 0); }
public VariableDeclarationListContext variableDeclarationList() {
return getRuleContext(VariableDeclarationListContext.class,0);
}
public AccessibilityModifierContext accessibilityModifier() {
return getRuleContext(AccessibilityModifierContext.class,0);
}
public VarModifierContext varModifier() {
return getRuleContext(VarModifierContext.class,0);
}
public TerminalNode ReadOnly() { return getToken(TypeScriptParser.ReadOnly, 0); }
public TerminalNode Declare() { return getToken(TypeScriptParser.Declare, 0); }
public VariableStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_variableStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterVariableStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitVariableStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitVariableStatement(this);
else return visitor.visitChildren(this);
}
}
public final VariableStatementContext variableStatement() throws RecognitionException {
VariableStatementContext _localctx = new VariableStatementContext(_ctx, getState());
enterRule(_localctx, 152, RULE_variableStatement);
int _la;
try {
setState(1057);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,119,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1028);
bindingPattern();
setState(1030);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Colon) {
{
setState(1029);
typeAnnotation();
}
}
setState(1032);
initializer();
setState(1034);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,112,_ctx) ) {
case 1:
{
setState(1033);
match(SemiColon);
}
break;
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1037);
_errHandler.sync(this);
_la = _input.LA(1);
if (((((_la - 110)) & ~0x3f) == 0 && ((1L << (_la - 110)) & ((1L << (Private - 110)) | (1L << (Public - 110)) | (1L << (Protected - 110)))) != 0)) {
{
setState(1036);
accessibilityModifier();
}
}
setState(1040);
_errHandler.sync(this);
_la = _input.LA(1);
if (((((_la - 76)) & ~0x3f) == 0 && ((1L << (_la - 76)) & ((1L << (Var - 76)) | (1L << (Const - 76)) | (1L << (Let - 76)))) != 0)) {
{
setState(1039);
varModifier();
}
}
setState(1043);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ReadOnly) {
{
setState(1042);
match(ReadOnly);
}
}
setState(1045);
variableDeclarationList();
setState(1047);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,116,_ctx) ) {
case 1:
{
setState(1046);
match(SemiColon);
}
break;
}
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1049);
match(Declare);
setState(1051);
_errHandler.sync(this);
_la = _input.LA(1);
if (((((_la - 76)) & ~0x3f) == 0 && ((1L << (_la - 76)) & ((1L << (Var - 76)) | (1L << (Const - 76)) | (1L << (Let - 76)))) != 0)) {
{
setState(1050);
varModifier();
}
}
setState(1053);
variableDeclarationList();
setState(1055);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,118,_ctx) ) {
case 1:
{
setState(1054);
match(SemiColon);
}
break;
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class VariableDeclarationListContext extends ParserRuleContext {
public List variableDeclaration() {
return getRuleContexts(VariableDeclarationContext.class);
}
public VariableDeclarationContext variableDeclaration(int i) {
return getRuleContext(VariableDeclarationContext.class,i);
}
public List Comma() { return getTokens(TypeScriptParser.Comma); }
public TerminalNode Comma(int i) {
return getToken(TypeScriptParser.Comma, i);
}
public VariableDeclarationListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_variableDeclarationList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterVariableDeclarationList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitVariableDeclarationList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitVariableDeclarationList(this);
else return visitor.visitChildren(this);
}
}
public final VariableDeclarationListContext variableDeclarationList() throws RecognitionException {
VariableDeclarationListContext _localctx = new VariableDeclarationListContext(_ctx, getState());
enterRule(_localctx, 154, RULE_variableDeclarationList);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1059);
variableDeclaration();
setState(1064);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,120,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1060);
match(Comma);
setState(1061);
variableDeclaration();
}
}
}
setState(1066);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,120,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class VariableDeclarationContext extends ParserRuleContext {
public IdentifierOrKeyWordContext identifierOrKeyWord() {
return getRuleContext(IdentifierOrKeyWordContext.class,0);
}
public ArrayLiteralContext arrayLiteral() {
return getRuleContext(ArrayLiteralContext.class,0);
}
public ObjectLiteralContext objectLiteral() {
return getRuleContext(ObjectLiteralContext.class,0);
}
public TypeAnnotationContext typeAnnotation() {
return getRuleContext(TypeAnnotationContext.class,0);
}
public List singleExpression() {
return getRuleContexts(SingleExpressionContext.class);
}
public SingleExpressionContext singleExpression(int i) {
return getRuleContext(SingleExpressionContext.class,i);
}
public TerminalNode Assign() { return getToken(TypeScriptParser.Assign, 0); }
public TypeParametersContext typeParameters() {
return getRuleContext(TypeParametersContext.class,0);
}
public VariableDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_variableDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterVariableDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitVariableDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitVariableDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final VariableDeclarationContext variableDeclaration() throws RecognitionException {
VariableDeclarationContext _localctx = new VariableDeclarationContext(_ctx, getState());
enterRule(_localctx, 156, RULE_variableDeclaration);
try {
enterOuterAlt(_localctx, 1);
{
setState(1070);
_errHandler.sync(this);
switch (_input.LA(1)) {
case Lodash:
case Any:
case TypeAlias:
case Require:
case Module:
case Identifier:
{
setState(1067);
identifierOrKeyWord();
}
break;
case OpenBracket:
{
setState(1068);
arrayLiteral();
}
break;
case OpenBrace:
{
setState(1069);
objectLiteral();
}
break;
default:
throw new NoViableAltException(this);
}
setState(1073);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,122,_ctx) ) {
case 1:
{
setState(1072);
typeAnnotation();
}
break;
}
setState(1076);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,123,_ctx) ) {
case 1:
{
setState(1075);
singleExpression(0);
}
break;
}
setState(1083);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,125,_ctx) ) {
case 1:
{
setState(1078);
match(Assign);
setState(1080);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,124,_ctx) ) {
case 1:
{
setState(1079);
typeParameters();
}
break;
}
setState(1082);
singleExpression(0);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EmptyStatement_Context extends ParserRuleContext {
public TerminalNode SemiColon() { return getToken(TypeScriptParser.SemiColon, 0); }
public EmptyStatement_Context(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_emptyStatement_; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterEmptyStatement_(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitEmptyStatement_(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitEmptyStatement_(this);
else return visitor.visitChildren(this);
}
}
public final EmptyStatement_Context emptyStatement_() throws RecognitionException {
EmptyStatement_Context _localctx = new EmptyStatement_Context(_ctx, getState());
enterRule(_localctx, 158, RULE_emptyStatement_);
try {
enterOuterAlt(_localctx, 1);
{
setState(1085);
match(SemiColon);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExpressionStatementContext extends ParserRuleContext {
public ExpressionSequenceContext expressionSequence() {
return getRuleContext(ExpressionSequenceContext.class,0);
}
public TerminalNode SemiColon() { return getToken(TypeScriptParser.SemiColon, 0); }
public ExpressionStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expressionStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterExpressionStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitExpressionStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitExpressionStatement(this);
else return visitor.visitChildren(this);
}
}
public final ExpressionStatementContext expressionStatement() throws RecognitionException {
ExpressionStatementContext _localctx = new ExpressionStatementContext(_ctx, getState());
enterRule(_localctx, 160, RULE_expressionStatement);
try {
enterOuterAlt(_localctx, 1);
{
setState(1087);
if (!(this.notOpenBraceAndNotFunction())) throw new FailedPredicateException(this, "this.notOpenBraceAndNotFunction()");
setState(1088);
expressionSequence();
setState(1090);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,126,_ctx) ) {
case 1:
{
setState(1089);
match(SemiColon);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class IfStatementContext extends ParserRuleContext {
public TerminalNode If() { return getToken(TypeScriptParser.If, 0); }
public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); }
public ExpressionSequenceContext expressionSequence() {
return getRuleContext(ExpressionSequenceContext.class,0);
}
public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); }
public List statement() {
return getRuleContexts(StatementContext.class);
}
public StatementContext statement(int i) {
return getRuleContext(StatementContext.class,i);
}
public TerminalNode Else() { return getToken(TypeScriptParser.Else, 0); }
public IfStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_ifStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterIfStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitIfStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitIfStatement(this);
else return visitor.visitChildren(this);
}
}
public final IfStatementContext ifStatement() throws RecognitionException {
IfStatementContext _localctx = new IfStatementContext(_ctx, getState());
enterRule(_localctx, 162, RULE_ifStatement);
try {
enterOuterAlt(_localctx, 1);
{
setState(1092);
match(If);
setState(1093);
match(OpenParen);
setState(1094);
expressionSequence();
setState(1095);
match(CloseParen);
setState(1096);
statement();
setState(1099);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,127,_ctx) ) {
case 1:
{
setState(1097);
match(Else);
setState(1098);
statement();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class IterationStatementContext extends ParserRuleContext {
public IterationStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_iterationStatement; }
public IterationStatementContext() { }
public void copyFrom(IterationStatementContext ctx) {
super.copyFrom(ctx);
}
}
public static class DoStatementContext extends IterationStatementContext {
public TerminalNode Do() { return getToken(TypeScriptParser.Do, 0); }
public StatementContext statement() {
return getRuleContext(StatementContext.class,0);
}
public TerminalNode While() { return getToken(TypeScriptParser.While, 0); }
public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); }
public ExpressionSequenceContext expressionSequence() {
return getRuleContext(ExpressionSequenceContext.class,0);
}
public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); }
public EosContext eos() {
return getRuleContext(EosContext.class,0);
}
public DoStatementContext(IterationStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterDoStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitDoStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitDoStatement(this);
else return visitor.visitChildren(this);
}
}
public static class ForVarStatementContext extends IterationStatementContext {
public TerminalNode For() { return getToken(TypeScriptParser.For, 0); }
public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); }
public VarModifierContext varModifier() {
return getRuleContext(VarModifierContext.class,0);
}
public VariableDeclarationListContext variableDeclarationList() {
return getRuleContext(VariableDeclarationListContext.class,0);
}
public List SemiColon() { return getTokens(TypeScriptParser.SemiColon); }
public TerminalNode SemiColon(int i) {
return getToken(TypeScriptParser.SemiColon, i);
}
public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); }
public StatementContext statement() {
return getRuleContext(StatementContext.class,0);
}
public List expressionSequence() {
return getRuleContexts(ExpressionSequenceContext.class);
}
public ExpressionSequenceContext expressionSequence(int i) {
return getRuleContext(ExpressionSequenceContext.class,i);
}
public ForVarStatementContext(IterationStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterForVarStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitForVarStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitForVarStatement(this);
else return visitor.visitChildren(this);
}
}
public static class ForVarInStatementContext extends IterationStatementContext {
public TerminalNode For() { return getToken(TypeScriptParser.For, 0); }
public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); }
public VarModifierContext varModifier() {
return getRuleContext(VarModifierContext.class,0);
}
public VariableDeclarationContext variableDeclaration() {
return getRuleContext(VariableDeclarationContext.class,0);
}
public ExpressionSequenceContext expressionSequence() {
return getRuleContext(ExpressionSequenceContext.class,0);
}
public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); }
public StatementContext statement() {
return getRuleContext(StatementContext.class,0);
}
public TerminalNode In() { return getToken(TypeScriptParser.In, 0); }
public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); }
public ForVarInStatementContext(IterationStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterForVarInStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitForVarInStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitForVarInStatement(this);
else return visitor.visitChildren(this);
}
}
public static class WhileStatementContext extends IterationStatementContext {
public TerminalNode While() { return getToken(TypeScriptParser.While, 0); }
public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); }
public ExpressionSequenceContext expressionSequence() {
return getRuleContext(ExpressionSequenceContext.class,0);
}
public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); }
public StatementContext statement() {
return getRuleContext(StatementContext.class,0);
}
public WhileStatementContext(IterationStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterWhileStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitWhileStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitWhileStatement(this);
else return visitor.visitChildren(this);
}
}
public static class ForStatementContext extends IterationStatementContext {
public TerminalNode For() { return getToken(TypeScriptParser.For, 0); }
public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); }
public List SemiColon() { return getTokens(TypeScriptParser.SemiColon); }
public TerminalNode SemiColon(int i) {
return getToken(TypeScriptParser.SemiColon, i);
}
public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); }
public StatementContext statement() {
return getRuleContext(StatementContext.class,0);
}
public List expressionSequence() {
return getRuleContexts(ExpressionSequenceContext.class);
}
public ExpressionSequenceContext expressionSequence(int i) {
return getRuleContext(ExpressionSequenceContext.class,i);
}
public ForStatementContext(IterationStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterForStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitForStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitForStatement(this);
else return visitor.visitChildren(this);
}
}
public static class ForInStatementContext extends IterationStatementContext {
public TerminalNode For() { return getToken(TypeScriptParser.For, 0); }
public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); }
public SingleExpressionContext singleExpression() {
return getRuleContext(SingleExpressionContext.class,0);
}
public ExpressionSequenceContext expressionSequence() {
return getRuleContext(ExpressionSequenceContext.class,0);
}
public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); }
public StatementContext statement() {
return getRuleContext(StatementContext.class,0);
}
public TerminalNode In() { return getToken(TypeScriptParser.In, 0); }
public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); }
public ForInStatementContext(IterationStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterForInStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitForInStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitForInStatement(this);
else return visitor.visitChildren(this);
}
}
public static class ForOfStatementContext extends IterationStatementContext {
public TerminalNode For() { return getToken(TypeScriptParser.For, 0); }
public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); }
public TerminalNode Of() { return getToken(TypeScriptParser.Of, 0); }
public ExpressionSequenceContext expressionSequence() {
return getRuleContext(ExpressionSequenceContext.class,0);
}
public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); }
public StatementContext statement() {
return getRuleContext(StatementContext.class,0);
}
public SingleExpressionContext singleExpression() {
return getRuleContext(SingleExpressionContext.class,0);
}
public VariableDeclarationListContext variableDeclarationList() {
return getRuleContext(VariableDeclarationListContext.class,0);
}
public TerminalNode Await() { return getToken(TypeScriptParser.Await, 0); }
public ForOfStatementContext(IterationStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterForOfStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitForOfStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitForOfStatement(this);
else return visitor.visitChildren(this);
}
}
public final IterationStatementContext iterationStatement() throws RecognitionException {
IterationStatementContext _localctx = new IterationStatementContext(_ctx, getState());
enterRule(_localctx, 164, RULE_iterationStatement);
int _la;
try {
setState(1184);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,137,_ctx) ) {
case 1:
_localctx = new DoStatementContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(1101);
match(Do);
setState(1102);
statement();
setState(1103);
match(While);
setState(1104);
match(OpenParen);
setState(1105);
expressionSequence();
setState(1106);
match(CloseParen);
setState(1107);
eos();
}
break;
case 2:
_localctx = new WhileStatementContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(1109);
match(While);
setState(1110);
match(OpenParen);
setState(1111);
expressionSequence();
setState(1112);
match(CloseParen);
setState(1113);
statement();
}
break;
case 3:
_localctx = new ForStatementContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(1115);
match(For);
setState(1116);
match(OpenParen);
setState(1118);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << RegularExpressionLiteral) | (1L << OpenBracket) | (1L << OpenParen) | (1L << OpenBrace) | (1L << PlusPlus) | (1L << MinusMinus) | (1L << Plus) | (1L << Minus) | (1L << BitNot) | (1L << Not) | (1L << LessThan) | (1L << Lodash) | (1L << Dollar) | (1L << NullLiteral) | (1L << BooleanLiteral) | (1L << DecimalLiteral))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (HexIntegerLiteral - 64)) | (1L << (OctalIntegerLiteral - 64)) | (1L << (OctalIntegerLiteral2 - 64)) | (1L << (BinaryIntegerLiteral - 64)) | (1L << (Break - 64)) | (1L << (Do - 64)) | (1L << (Instanceof - 64)) | (1L << (Typeof - 64)) | (1L << (Keyof - 64)) | (1L << (Case - 64)) | (1L << (Else - 64)) | (1L << (New - 64)) | (1L << (Var - 64)) | (1L << (Catch - 64)) | (1L << (Finally - 64)) | (1L << (Return - 64)) | (1L << (Void - 64)) | (1L << (Continue - 64)) | (1L << (For - 64)) | (1L << (Switch - 64)) | (1L << (While - 64)) | (1L << (Debugger - 64)) | (1L << (Function_ - 64)) | (1L << (This - 64)) | (1L << (With - 64)) | (1L << (If - 64)) | (1L << (Throw - 64)) | (1L << (Delete - 64)) | (1L << (In - 64)) | (1L << (Try - 64)) | (1L << (From - 64)) | (1L << (ReadOnly - 64)) | (1L << (Async - 64)) | (1L << (Await - 64)) | (1L << (Class - 64)) | (1L << (Enum - 64)) | (1L << (Extends - 64)) | (1L << (Super - 64)) | (1L << (Const - 64)) | (1L << (Export - 64)) | (1L << (Import - 64)) | (1L << (Implements - 64)) | (1L << (Let - 64)) | (1L << (Private - 64)) | (1L << (Public - 64)) | (1L << (Interface - 64)) | (1L << (Package - 64)) | (1L << (Protected - 64)) | (1L << (Static - 64)) | (1L << (Yield - 64)) | (1L << (Any - 64)) | (1L << (Number - 64)) | (1L << (Boolean - 64)) | (1L << (String - 64)) | (1L << (TypeAlias - 64)) | (1L << (Get - 64)) | (1L << (Set - 64)) | (1L << (Namespace - 64)) | (1L << (Require - 64)))) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & ((1L << (Module - 128)) | (1L << (Undefined - 128)) | (1L << (Is - 128)) | (1L << (Identifier - 128)) | (1L << (StringLiteral - 128)) | (1L << (BackTick - 128)))) != 0)) {
{
setState(1117);
expressionSequence();
}
}
setState(1120);
match(SemiColon);
setState(1122);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << RegularExpressionLiteral) | (1L << OpenBracket) | (1L << OpenParen) | (1L << OpenBrace) | (1L << PlusPlus) | (1L << MinusMinus) | (1L << Plus) | (1L << Minus) | (1L << BitNot) | (1L << Not) | (1L << LessThan) | (1L << Lodash) | (1L << Dollar) | (1L << NullLiteral) | (1L << BooleanLiteral) | (1L << DecimalLiteral))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (HexIntegerLiteral - 64)) | (1L << (OctalIntegerLiteral - 64)) | (1L << (OctalIntegerLiteral2 - 64)) | (1L << (BinaryIntegerLiteral - 64)) | (1L << (Break - 64)) | (1L << (Do - 64)) | (1L << (Instanceof - 64)) | (1L << (Typeof - 64)) | (1L << (Keyof - 64)) | (1L << (Case - 64)) | (1L << (Else - 64)) | (1L << (New - 64)) | (1L << (Var - 64)) | (1L << (Catch - 64)) | (1L << (Finally - 64)) | (1L << (Return - 64)) | (1L << (Void - 64)) | (1L << (Continue - 64)) | (1L << (For - 64)) | (1L << (Switch - 64)) | (1L << (While - 64)) | (1L << (Debugger - 64)) | (1L << (Function_ - 64)) | (1L << (This - 64)) | (1L << (With - 64)) | (1L << (If - 64)) | (1L << (Throw - 64)) | (1L << (Delete - 64)) | (1L << (In - 64)) | (1L << (Try - 64)) | (1L << (From - 64)) | (1L << (ReadOnly - 64)) | (1L << (Async - 64)) | (1L << (Await - 64)) | (1L << (Class - 64)) | (1L << (Enum - 64)) | (1L << (Extends - 64)) | (1L << (Super - 64)) | (1L << (Const - 64)) | (1L << (Export - 64)) | (1L << (Import - 64)) | (1L << (Implements - 64)) | (1L << (Let - 64)) | (1L << (Private - 64)) | (1L << (Public - 64)) | (1L << (Interface - 64)) | (1L << (Package - 64)) | (1L << (Protected - 64)) | (1L << (Static - 64)) | (1L << (Yield - 64)) | (1L << (Any - 64)) | (1L << (Number - 64)) | (1L << (Boolean - 64)) | (1L << (String - 64)) | (1L << (TypeAlias - 64)) | (1L << (Get - 64)) | (1L << (Set - 64)) | (1L << (Namespace - 64)) | (1L << (Require - 64)))) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & ((1L << (Module - 128)) | (1L << (Undefined - 128)) | (1L << (Is - 128)) | (1L << (Identifier - 128)) | (1L << (StringLiteral - 128)) | (1L << (BackTick - 128)))) != 0)) {
{
setState(1121);
expressionSequence();
}
}
setState(1124);
match(SemiColon);
setState(1126);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << RegularExpressionLiteral) | (1L << OpenBracket) | (1L << OpenParen) | (1L << OpenBrace) | (1L << PlusPlus) | (1L << MinusMinus) | (1L << Plus) | (1L << Minus) | (1L << BitNot) | (1L << Not) | (1L << LessThan) | (1L << Lodash) | (1L << Dollar) | (1L << NullLiteral) | (1L << BooleanLiteral) | (1L << DecimalLiteral))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (HexIntegerLiteral - 64)) | (1L << (OctalIntegerLiteral - 64)) | (1L << (OctalIntegerLiteral2 - 64)) | (1L << (BinaryIntegerLiteral - 64)) | (1L << (Break - 64)) | (1L << (Do - 64)) | (1L << (Instanceof - 64)) | (1L << (Typeof - 64)) | (1L << (Keyof - 64)) | (1L << (Case - 64)) | (1L << (Else - 64)) | (1L << (New - 64)) | (1L << (Var - 64)) | (1L << (Catch - 64)) | (1L << (Finally - 64)) | (1L << (Return - 64)) | (1L << (Void - 64)) | (1L << (Continue - 64)) | (1L << (For - 64)) | (1L << (Switch - 64)) | (1L << (While - 64)) | (1L << (Debugger - 64)) | (1L << (Function_ - 64)) | (1L << (This - 64)) | (1L << (With - 64)) | (1L << (If - 64)) | (1L << (Throw - 64)) | (1L << (Delete - 64)) | (1L << (In - 64)) | (1L << (Try - 64)) | (1L << (From - 64)) | (1L << (ReadOnly - 64)) | (1L << (Async - 64)) | (1L << (Await - 64)) | (1L << (Class - 64)) | (1L << (Enum - 64)) | (1L << (Extends - 64)) | (1L << (Super - 64)) | (1L << (Const - 64)) | (1L << (Export - 64)) | (1L << (Import - 64)) | (1L << (Implements - 64)) | (1L << (Let - 64)) | (1L << (Private - 64)) | (1L << (Public - 64)) | (1L << (Interface - 64)) | (1L << (Package - 64)) | (1L << (Protected - 64)) | (1L << (Static - 64)) | (1L << (Yield - 64)) | (1L << (Any - 64)) | (1L << (Number - 64)) | (1L << (Boolean - 64)) | (1L << (String - 64)) | (1L << (TypeAlias - 64)) | (1L << (Get - 64)) | (1L << (Set - 64)) | (1L << (Namespace - 64)) | (1L << (Require - 64)))) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & ((1L << (Module - 128)) | (1L << (Undefined - 128)) | (1L << (Is - 128)) | (1L << (Identifier - 128)) | (1L << (StringLiteral - 128)) | (1L << (BackTick - 128)))) != 0)) {
{
setState(1125);
expressionSequence();
}
}
setState(1128);
match(CloseParen);
setState(1129);
statement();
}
break;
case 4:
_localctx = new ForVarStatementContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(1130);
match(For);
setState(1131);
match(OpenParen);
setState(1132);
varModifier();
setState(1133);
variableDeclarationList();
setState(1134);
match(SemiColon);
setState(1136);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << RegularExpressionLiteral) | (1L << OpenBracket) | (1L << OpenParen) | (1L << OpenBrace) | (1L << PlusPlus) | (1L << MinusMinus) | (1L << Plus) | (1L << Minus) | (1L << BitNot) | (1L << Not) | (1L << LessThan) | (1L << Lodash) | (1L << Dollar) | (1L << NullLiteral) | (1L << BooleanLiteral) | (1L << DecimalLiteral))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (HexIntegerLiteral - 64)) | (1L << (OctalIntegerLiteral - 64)) | (1L << (OctalIntegerLiteral2 - 64)) | (1L << (BinaryIntegerLiteral - 64)) | (1L << (Break - 64)) | (1L << (Do - 64)) | (1L << (Instanceof - 64)) | (1L << (Typeof - 64)) | (1L << (Keyof - 64)) | (1L << (Case - 64)) | (1L << (Else - 64)) | (1L << (New - 64)) | (1L << (Var - 64)) | (1L << (Catch - 64)) | (1L << (Finally - 64)) | (1L << (Return - 64)) | (1L << (Void - 64)) | (1L << (Continue - 64)) | (1L << (For - 64)) | (1L << (Switch - 64)) | (1L << (While - 64)) | (1L << (Debugger - 64)) | (1L << (Function_ - 64)) | (1L << (This - 64)) | (1L << (With - 64)) | (1L << (If - 64)) | (1L << (Throw - 64)) | (1L << (Delete - 64)) | (1L << (In - 64)) | (1L << (Try - 64)) | (1L << (From - 64)) | (1L << (ReadOnly - 64)) | (1L << (Async - 64)) | (1L << (Await - 64)) | (1L << (Class - 64)) | (1L << (Enum - 64)) | (1L << (Extends - 64)) | (1L << (Super - 64)) | (1L << (Const - 64)) | (1L << (Export - 64)) | (1L << (Import - 64)) | (1L << (Implements - 64)) | (1L << (Let - 64)) | (1L << (Private - 64)) | (1L << (Public - 64)) | (1L << (Interface - 64)) | (1L << (Package - 64)) | (1L << (Protected - 64)) | (1L << (Static - 64)) | (1L << (Yield - 64)) | (1L << (Any - 64)) | (1L << (Number - 64)) | (1L << (Boolean - 64)) | (1L << (String - 64)) | (1L << (TypeAlias - 64)) | (1L << (Get - 64)) | (1L << (Set - 64)) | (1L << (Namespace - 64)) | (1L << (Require - 64)))) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & ((1L << (Module - 128)) | (1L << (Undefined - 128)) | (1L << (Is - 128)) | (1L << (Identifier - 128)) | (1L << (StringLiteral - 128)) | (1L << (BackTick - 128)))) != 0)) {
{
setState(1135);
expressionSequence();
}
}
setState(1138);
match(SemiColon);
setState(1140);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << RegularExpressionLiteral) | (1L << OpenBracket) | (1L << OpenParen) | (1L << OpenBrace) | (1L << PlusPlus) | (1L << MinusMinus) | (1L << Plus) | (1L << Minus) | (1L << BitNot) | (1L << Not) | (1L << LessThan) | (1L << Lodash) | (1L << Dollar) | (1L << NullLiteral) | (1L << BooleanLiteral) | (1L << DecimalLiteral))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (HexIntegerLiteral - 64)) | (1L << (OctalIntegerLiteral - 64)) | (1L << (OctalIntegerLiteral2 - 64)) | (1L << (BinaryIntegerLiteral - 64)) | (1L << (Break - 64)) | (1L << (Do - 64)) | (1L << (Instanceof - 64)) | (1L << (Typeof - 64)) | (1L << (Keyof - 64)) | (1L << (Case - 64)) | (1L << (Else - 64)) | (1L << (New - 64)) | (1L << (Var - 64)) | (1L << (Catch - 64)) | (1L << (Finally - 64)) | (1L << (Return - 64)) | (1L << (Void - 64)) | (1L << (Continue - 64)) | (1L << (For - 64)) | (1L << (Switch - 64)) | (1L << (While - 64)) | (1L << (Debugger - 64)) | (1L << (Function_ - 64)) | (1L << (This - 64)) | (1L << (With - 64)) | (1L << (If - 64)) | (1L << (Throw - 64)) | (1L << (Delete - 64)) | (1L << (In - 64)) | (1L << (Try - 64)) | (1L << (From - 64)) | (1L << (ReadOnly - 64)) | (1L << (Async - 64)) | (1L << (Await - 64)) | (1L << (Class - 64)) | (1L << (Enum - 64)) | (1L << (Extends - 64)) | (1L << (Super - 64)) | (1L << (Const - 64)) | (1L << (Export - 64)) | (1L << (Import - 64)) | (1L << (Implements - 64)) | (1L << (Let - 64)) | (1L << (Private - 64)) | (1L << (Public - 64)) | (1L << (Interface - 64)) | (1L << (Package - 64)) | (1L << (Protected - 64)) | (1L << (Static - 64)) | (1L << (Yield - 64)) | (1L << (Any - 64)) | (1L << (Number - 64)) | (1L << (Boolean - 64)) | (1L << (String - 64)) | (1L << (TypeAlias - 64)) | (1L << (Get - 64)) | (1L << (Set - 64)) | (1L << (Namespace - 64)) | (1L << (Require - 64)))) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & ((1L << (Module - 128)) | (1L << (Undefined - 128)) | (1L << (Is - 128)) | (1L << (Identifier - 128)) | (1L << (StringLiteral - 128)) | (1L << (BackTick - 128)))) != 0)) {
{
setState(1139);
expressionSequence();
}
}
setState(1142);
match(CloseParen);
setState(1143);
statement();
}
break;
case 5:
_localctx = new ForInStatementContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(1145);
match(For);
setState(1146);
match(OpenParen);
setState(1147);
singleExpression(0);
setState(1151);
_errHandler.sync(this);
switch (_input.LA(1)) {
case In:
{
setState(1148);
match(In);
}
break;
case Identifier:
{
setState(1149);
match(Identifier);
setState(1150);
if (!(this.p("of"))) throw new FailedPredicateException(this, "this.p(\"of\")");
}
break;
default:
throw new NoViableAltException(this);
}
setState(1153);
expressionSequence();
setState(1154);
match(CloseParen);
setState(1155);
statement();
}
break;
case 6:
_localctx = new ForVarInStatementContext(_localctx);
enterOuterAlt(_localctx, 6);
{
setState(1157);
match(For);
setState(1158);
match(OpenParen);
setState(1159);
varModifier();
setState(1160);
variableDeclaration();
setState(1164);
_errHandler.sync(this);
switch (_input.LA(1)) {
case In:
{
setState(1161);
match(In);
}
break;
case Identifier:
{
setState(1162);
match(Identifier);
setState(1163);
if (!(this.p("of"))) throw new FailedPredicateException(this, "this.p(\"of\")");
}
break;
default:
throw new NoViableAltException(this);
}
setState(1166);
expressionSequence();
setState(1167);
match(CloseParen);
setState(1168);
statement();
}
break;
case 7:
_localctx = new ForOfStatementContext(_localctx);
enterOuterAlt(_localctx, 7);
{
setState(1170);
match(For);
setState(1172);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Await) {
{
setState(1171);
match(Await);
}
}
setState(1174);
match(OpenParen);
setState(1177);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,136,_ctx) ) {
case 1:
{
setState(1175);
singleExpression(0);
}
break;
case 2:
{
setState(1176);
variableDeclarationList();
}
break;
}
setState(1179);
match(Of);
setState(1180);
expressionSequence();
setState(1181);
match(CloseParen);
setState(1182);
statement();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class VarModifierContext extends ParserRuleContext {
public TerminalNode Var() { return getToken(TypeScriptParser.Var, 0); }
public TerminalNode Let() { return getToken(TypeScriptParser.Let, 0); }
public TerminalNode Const() { return getToken(TypeScriptParser.Const, 0); }
public VarModifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_varModifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterVarModifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitVarModifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitVarModifier(this);
else return visitor.visitChildren(this);
}
}
public final VarModifierContext varModifier() throws RecognitionException {
VarModifierContext _localctx = new VarModifierContext(_ctx, getState());
enterRule(_localctx, 166, RULE_varModifier);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1186);
_la = _input.LA(1);
if ( !(((((_la - 76)) & ~0x3f) == 0 && ((1L << (_la - 76)) & ((1L << (Var - 76)) | (1L << (Const - 76)) | (1L << (Let - 76)))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ContinueStatementContext extends ParserRuleContext {
public TerminalNode Continue() { return getToken(TypeScriptParser.Continue, 0); }
public EosContext eos() {
return getRuleContext(EosContext.class,0);
}
public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); }
public ContinueStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_continueStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterContinueStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitContinueStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitContinueStatement(this);
else return visitor.visitChildren(this);
}
}
public final ContinueStatementContext continueStatement() throws RecognitionException {
ContinueStatementContext _localctx = new ContinueStatementContext(_ctx, getState());
enterRule(_localctx, 168, RULE_continueStatement);
try {
enterOuterAlt(_localctx, 1);
{
setState(1188);
match(Continue);
setState(1191);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,138,_ctx) ) {
case 1:
{
setState(1189);
if (!(this.notLineTerminator())) throw new FailedPredicateException(this, "this.notLineTerminator()");
setState(1190);
match(Identifier);
}
break;
}
setState(1193);
eos();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BreakStatementContext extends ParserRuleContext {
public TerminalNode Break() { return getToken(TypeScriptParser.Break, 0); }
public EosContext eos() {
return getRuleContext(EosContext.class,0);
}
public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); }
public BreakStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_breakStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterBreakStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitBreakStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitBreakStatement(this);
else return visitor.visitChildren(this);
}
}
public final BreakStatementContext breakStatement() throws RecognitionException {
BreakStatementContext _localctx = new BreakStatementContext(_ctx, getState());
enterRule(_localctx, 170, RULE_breakStatement);
try {
enterOuterAlt(_localctx, 1);
{
setState(1195);
match(Break);
setState(1198);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,139,_ctx) ) {
case 1:
{
setState(1196);
if (!(this.notLineTerminator())) throw new FailedPredicateException(this, "this.notLineTerminator()");
setState(1197);
match(Identifier);
}
break;
}
setState(1200);
eos();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ReturnStatementContext extends ParserRuleContext {
public TerminalNode Return() { return getToken(TypeScriptParser.Return, 0); }
public EosContext eos() {
return getRuleContext(EosContext.class,0);
}
public ExpressionSequenceContext expressionSequence() {
return getRuleContext(ExpressionSequenceContext.class,0);
}
public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); }
public HtmlElementsContext htmlElements() {
return getRuleContext(HtmlElementsContext.class,0);
}
public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); }
public ReturnStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_returnStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterReturnStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitReturnStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitReturnStatement(this);
else return visitor.visitChildren(this);
}
}
public final ReturnStatementContext returnStatement() throws RecognitionException {
ReturnStatementContext _localctx = new ReturnStatementContext(_ctx, getState());
enterRule(_localctx, 172, RULE_returnStatement);
try {
setState(1214);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,141,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1202);
match(Return);
setState(1205);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,140,_ctx) ) {
case 1:
{
setState(1203);
if (!(this.notLineTerminator())) throw new FailedPredicateException(this, "this.notLineTerminator()");
setState(1204);
expressionSequence();
}
break;
}
setState(1207);
eos();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1208);
match(Return);
setState(1209);
match(OpenParen);
setState(1210);
htmlElements();
setState(1211);
match(CloseParen);
setState(1212);
eos();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class HtmlElementsContext extends ParserRuleContext {
public List htmlElement() {
return getRuleContexts(HtmlElementContext.class);
}
public HtmlElementContext htmlElement(int i) {
return getRuleContext(HtmlElementContext.class,i);
}
public HtmlElementsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_htmlElements; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterHtmlElements(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitHtmlElements(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitHtmlElements(this);
else return visitor.visitChildren(this);
}
}
public final HtmlElementsContext htmlElements() throws RecognitionException {
HtmlElementsContext _localctx = new HtmlElementsContext(_ctx, getState());
enterRule(_localctx, 174, RULE_htmlElements);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1217);
_errHandler.sync(this);
_alt = 1;
do {
switch (_alt) {
case 1:
{
{
setState(1216);
htmlElement();
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(1219);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,142,_ctx);
} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class HtmlElementContext extends ParserRuleContext {
public List LessThan() { return getTokens(TypeScriptParser.LessThan); }
public TerminalNode LessThan(int i) {
return getToken(TypeScriptParser.LessThan, i);
}
public HtmlTagStartNameContext htmlTagStartName() {
return getRuleContext(HtmlTagStartNameContext.class,0);
}
public List MoreThan() { return getTokens(TypeScriptParser.MoreThan); }
public TerminalNode MoreThan(int i) {
return getToken(TypeScriptParser.MoreThan, i);
}
public HtmlContentContext htmlContent() {
return getRuleContext(HtmlContentContext.class,0);
}
public TerminalNode Divide() { return getToken(TypeScriptParser.Divide, 0); }
public HtmlTagClosingNameContext htmlTagClosingName() {
return getRuleContext(HtmlTagClosingNameContext.class,0);
}
public List htmlAttribute() {
return getRuleContexts(HtmlAttributeContext.class);
}
public HtmlAttributeContext htmlAttribute(int i) {
return getRuleContext(HtmlAttributeContext.class,i);
}
public HtmlTagNameContext htmlTagName() {
return getRuleContext(HtmlTagNameContext.class,0);
}
public HtmlElementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_htmlElement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterHtmlElement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitHtmlElement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitHtmlElement(this);
else return visitor.visitChildren(this);
}
}
public final HtmlElementContext htmlElement() throws RecognitionException {
HtmlElementContext _localctx = new HtmlElementContext(_ctx, getState());
enterRule(_localctx, 176, RULE_htmlElement);
int _la;
try {
int _alt;
setState(1276);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,147,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1221);
match(LessThan);
setState(1222);
htmlTagStartName();
setState(1226);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==OpenBrace || _la==Lodash || ((((_la - 117)) & ~0x3f) == 0 && ((1L << (_la - 117)) & ((1L << (Any - 117)) | (1L << (TypeAlias - 117)) | (1L << (Require - 117)) | (1L << (Module - 117)) | (1L << (Identifier - 117)) | (1L << (TagName - 117)))) != 0)) {
{
{
setState(1223);
htmlAttribute();
}
}
setState(1228);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1229);
match(MoreThan);
setState(1230);
htmlContent();
setState(1231);
match(LessThan);
setState(1232);
match(Divide);
setState(1233);
htmlTagClosingName();
setState(1234);
match(MoreThan);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1236);
match(LessThan);
setState(1237);
match(MoreThan);
setState(1238);
htmlContent();
setState(1239);
match(LessThan);
setState(1240);
match(Divide);
setState(1241);
match(MoreThan);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1243);
match(LessThan);
setState(1244);
htmlTagName();
setState(1248);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,144,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1245);
htmlAttribute();
}
}
}
setState(1250);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,144,_ctx);
}
setState(1251);
htmlContent();
setState(1252);
match(Divide);
setState(1253);
match(MoreThan);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(1255);
match(LessThan);
setState(1256);
htmlTagName();
setState(1260);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==OpenBrace || _la==Lodash || ((((_la - 117)) & ~0x3f) == 0 && ((1L << (_la - 117)) & ((1L << (Any - 117)) | (1L << (TypeAlias - 117)) | (1L << (Require - 117)) | (1L << (Module - 117)) | (1L << (Identifier - 117)) | (1L << (TagName - 117)))) != 0)) {
{
{
setState(1257);
htmlAttribute();
}
}
setState(1262);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1263);
match(Divide);
setState(1264);
match(MoreThan);
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(1266);
match(LessThan);
setState(1267);
htmlTagName();
setState(1271);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==OpenBrace || _la==Lodash || ((((_la - 117)) & ~0x3f) == 0 && ((1L << (_la - 117)) & ((1L << (Any - 117)) | (1L << (TypeAlias - 117)) | (1L << (Require - 117)) | (1L << (Module - 117)) | (1L << (Identifier - 117)) | (1L << (TagName - 117)))) != 0)) {
{
{
setState(1268);
htmlAttribute();
}
}
setState(1273);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1274);
match(MoreThan);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class HtmlContentContext extends ParserRuleContext {
public List htmlChardata() {
return getRuleContexts(HtmlChardataContext.class);
}
public HtmlChardataContext htmlChardata(int i) {
return getRuleContext(HtmlChardataContext.class,i);
}
public List htmlElement() {
return getRuleContexts(HtmlElementContext.class);
}
public HtmlElementContext htmlElement(int i) {
return getRuleContext(HtmlElementContext.class,i);
}
public List objectExpressionSequence() {
return getRuleContexts(ObjectExpressionSequenceContext.class);
}
public ObjectExpressionSequenceContext objectExpressionSequence(int i) {
return getRuleContext(ObjectExpressionSequenceContext.class,i);
}
public HtmlContentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_htmlContent; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterHtmlContent(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitHtmlContent(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitHtmlContent(this);
else return visitor.visitChildren(this);
}
}
public final HtmlContentContext htmlContent() throws RecognitionException {
HtmlContentContext _localctx = new HtmlContentContext(_ctx, getState());
enterRule(_localctx, 178, RULE_htmlContent);
try {
int _alt;
setState(1305);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,155,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1279);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,148,_ctx) ) {
case 1:
{
setState(1278);
htmlChardata();
}
break;
}
setState(1287);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,150,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
{
setState(1281);
htmlElement();
}
setState(1283);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,149,_ctx) ) {
case 1:
{
setState(1282);
htmlChardata();
}
break;
}
}
}
}
setState(1289);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,150,_ctx);
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1291);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,151,_ctx) ) {
case 1:
{
setState(1290);
htmlChardata();
}
break;
}
setState(1302);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,154,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1295);
_errHandler.sync(this);
switch (_input.LA(1)) {
case LessThan:
{
setState(1293);
htmlElement();
}
break;
case OpenBrace:
{
setState(1294);
objectExpressionSequence();
}
break;
default:
throw new NoViableAltException(this);
}
setState(1298);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,153,_ctx) ) {
case 1:
{
setState(1297);
htmlChardata();
}
break;
}
}
}
}
setState(1304);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,154,_ctx);
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class HtmlTagStartNameContext extends ParserRuleContext {
public HtmlTagNameContext htmlTagName;
public HtmlTagNameContext htmlTagName() {
return getRuleContext(HtmlTagNameContext.class,0);
}
public HtmlTagStartNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_htmlTagStartName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterHtmlTagStartName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitHtmlTagStartName(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitHtmlTagStartName(this);
else return visitor.visitChildren(this);
}
}
public final HtmlTagStartNameContext htmlTagStartName() throws RecognitionException {
HtmlTagStartNameContext _localctx = new HtmlTagStartNameContext(_ctx, getState());
enterRule(_localctx, 180, RULE_htmlTagStartName);
try {
enterOuterAlt(_localctx, 1);
{
setState(1307);
((HtmlTagStartNameContext)_localctx).htmlTagName = htmlTagName();
this.pushHtmlTagName((((HtmlTagStartNameContext)_localctx).htmlTagName!=null?_input.getText(((HtmlTagStartNameContext)_localctx).htmlTagName.start,((HtmlTagStartNameContext)_localctx).htmlTagName.stop):null));
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class HtmlTagClosingNameContext extends ParserRuleContext {
public HtmlTagNameContext htmlTagName;
public HtmlTagNameContext htmlTagName() {
return getRuleContext(HtmlTagNameContext.class,0);
}
public HtmlTagClosingNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_htmlTagClosingName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterHtmlTagClosingName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitHtmlTagClosingName(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitHtmlTagClosingName(this);
else return visitor.visitChildren(this);
}
}
public final HtmlTagClosingNameContext htmlTagClosingName() throws RecognitionException {
HtmlTagClosingNameContext _localctx = new HtmlTagClosingNameContext(_ctx, getState());
enterRule(_localctx, 182, RULE_htmlTagClosingName);
try {
enterOuterAlt(_localctx, 1);
{
setState(1310);
((HtmlTagClosingNameContext)_localctx).htmlTagName = htmlTagName();
setState(1311);
if (!(this.popHtmlTagName((((HtmlTagClosingNameContext)_localctx).htmlTagName!=null?_input.getText(((HtmlTagClosingNameContext)_localctx).htmlTagName.start,((HtmlTagClosingNameContext)_localctx).htmlTagName.stop):null)))) throw new FailedPredicateException(this, "this.popHtmlTagName($htmlTagName.text)");
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class HtmlTagNameContext extends ParserRuleContext {
public TerminalNode TagName() { return getToken(TypeScriptParser.TagName, 0); }
public KeywordContext keyword() {
return getRuleContext(KeywordContext.class,0);
}
public List Identifier() { return getTokens(TypeScriptParser.Identifier); }
public TerminalNode Identifier(int i) {
return getToken(TypeScriptParser.Identifier, i);
}
public List Dot() { return getTokens(TypeScriptParser.Dot); }
public TerminalNode Dot(int i) {
return getToken(TypeScriptParser.Dot, i);
}
public HtmlTagNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_htmlTagName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterHtmlTagName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitHtmlTagName(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitHtmlTagName(this);
else return visitor.visitChildren(this);
}
}
public final HtmlTagNameContext htmlTagName() throws RecognitionException {
HtmlTagNameContext _localctx = new HtmlTagNameContext(_ctx, getState());
enterRule(_localctx, 184, RULE_htmlTagName);
try {
int _alt;
setState(1324);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,157,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1313);
match(TagName);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1314);
keyword();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1315);
match(Identifier);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(1316);
match(Identifier);
setState(1321);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,156,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1317);
match(Dot);
setState(1318);
match(Identifier);
}
}
}
setState(1323);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,156,_ctx);
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class HtmlAttributeContext extends ParserRuleContext {
public HtmlAttributeNameContext htmlAttributeName() {
return getRuleContext(HtmlAttributeNameContext.class,0);
}
public TerminalNode Assign() { return getToken(TypeScriptParser.Assign, 0); }
public HtmlAttributeValueContext htmlAttributeValue() {
return getRuleContext(HtmlAttributeValueContext.class,0);
}
public ObjectLiteralContext objectLiteral() {
return getRuleContext(ObjectLiteralContext.class,0);
}
public HtmlAttributeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_htmlAttribute; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterHtmlAttribute(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitHtmlAttribute(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitHtmlAttribute(this);
else return visitor.visitChildren(this);
}
}
public final HtmlAttributeContext htmlAttribute() throws RecognitionException {
HtmlAttributeContext _localctx = new HtmlAttributeContext(_ctx, getState());
enterRule(_localctx, 186, RULE_htmlAttribute);
try {
setState(1332);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,158,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1326);
htmlAttributeName();
setState(1327);
match(Assign);
setState(1328);
htmlAttributeValue();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1330);
htmlAttributeName();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1331);
objectLiteral();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class HtmlAttributeNameContext extends ParserRuleContext {
public TerminalNode TagName() { return getToken(TypeScriptParser.TagName, 0); }
public IdentifierOrKeyWordContext identifierOrKeyWord() {
return getRuleContext(IdentifierOrKeyWordContext.class,0);
}
public List Identifier() { return getTokens(TypeScriptParser.Identifier); }
public TerminalNode Identifier(int i) {
return getToken(TypeScriptParser.Identifier, i);
}
public List Minus() { return getTokens(TypeScriptParser.Minus); }
public TerminalNode Minus(int i) {
return getToken(TypeScriptParser.Minus, i);
}
public HtmlAttributeNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_htmlAttributeName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterHtmlAttributeName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitHtmlAttributeName(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitHtmlAttributeName(this);
else return visitor.visitChildren(this);
}
}
public final HtmlAttributeNameContext htmlAttributeName() throws RecognitionException {
HtmlAttributeNameContext _localctx = new HtmlAttributeNameContext(_ctx, getState());
enterRule(_localctx, 188, RULE_htmlAttributeName);
try {
int _alt;
setState(1344);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,160,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1334);
match(TagName);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1335);
identifierOrKeyWord();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1336);
match(Identifier);
setState(1341);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,159,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1337);
match(Minus);
setState(1338);
match(Identifier);
}
}
}
setState(1343);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,159,_ctx);
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class HtmlChardataContext extends ParserRuleContext {
public List LessThan() { return getTokens(TypeScriptParser.LessThan); }
public TerminalNode LessThan(int i) {
return getToken(TypeScriptParser.LessThan, i);
}
public List OpenBrace() { return getTokens(TypeScriptParser.OpenBrace); }
public TerminalNode OpenBrace(int i) {
return getToken(TypeScriptParser.OpenBrace, i);
}
public HtmlChardataContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_htmlChardata; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterHtmlChardata(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitHtmlChardata(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitHtmlChardata(this);
else return visitor.visitChildren(this);
}
}
public final HtmlChardataContext htmlChardata() throws RecognitionException {
HtmlChardataContext _localctx = new HtmlChardataContext(_ctx, getState());
enterRule(_localctx, 190, RULE_htmlChardata);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1347);
_errHandler.sync(this);
_alt = 1;
do {
switch (_alt) {
case 1:
{
{
setState(1346);
_la = _input.LA(1);
if ( _la <= 0 || (_la==OpenBrace || _la==LessThan) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(1349);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,161,_ctx);
} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class HtmlAttributeValueContext extends ParserRuleContext {
public TerminalNode AttributeValue() { return getToken(TypeScriptParser.AttributeValue, 0); }
public TerminalNode StringLiteral() { return getToken(TypeScriptParser.StringLiteral, 0); }
public ObjectExpressionSequenceContext objectExpressionSequence() {
return getRuleContext(ObjectExpressionSequenceContext.class,0);
}
public HtmlAttributeValueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_htmlAttributeValue; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterHtmlAttributeValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitHtmlAttributeValue(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitHtmlAttributeValue(this);
else return visitor.visitChildren(this);
}
}
public final HtmlAttributeValueContext htmlAttributeValue() throws RecognitionException {
HtmlAttributeValueContext _localctx = new HtmlAttributeValueContext(_ctx, getState());
enterRule(_localctx, 192, RULE_htmlAttributeValue);
try {
setState(1354);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AttributeValue:
enterOuterAlt(_localctx, 1);
{
setState(1351);
match(AttributeValue);
}
break;
case StringLiteral:
enterOuterAlt(_localctx, 2);
{
setState(1352);
match(StringLiteral);
}
break;
case OpenBrace:
enterOuterAlt(_localctx, 3);
{
setState(1353);
objectExpressionSequence();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ObjectExpressionSequenceContext extends ParserRuleContext {
public TerminalNode OpenBrace() { return getToken(TypeScriptParser.OpenBrace, 0); }
public ExpressionSequenceContext expressionSequence() {
return getRuleContext(ExpressionSequenceContext.class,0);
}
public TerminalNode CloseBrace() { return getToken(TypeScriptParser.CloseBrace, 0); }
public ObjectExpressionSequenceContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_objectExpressionSequence; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterObjectExpressionSequence(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitObjectExpressionSequence(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitObjectExpressionSequence(this);
else return visitor.visitChildren(this);
}
}
public final ObjectExpressionSequenceContext objectExpressionSequence() throws RecognitionException {
ObjectExpressionSequenceContext _localctx = new ObjectExpressionSequenceContext(_ctx, getState());
enterRule(_localctx, 194, RULE_objectExpressionSequence);
try {
enterOuterAlt(_localctx, 1);
{
setState(1356);
match(OpenBrace);
setState(1357);
expressionSequence();
setState(1358);
match(CloseBrace);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class YieldStatementContext extends ParserRuleContext {
public TerminalNode Yield() { return getToken(TypeScriptParser.Yield, 0); }
public EosContext eos() {
return getRuleContext(EosContext.class,0);
}
public ExpressionSequenceContext expressionSequence() {
return getRuleContext(ExpressionSequenceContext.class,0);
}
public YieldStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_yieldStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterYieldStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitYieldStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitYieldStatement(this);
else return visitor.visitChildren(this);
}
}
public final YieldStatementContext yieldStatement() throws RecognitionException {
YieldStatementContext _localctx = new YieldStatementContext(_ctx, getState());
enterRule(_localctx, 196, RULE_yieldStatement);
try {
enterOuterAlt(_localctx, 1);
{
setState(1360);
match(Yield);
setState(1363);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,163,_ctx) ) {
case 1:
{
setState(1361);
if (!(this.notLineTerminator())) throw new FailedPredicateException(this, "this.notLineTerminator()");
setState(1362);
expressionSequence();
}
break;
}
setState(1365);
eos();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class WithStatementContext extends ParserRuleContext {
public TerminalNode With() { return getToken(TypeScriptParser.With, 0); }
public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); }
public ExpressionSequenceContext expressionSequence() {
return getRuleContext(ExpressionSequenceContext.class,0);
}
public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); }
public StatementContext statement() {
return getRuleContext(StatementContext.class,0);
}
public WithStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_withStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterWithStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitWithStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitWithStatement(this);
else return visitor.visitChildren(this);
}
}
public final WithStatementContext withStatement() throws RecognitionException {
WithStatementContext _localctx = new WithStatementContext(_ctx, getState());
enterRule(_localctx, 198, RULE_withStatement);
try {
enterOuterAlt(_localctx, 1);
{
setState(1367);
match(With);
setState(1368);
match(OpenParen);
setState(1369);
expressionSequence();
setState(1370);
match(CloseParen);
setState(1371);
statement();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SwitchStatementContext extends ParserRuleContext {
public TerminalNode Switch() { return getToken(TypeScriptParser.Switch, 0); }
public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); }
public ExpressionSequenceContext expressionSequence() {
return getRuleContext(ExpressionSequenceContext.class,0);
}
public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); }
public CaseBlockContext caseBlock() {
return getRuleContext(CaseBlockContext.class,0);
}
public SwitchStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_switchStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterSwitchStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitSwitchStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitSwitchStatement(this);
else return visitor.visitChildren(this);
}
}
public final SwitchStatementContext switchStatement() throws RecognitionException {
SwitchStatementContext _localctx = new SwitchStatementContext(_ctx, getState());
enterRule(_localctx, 200, RULE_switchStatement);
try {
enterOuterAlt(_localctx, 1);
{
setState(1373);
match(Switch);
setState(1374);
match(OpenParen);
setState(1375);
expressionSequence();
setState(1376);
match(CloseParen);
setState(1377);
caseBlock();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CaseBlockContext extends ParserRuleContext {
public TerminalNode OpenBrace() { return getToken(TypeScriptParser.OpenBrace, 0); }
public TerminalNode CloseBrace() { return getToken(TypeScriptParser.CloseBrace, 0); }
public List caseClauses() {
return getRuleContexts(CaseClausesContext.class);
}
public CaseClausesContext caseClauses(int i) {
return getRuleContext(CaseClausesContext.class,i);
}
public DefaultClauseContext defaultClause() {
return getRuleContext(DefaultClauseContext.class,0);
}
public CaseBlockContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_caseBlock; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterCaseBlock(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitCaseBlock(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitCaseBlock(this);
else return visitor.visitChildren(this);
}
}
public final CaseBlockContext caseBlock() throws RecognitionException {
CaseBlockContext _localctx = new CaseBlockContext(_ctx, getState());
enterRule(_localctx, 202, RULE_caseBlock);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1379);
match(OpenBrace);
setState(1381);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Case) {
{
setState(1380);
caseClauses();
}
}
setState(1387);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Default) {
{
setState(1383);
defaultClause();
setState(1385);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Case) {
{
setState(1384);
caseClauses();
}
}
}
}
setState(1389);
match(CloseBrace);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CaseClausesContext extends ParserRuleContext {
public List caseClause() {
return getRuleContexts(CaseClauseContext.class);
}
public CaseClauseContext caseClause(int i) {
return getRuleContext(CaseClauseContext.class,i);
}
public CaseClausesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_caseClauses; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterCaseClauses(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitCaseClauses(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitCaseClauses(this);
else return visitor.visitChildren(this);
}
}
public final CaseClausesContext caseClauses() throws RecognitionException {
CaseClausesContext _localctx = new CaseClausesContext(_ctx, getState());
enterRule(_localctx, 204, RULE_caseClauses);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1392);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(1391);
caseClause();
}
}
setState(1394);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==Case );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CaseClauseContext extends ParserRuleContext {
public TerminalNode Case() { return getToken(TypeScriptParser.Case, 0); }
public ExpressionSequenceContext expressionSequence() {
return getRuleContext(ExpressionSequenceContext.class,0);
}
public TerminalNode Colon() { return getToken(TypeScriptParser.Colon, 0); }
public StatementListContext statementList() {
return getRuleContext(StatementListContext.class,0);
}
public CaseClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_caseClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterCaseClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitCaseClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitCaseClause(this);
else return visitor.visitChildren(this);
}
}
public final CaseClauseContext caseClause() throws RecognitionException {
CaseClauseContext _localctx = new CaseClauseContext(_ctx, getState());
enterRule(_localctx, 206, RULE_caseClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(1396);
match(Case);
setState(1397);
expressionSequence();
setState(1398);
match(Colon);
setState(1400);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,168,_ctx) ) {
case 1:
{
setState(1399);
statementList();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DefaultClauseContext extends ParserRuleContext {
public TerminalNode Default() { return getToken(TypeScriptParser.Default, 0); }
public TerminalNode Colon() { return getToken(TypeScriptParser.Colon, 0); }
public StatementListContext statementList() {
return getRuleContext(StatementListContext.class,0);
}
public DefaultClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_defaultClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterDefaultClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitDefaultClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitDefaultClause(this);
else return visitor.visitChildren(this);
}
}
public final DefaultClauseContext defaultClause() throws RecognitionException {
DefaultClauseContext _localctx = new DefaultClauseContext(_ctx, getState());
enterRule(_localctx, 208, RULE_defaultClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(1402);
match(Default);
setState(1403);
match(Colon);
setState(1405);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,169,_ctx) ) {
case 1:
{
setState(1404);
statementList();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LabelledStatementContext extends ParserRuleContext {
public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); }
public TerminalNode Colon() { return getToken(TypeScriptParser.Colon, 0); }
public StatementContext statement() {
return getRuleContext(StatementContext.class,0);
}
public LabelledStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_labelledStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterLabelledStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitLabelledStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitLabelledStatement(this);
else return visitor.visitChildren(this);
}
}
public final LabelledStatementContext labelledStatement() throws RecognitionException {
LabelledStatementContext _localctx = new LabelledStatementContext(_ctx, getState());
enterRule(_localctx, 210, RULE_labelledStatement);
try {
enterOuterAlt(_localctx, 1);
{
setState(1407);
match(Identifier);
setState(1408);
match(Colon);
setState(1409);
statement();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ThrowStatementContext extends ParserRuleContext {
public TerminalNode Throw() { return getToken(TypeScriptParser.Throw, 0); }
public ExpressionSequenceContext expressionSequence() {
return getRuleContext(ExpressionSequenceContext.class,0);
}
public EosContext eos() {
return getRuleContext(EosContext.class,0);
}
public ThrowStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_throwStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterThrowStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitThrowStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitThrowStatement(this);
else return visitor.visitChildren(this);
}
}
public final ThrowStatementContext throwStatement() throws RecognitionException {
ThrowStatementContext _localctx = new ThrowStatementContext(_ctx, getState());
enterRule(_localctx, 212, RULE_throwStatement);
try {
enterOuterAlt(_localctx, 1);
{
setState(1411);
match(Throw);
setState(1412);
if (!(this.notLineTerminator())) throw new FailedPredicateException(this, "this.notLineTerminator()");
setState(1413);
expressionSequence();
setState(1414);
eos();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TryStatementContext extends ParserRuleContext {
public TerminalNode Try() { return getToken(TypeScriptParser.Try, 0); }
public BlockContext block() {
return getRuleContext(BlockContext.class,0);
}
public CatchProductionContext catchProduction() {
return getRuleContext(CatchProductionContext.class,0);
}
public FinallyProductionContext finallyProduction() {
return getRuleContext(FinallyProductionContext.class,0);
}
public TryStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_tryStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTryStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTryStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitTryStatement(this);
else return visitor.visitChildren(this);
}
}
public final TryStatementContext tryStatement() throws RecognitionException {
TryStatementContext _localctx = new TryStatementContext(_ctx, getState());
enterRule(_localctx, 214, RULE_tryStatement);
try {
enterOuterAlt(_localctx, 1);
{
setState(1416);
match(Try);
setState(1417);
block();
setState(1423);
_errHandler.sync(this);
switch (_input.LA(1)) {
case Catch:
{
setState(1418);
catchProduction();
setState(1420);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,170,_ctx) ) {
case 1:
{
setState(1419);
finallyProduction();
}
break;
}
}
break;
case Finally:
{
setState(1422);
finallyProduction();
}
break;
default:
throw new NoViableAltException(this);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CatchProductionContext extends ParserRuleContext {
public TerminalNode Catch() { return getToken(TypeScriptParser.Catch, 0); }
public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); }
public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); }
public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); }
public BlockContext block() {
return getRuleContext(BlockContext.class,0);
}
public CatchProductionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_catchProduction; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterCatchProduction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitCatchProduction(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitCatchProduction(this);
else return visitor.visitChildren(this);
}
}
public final CatchProductionContext catchProduction() throws RecognitionException {
CatchProductionContext _localctx = new CatchProductionContext(_ctx, getState());
enterRule(_localctx, 216, RULE_catchProduction);
try {
enterOuterAlt(_localctx, 1);
{
setState(1425);
match(Catch);
setState(1426);
match(OpenParen);
setState(1427);
match(Identifier);
setState(1428);
match(CloseParen);
setState(1429);
block();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FinallyProductionContext extends ParserRuleContext {
public TerminalNode Finally() { return getToken(TypeScriptParser.Finally, 0); }
public BlockContext block() {
return getRuleContext(BlockContext.class,0);
}
public FinallyProductionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_finallyProduction; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterFinallyProduction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitFinallyProduction(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitFinallyProduction(this);
else return visitor.visitChildren(this);
}
}
public final FinallyProductionContext finallyProduction() throws RecognitionException {
FinallyProductionContext _localctx = new FinallyProductionContext(_ctx, getState());
enterRule(_localctx, 218, RULE_finallyProduction);
try {
enterOuterAlt(_localctx, 1);
{
setState(1431);
match(Finally);
setState(1432);
block();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DebuggerStatementContext extends ParserRuleContext {
public TerminalNode Debugger() { return getToken(TypeScriptParser.Debugger, 0); }
public EosContext eos() {
return getRuleContext(EosContext.class,0);
}
public DebuggerStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_debuggerStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterDebuggerStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitDebuggerStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitDebuggerStatement(this);
else return visitor.visitChildren(this);
}
}
public final DebuggerStatementContext debuggerStatement() throws RecognitionException {
DebuggerStatementContext _localctx = new DebuggerStatementContext(_ctx, getState());
enterRule(_localctx, 220, RULE_debuggerStatement);
try {
enterOuterAlt(_localctx, 1);
{
setState(1434);
match(Debugger);
setState(1435);
eos();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FunctionDeclarationContext extends ParserRuleContext {
public TerminalNode Function_() { return getToken(TypeScriptParser.Function_, 0); }
public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); }
public CallSignatureContext callSignature() {
return getRuleContext(CallSignatureContext.class,0);
}
public TerminalNode SemiColon() { return getToken(TypeScriptParser.SemiColon, 0); }
public TerminalNode Default() { return getToken(TypeScriptParser.Default, 0); }
public TerminalNode Async() { return getToken(TypeScriptParser.Async, 0); }
public TerminalNode OpenBrace() { return getToken(TypeScriptParser.OpenBrace, 0); }
public FunctionBodyContext functionBody() {
return getRuleContext(FunctionBodyContext.class,0);
}
public TerminalNode CloseBrace() { return getToken(TypeScriptParser.CloseBrace, 0); }
public FunctionDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_functionDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterFunctionDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitFunctionDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitFunctionDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final FunctionDeclarationContext functionDeclaration() throws RecognitionException {
FunctionDeclarationContext _localctx = new FunctionDeclarationContext(_ctx, getState());
enterRule(_localctx, 222, RULE_functionDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1438);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Default) {
{
setState(1437);
match(Default);
}
}
setState(1441);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Async) {
{
setState(1440);
match(Async);
}
}
setState(1443);
match(Function_);
setState(1444);
match(Identifier);
setState(1445);
callSignature();
setState(1451);
_errHandler.sync(this);
switch (_input.LA(1)) {
case OpenBrace:
{
{
setState(1446);
match(OpenBrace);
setState(1447);
functionBody();
setState(1448);
match(CloseBrace);
}
}
break;
case SemiColon:
{
setState(1450);
match(SemiColon);
}
break;
default:
throw new NoViableAltException(this);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ClassDeclarationContext extends ParserRuleContext {
public TerminalNode Class() { return getToken(TypeScriptParser.Class, 0); }
public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); }
public ClassHeritageContext classHeritage() {
return getRuleContext(ClassHeritageContext.class,0);
}
public ClassTailContext classTail() {
return getRuleContext(ClassTailContext.class,0);
}
public TerminalNode Declare() { return getToken(TypeScriptParser.Declare, 0); }
public TerminalNode Abstract() { return getToken(TypeScriptParser.Abstract, 0); }
public TypeParametersContext typeParameters() {
return getRuleContext(TypeParametersContext.class,0);
}
public ClassDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_classDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterClassDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitClassDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitClassDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final ClassDeclarationContext classDeclaration() throws RecognitionException {
ClassDeclarationContext _localctx = new ClassDeclarationContext(_ctx, getState());
enterRule(_localctx, 224, RULE_classDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1454);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Declare) {
{
setState(1453);
match(Declare);
}
}
setState(1457);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Abstract) {
{
setState(1456);
match(Abstract);
}
}
setState(1459);
match(Class);
setState(1460);
match(Identifier);
setState(1462);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LessThan) {
{
setState(1461);
typeParameters();
}
}
setState(1464);
classHeritage();
setState(1465);
classTail();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ClassHeritageContext extends ParserRuleContext {
public ClassExtendsClauseContext classExtendsClause() {
return getRuleContext(ClassExtendsClauseContext.class,0);
}
public ImplementsClauseContext implementsClause() {
return getRuleContext(ImplementsClauseContext.class,0);
}
public ClassHeritageContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_classHeritage; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterClassHeritage(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitClassHeritage(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitClassHeritage(this);
else return visitor.visitChildren(this);
}
}
public final ClassHeritageContext classHeritage() throws RecognitionException {
ClassHeritageContext _localctx = new ClassHeritageContext(_ctx, getState());
enterRule(_localctx, 226, RULE_classHeritage);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1468);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Extends) {
{
setState(1467);
classExtendsClause();
}
}
setState(1471);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Implements) {
{
setState(1470);
implementsClause();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ClassTailContext extends ParserRuleContext {
public TerminalNode OpenBrace() { return getToken(TypeScriptParser.OpenBrace, 0); }
public TerminalNode CloseBrace() { return getToken(TypeScriptParser.CloseBrace, 0); }
public List classElement() {
return getRuleContexts(ClassElementContext.class);
}
public ClassElementContext classElement(int i) {
return getRuleContext(ClassElementContext.class,i);
}
public ClassTailContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_classTail; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterClassTail(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitClassTail(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitClassTail(this);
else return visitor.visitChildren(this);
}
}
public final ClassTailContext classTail() throws RecognitionException {
ClassTailContext _localctx = new ClassTailContext(_ctx, getState());
enterRule(_localctx, 228, RULE_classTail);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1473);
match(OpenBrace);
setState(1477);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,180,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1474);
classElement();
}
}
}
setState(1479);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,180,_ctx);
}
setState(1480);
match(CloseBrace);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ClassExtendsClauseContext extends ParserRuleContext {
public TerminalNode Extends() { return getToken(TypeScriptParser.Extends, 0); }
public TypeReferenceContext typeReference() {
return getRuleContext(TypeReferenceContext.class,0);
}
public ClassExtendsClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_classExtendsClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterClassExtendsClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitClassExtendsClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitClassExtendsClause(this);
else return visitor.visitChildren(this);
}
}
public final ClassExtendsClauseContext classExtendsClause() throws RecognitionException {
ClassExtendsClauseContext _localctx = new ClassExtendsClauseContext(_ctx, getState());
enterRule(_localctx, 230, RULE_classExtendsClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(1482);
match(Extends);
setState(1483);
typeReference();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ImplementsClauseContext extends ParserRuleContext {
public TerminalNode Implements() { return getToken(TypeScriptParser.Implements, 0); }
public ClassOrInterfaceTypeListContext classOrInterfaceTypeList() {
return getRuleContext(ClassOrInterfaceTypeListContext.class,0);
}
public ImplementsClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_implementsClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterImplementsClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitImplementsClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitImplementsClause(this);
else return visitor.visitChildren(this);
}
}
public final ImplementsClauseContext implementsClause() throws RecognitionException {
ImplementsClauseContext _localctx = new ImplementsClauseContext(_ctx, getState());
enterRule(_localctx, 232, RULE_implementsClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(1485);
match(Implements);
setState(1486);
classOrInterfaceTypeList();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ClassElementContext extends ParserRuleContext {
public ConstructorDeclarationContext constructorDeclaration() {
return getRuleContext(ConstructorDeclarationContext.class,0);
}
public PropertyMemberDeclarationContext propertyMemberDeclaration() {
return getRuleContext(PropertyMemberDeclarationContext.class,0);
}
public DecoratorListContext decoratorList() {
return getRuleContext(DecoratorListContext.class,0);
}
public IndexMemberDeclarationContext indexMemberDeclaration() {
return getRuleContext(IndexMemberDeclarationContext.class,0);
}
public StatementContext statement() {
return getRuleContext(StatementContext.class,0);
}
public ClassElementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_classElement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterClassElement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitClassElement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitClassElement(this);
else return visitor.visitChildren(this);
}
}
public final ClassElementContext classElement() throws RecognitionException {
ClassElementContext _localctx = new ClassElementContext(_ctx, getState());
enterRule(_localctx, 234, RULE_classElement);
int _la;
try {
setState(1495);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,182,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1488);
constructorDeclaration();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1490);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==At) {
{
setState(1489);
decoratorList();
}
}
setState(1492);
propertyMemberDeclaration();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1493);
indexMemberDeclaration();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(1494);
statement();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PropertyMemberDeclarationContext extends ParserRuleContext {
public PropertyMemberDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_propertyMemberDeclaration; }
public PropertyMemberDeclarationContext() { }
public void copyFrom(PropertyMemberDeclarationContext ctx) {
super.copyFrom(ctx);
}
}
public static class PropertyDeclarationExpressionContext extends PropertyMemberDeclarationContext {
public PropertyMemberBaseContext propertyMemberBase() {
return getRuleContext(PropertyMemberBaseContext.class,0);
}
public PropertyNameContext propertyName() {
return getRuleContext(PropertyNameContext.class,0);
}
public TerminalNode SemiColon() { return getToken(TypeScriptParser.SemiColon, 0); }
public TerminalNode Not() { return getToken(TypeScriptParser.Not, 0); }
public TerminalNode QuestionMark() { return getToken(TypeScriptParser.QuestionMark, 0); }
public TypeAnnotationContext typeAnnotation() {
return getRuleContext(TypeAnnotationContext.class,0);
}
public InitializerContext initializer() {
return getRuleContext(InitializerContext.class,0);
}
public PropertyDeclarationExpressionContext(PropertyMemberDeclarationContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterPropertyDeclarationExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitPropertyDeclarationExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitPropertyDeclarationExpression(this);
else return visitor.visitChildren(this);
}
}
public static class MethodDeclarationExpressionContext extends PropertyMemberDeclarationContext {
public PropertyMemberBaseContext propertyMemberBase() {
return getRuleContext(PropertyMemberBaseContext.class,0);
}
public PropertyNameContext propertyName() {
return getRuleContext(PropertyNameContext.class,0);
}
public CallSignatureContext callSignature() {
return getRuleContext(CallSignatureContext.class,0);
}
public TerminalNode SemiColon() { return getToken(TypeScriptParser.SemiColon, 0); }
public TerminalNode OpenBrace() { return getToken(TypeScriptParser.OpenBrace, 0); }
public FunctionBodyContext functionBody() {
return getRuleContext(FunctionBodyContext.class,0);
}
public TerminalNode CloseBrace() { return getToken(TypeScriptParser.CloseBrace, 0); }
public MethodDeclarationExpressionContext(PropertyMemberDeclarationContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterMethodDeclarationExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitMethodDeclarationExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitMethodDeclarationExpression(this);
else return visitor.visitChildren(this);
}
}
public static class GetterSetterDeclarationExpressionContext extends PropertyMemberDeclarationContext {
public PropertyMemberBaseContext propertyMemberBase() {
return getRuleContext(PropertyMemberBaseContext.class,0);
}
public GetAccessorContext getAccessor() {
return getRuleContext(GetAccessorContext.class,0);
}
public SetAccessorContext setAccessor() {
return getRuleContext(SetAccessorContext.class,0);
}
public GetterSetterDeclarationExpressionContext(PropertyMemberDeclarationContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterGetterSetterDeclarationExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitGetterSetterDeclarationExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitGetterSetterDeclarationExpression(this);
else return visitor.visitChildren(this);
}
}
public static class AbstractMemberDeclarationContext extends PropertyMemberDeclarationContext {
public AbstractDeclarationContext abstractDeclaration() {
return getRuleContext(AbstractDeclarationContext.class,0);
}
public AbstractMemberDeclarationContext(PropertyMemberDeclarationContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterAbstractMemberDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitAbstractMemberDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitAbstractMemberDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final PropertyMemberDeclarationContext propertyMemberDeclaration() throws RecognitionException {
PropertyMemberDeclarationContext _localctx = new PropertyMemberDeclarationContext(_ctx, getState());
enterRule(_localctx, 236, RULE_propertyMemberDeclaration);
int _la;
try {
setState(1529);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,189,_ctx) ) {
case 1:
_localctx = new PropertyDeclarationExpressionContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(1497);
propertyMemberBase();
setState(1498);
propertyName();
setState(1500);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Not) {
{
setState(1499);
match(Not);
}
}
setState(1503);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==QuestionMark) {
{
setState(1502);
match(QuestionMark);
}
}
setState(1506);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Colon) {
{
setState(1505);
typeAnnotation();
}
}
setState(1509);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Assign) {
{
setState(1508);
initializer();
}
}
setState(1511);
match(SemiColon);
}
break;
case 2:
_localctx = new MethodDeclarationExpressionContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(1513);
propertyMemberBase();
setState(1514);
propertyName();
setState(1515);
callSignature();
setState(1521);
_errHandler.sync(this);
switch (_input.LA(1)) {
case OpenBrace:
{
{
setState(1516);
match(OpenBrace);
setState(1517);
functionBody();
setState(1518);
match(CloseBrace);
}
}
break;
case SemiColon:
{
setState(1520);
match(SemiColon);
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case 3:
_localctx = new GetterSetterDeclarationExpressionContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(1523);
propertyMemberBase();
setState(1526);
_errHandler.sync(this);
switch (_input.LA(1)) {
case Get:
{
setState(1524);
getAccessor();
}
break;
case Set:
{
setState(1525);
setAccessor();
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case 4:
_localctx = new AbstractMemberDeclarationContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(1528);
abstractDeclaration();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PropertyMemberBaseContext extends ParserRuleContext {
public TerminalNode Async() { return getToken(TypeScriptParser.Async, 0); }
public AccessibilityModifierContext accessibilityModifier() {
return getRuleContext(AccessibilityModifierContext.class,0);
}
public TerminalNode Static() { return getToken(TypeScriptParser.Static, 0); }
public TerminalNode ReadOnly() { return getToken(TypeScriptParser.ReadOnly, 0); }
public PropertyMemberBaseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_propertyMemberBase; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterPropertyMemberBase(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitPropertyMemberBase(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitPropertyMemberBase(this);
else return visitor.visitChildren(this);
}
}
public final PropertyMemberBaseContext propertyMemberBase() throws RecognitionException {
PropertyMemberBaseContext _localctx = new PropertyMemberBaseContext(_ctx, getState());
enterRule(_localctx, 238, RULE_propertyMemberBase);
try {
enterOuterAlt(_localctx, 1);
{
setState(1532);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,190,_ctx) ) {
case 1:
{
setState(1531);
match(Async);
}
break;
}
setState(1535);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,191,_ctx) ) {
case 1:
{
setState(1534);
accessibilityModifier();
}
break;
}
setState(1538);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,192,_ctx) ) {
case 1:
{
setState(1537);
match(Static);
}
break;
}
setState(1541);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,193,_ctx) ) {
case 1:
{
setState(1540);
match(ReadOnly);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class IndexMemberDeclarationContext extends ParserRuleContext {
public IndexSignatureContext indexSignature() {
return getRuleContext(IndexSignatureContext.class,0);
}
public TerminalNode SemiColon() { return getToken(TypeScriptParser.SemiColon, 0); }
public IndexMemberDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_indexMemberDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterIndexMemberDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitIndexMemberDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitIndexMemberDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final IndexMemberDeclarationContext indexMemberDeclaration() throws RecognitionException {
IndexMemberDeclarationContext _localctx = new IndexMemberDeclarationContext(_ctx, getState());
enterRule(_localctx, 240, RULE_indexMemberDeclaration);
try {
enterOuterAlt(_localctx, 1);
{
setState(1543);
indexSignature();
setState(1544);
match(SemiColon);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GeneratorMethodContext extends ParserRuleContext {
public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); }
public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); }
public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); }
public TerminalNode OpenBrace() { return getToken(TypeScriptParser.OpenBrace, 0); }
public FunctionBodyContext functionBody() {
return getRuleContext(FunctionBodyContext.class,0);
}
public TerminalNode CloseBrace() { return getToken(TypeScriptParser.CloseBrace, 0); }
public TerminalNode Multiply() { return getToken(TypeScriptParser.Multiply, 0); }
public FormalParameterListContext formalParameterList() {
return getRuleContext(FormalParameterListContext.class,0);
}
public TypeAnnotationContext typeAnnotation() {
return getRuleContext(TypeAnnotationContext.class,0);
}
public GeneratorMethodContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_generatorMethod; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterGeneratorMethod(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitGeneratorMethod(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitGeneratorMethod(this);
else return visitor.visitChildren(this);
}
}
public final GeneratorMethodContext generatorMethod() throws RecognitionException {
GeneratorMethodContext _localctx = new GeneratorMethodContext(_ctx, getState());
enterRule(_localctx, 242, RULE_generatorMethod);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1547);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Multiply) {
{
setState(1546);
match(Multiply);
}
}
setState(1549);
match(Identifier);
setState(1550);
match(OpenParen);
setState(1552);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << OpenBracket) | (1L << OpenBrace) | (1L << Ellipsis) | (1L << Lodash))) != 0) || ((((_la - 110)) & ~0x3f) == 0 && ((1L << (_la - 110)) & ((1L << (Private - 110)) | (1L << (Public - 110)) | (1L << (Protected - 110)) | (1L << (Any - 110)) | (1L << (TypeAlias - 110)) | (1L << (Require - 110)) | (1L << (Module - 110)) | (1L << (At - 110)) | (1L << (Identifier - 110)))) != 0)) {
{
setState(1551);
formalParameterList();
}
}
setState(1554);
match(CloseParen);
setState(1556);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Colon) {
{
setState(1555);
typeAnnotation();
}
}
setState(1558);
match(OpenBrace);
setState(1559);
functionBody();
setState(1560);
match(CloseBrace);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GeneratorFunctionDeclarationContext extends ParserRuleContext {
public TerminalNode Function_() { return getToken(TypeScriptParser.Function_, 0); }
public TerminalNode Multiply() { return getToken(TypeScriptParser.Multiply, 0); }
public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); }
public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); }
public TerminalNode OpenBrace() { return getToken(TypeScriptParser.OpenBrace, 0); }
public FunctionBodyContext functionBody() {
return getRuleContext(FunctionBodyContext.class,0);
}
public TerminalNode CloseBrace() { return getToken(TypeScriptParser.CloseBrace, 0); }
public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); }
public FormalParameterListContext formalParameterList() {
return getRuleContext(FormalParameterListContext.class,0);
}
public GeneratorFunctionDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_generatorFunctionDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterGeneratorFunctionDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitGeneratorFunctionDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitGeneratorFunctionDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final GeneratorFunctionDeclarationContext generatorFunctionDeclaration() throws RecognitionException {
GeneratorFunctionDeclarationContext _localctx = new GeneratorFunctionDeclarationContext(_ctx, getState());
enterRule(_localctx, 244, RULE_generatorFunctionDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1562);
match(Function_);
setState(1563);
match(Multiply);
setState(1565);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Identifier) {
{
setState(1564);
match(Identifier);
}
}
setState(1567);
match(OpenParen);
setState(1569);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << OpenBracket) | (1L << OpenBrace) | (1L << Ellipsis) | (1L << Lodash))) != 0) || ((((_la - 110)) & ~0x3f) == 0 && ((1L << (_la - 110)) & ((1L << (Private - 110)) | (1L << (Public - 110)) | (1L << (Protected - 110)) | (1L << (Any - 110)) | (1L << (TypeAlias - 110)) | (1L << (Require - 110)) | (1L << (Module - 110)) | (1L << (At - 110)) | (1L << (Identifier - 110)))) != 0)) {
{
setState(1568);
formalParameterList();
}
}
setState(1571);
match(CloseParen);
setState(1572);
match(OpenBrace);
setState(1573);
functionBody();
setState(1574);
match(CloseBrace);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GeneratorBlockContext extends ParserRuleContext {
public TerminalNode OpenBrace() { return getToken(TypeScriptParser.OpenBrace, 0); }
public List generatorDefinition() {
return getRuleContexts(GeneratorDefinitionContext.class);
}
public GeneratorDefinitionContext generatorDefinition(int i) {
return getRuleContext(GeneratorDefinitionContext.class,i);
}
public TerminalNode CloseBrace() { return getToken(TypeScriptParser.CloseBrace, 0); }
public List Comma() { return getTokens(TypeScriptParser.Comma); }
public TerminalNode Comma(int i) {
return getToken(TypeScriptParser.Comma, i);
}
public GeneratorBlockContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_generatorBlock; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterGeneratorBlock(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitGeneratorBlock(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitGeneratorBlock(this);
else return visitor.visitChildren(this);
}
}
public final GeneratorBlockContext generatorBlock() throws RecognitionException {
GeneratorBlockContext _localctx = new GeneratorBlockContext(_ctx, getState());
enterRule(_localctx, 246, RULE_generatorBlock);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1576);
match(OpenBrace);
setState(1577);
generatorDefinition();
setState(1582);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,199,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1578);
match(Comma);
setState(1579);
generatorDefinition();
}
}
}
setState(1584);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,199,_ctx);
}
setState(1586);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Comma) {
{
setState(1585);
match(Comma);
}
}
setState(1588);
match(CloseBrace);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GeneratorDefinitionContext extends ParserRuleContext {
public TerminalNode Multiply() { return getToken(TypeScriptParser.Multiply, 0); }
public IteratorDefinitionContext iteratorDefinition() {
return getRuleContext(IteratorDefinitionContext.class,0);
}
public GeneratorDefinitionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_generatorDefinition; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterGeneratorDefinition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitGeneratorDefinition(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitGeneratorDefinition(this);
else return visitor.visitChildren(this);
}
}
public final GeneratorDefinitionContext generatorDefinition() throws RecognitionException {
GeneratorDefinitionContext _localctx = new GeneratorDefinitionContext(_ctx, getState());
enterRule(_localctx, 248, RULE_generatorDefinition);
try {
enterOuterAlt(_localctx, 1);
{
setState(1590);
match(Multiply);
setState(1591);
iteratorDefinition();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class IteratorBlockContext extends ParserRuleContext {
public TerminalNode OpenBrace() { return getToken(TypeScriptParser.OpenBrace, 0); }
public List iteratorDefinition() {
return getRuleContexts(IteratorDefinitionContext.class);
}
public IteratorDefinitionContext iteratorDefinition(int i) {
return getRuleContext(IteratorDefinitionContext.class,i);
}
public TerminalNode CloseBrace() { return getToken(TypeScriptParser.CloseBrace, 0); }
public List Comma() { return getTokens(TypeScriptParser.Comma); }
public TerminalNode Comma(int i) {
return getToken(TypeScriptParser.Comma, i);
}
public IteratorBlockContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_iteratorBlock; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterIteratorBlock(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitIteratorBlock(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitIteratorBlock(this);
else return visitor.visitChildren(this);
}
}
public final IteratorBlockContext iteratorBlock() throws RecognitionException {
IteratorBlockContext _localctx = new IteratorBlockContext(_ctx, getState());
enterRule(_localctx, 250, RULE_iteratorBlock);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1593);
match(OpenBrace);
setState(1594);
iteratorDefinition();
setState(1599);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,201,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1595);
match(Comma);
setState(1596);
iteratorDefinition();
}
}
}
setState(1601);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,201,_ctx);
}
setState(1603);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Comma) {
{
setState(1602);
match(Comma);
}
}
setState(1605);
match(CloseBrace);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class IteratorDefinitionContext extends ParserRuleContext {
public TerminalNode OpenBracket() { return getToken(TypeScriptParser.OpenBracket, 0); }
public SingleExpressionContext singleExpression() {
return getRuleContext(SingleExpressionContext.class,0);
}
public TerminalNode CloseBracket() { return getToken(TypeScriptParser.CloseBracket, 0); }
public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); }
public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); }
public TerminalNode OpenBrace() { return getToken(TypeScriptParser.OpenBrace, 0); }
public FunctionBodyContext functionBody() {
return getRuleContext(FunctionBodyContext.class,0);
}
public TerminalNode CloseBrace() { return getToken(TypeScriptParser.CloseBrace, 0); }
public FormalParameterListContext formalParameterList() {
return getRuleContext(FormalParameterListContext.class,0);
}
public IteratorDefinitionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_iteratorDefinition; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterIteratorDefinition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitIteratorDefinition(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitIteratorDefinition(this);
else return visitor.visitChildren(this);
}
}
public final IteratorDefinitionContext iteratorDefinition() throws RecognitionException {
IteratorDefinitionContext _localctx = new IteratorDefinitionContext(_ctx, getState());
enterRule(_localctx, 252, RULE_iteratorDefinition);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1607);
match(OpenBracket);
setState(1608);
singleExpression(0);
setState(1609);
match(CloseBracket);
setState(1610);
match(OpenParen);
setState(1612);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << OpenBracket) | (1L << OpenBrace) | (1L << Ellipsis) | (1L << Lodash))) != 0) || ((((_la - 110)) & ~0x3f) == 0 && ((1L << (_la - 110)) & ((1L << (Private - 110)) | (1L << (Public - 110)) | (1L << (Protected - 110)) | (1L << (Any - 110)) | (1L << (TypeAlias - 110)) | (1L << (Require - 110)) | (1L << (Module - 110)) | (1L << (At - 110)) | (1L << (Identifier - 110)))) != 0)) {
{
setState(1611);
formalParameterList();
}
}
setState(1614);
match(CloseParen);
setState(1615);
match(OpenBrace);
setState(1616);
functionBody();
setState(1617);
match(CloseBrace);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FormalParameterListContext extends ParserRuleContext {
public List formalParameterArg() {
return getRuleContexts(FormalParameterArgContext.class);
}
public FormalParameterArgContext formalParameterArg(int i) {
return getRuleContext(FormalParameterArgContext.class,i);
}
public List Comma() { return getTokens(TypeScriptParser.Comma); }
public TerminalNode Comma(int i) {
return getToken(TypeScriptParser.Comma, i);
}
public LastFormalParameterArgContext lastFormalParameterArg() {
return getRuleContext(LastFormalParameterArgContext.class,0);
}
public FormalParameterListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_formalParameterList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterFormalParameterList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitFormalParameterList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitFormalParameterList(this);
else return visitor.visitChildren(this);
}
}
public final FormalParameterListContext formalParameterList() throws RecognitionException {
FormalParameterListContext _localctx = new FormalParameterListContext(_ctx, getState());
enterRule(_localctx, 254, RULE_formalParameterList);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1619);
formalParameterArg();
setState(1624);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,204,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1620);
match(Comma);
setState(1621);
formalParameterArg();
}
}
}
setState(1626);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,204,_ctx);
}
setState(1629);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,205,_ctx) ) {
case 1:
{
setState(1627);
match(Comma);
setState(1628);
lastFormalParameterArg();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FormalParameterArgContext extends ParserRuleContext {
public IdentifierOrKeyWordContext identifierOrKeyWord() {
return getRuleContext(IdentifierOrKeyWordContext.class,0);
}
public DecoratorContext decorator() {
return getRuleContext(DecoratorContext.class,0);
}
public AccessibilityModifierContext accessibilityModifier() {
return getRuleContext(AccessibilityModifierContext.class,0);
}
public TerminalNode QuestionMark() { return getToken(TypeScriptParser.QuestionMark, 0); }
public TypeAnnotationContext typeAnnotation() {
return getRuleContext(TypeAnnotationContext.class,0);
}
public TerminalNode Assign() { return getToken(TypeScriptParser.Assign, 0); }
public SingleExpressionContext singleExpression() {
return getRuleContext(SingleExpressionContext.class,0);
}
public LastFormalParameterArgContext lastFormalParameterArg() {
return getRuleContext(LastFormalParameterArgContext.class,0);
}
public ArrayLiteralContext arrayLiteral() {
return getRuleContext(ArrayLiteralContext.class,0);
}
public List objectLiteral() {
return getRuleContexts(ObjectLiteralContext.class);
}
public ObjectLiteralContext objectLiteral(int i) {
return getRuleContext(ObjectLiteralContext.class,i);
}
public TerminalNode Colon() { return getToken(TypeScriptParser.Colon, 0); }
public FormalParameterListContext formalParameterList() {
return getRuleContext(FormalParameterListContext.class,0);
}
public List Comma() { return getTokens(TypeScriptParser.Comma); }
public TerminalNode Comma(int i) {
return getToken(TypeScriptParser.Comma, i);
}
public FormalParameterArgContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_formalParameterArg; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterFormalParameterArg(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitFormalParameterArg(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitFormalParameterArg(this);
else return visitor.visitChildren(this);
}
}
public final FormalParameterArgContext formalParameterArg() throws RecognitionException {
FormalParameterArgContext _localctx = new FormalParameterArgContext(_ctx, getState());
enterRule(_localctx, 256, RULE_formalParameterArg);
int _la;
try {
int _alt;
setState(1663);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,213,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1632);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==At) {
{
setState(1631);
decorator();
}
}
setState(1635);
_errHandler.sync(this);
_la = _input.LA(1);
if (((((_la - 110)) & ~0x3f) == 0 && ((1L << (_la - 110)) & ((1L << (Private - 110)) | (1L << (Public - 110)) | (1L << (Protected - 110)))) != 0)) {
{
setState(1634);
accessibilityModifier();
}
}
setState(1637);
identifierOrKeyWord();
setState(1639);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==QuestionMark) {
{
setState(1638);
match(QuestionMark);
}
}
setState(1642);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Colon) {
{
setState(1641);
typeAnnotation();
}
}
setState(1646);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Assign) {
{
setState(1644);
match(Assign);
setState(1645);
singleExpression(0);
}
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1648);
lastFormalParameterArg();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1649);
arrayLiteral();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(1650);
objectLiteral();
setState(1653);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Colon) {
{
setState(1651);
match(Colon);
setState(1652);
formalParameterList();
}
}
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(1655);
objectLiteral();
setState(1660);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,212,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1656);
match(Comma);
setState(1657);
objectLiteral();
}
}
}
setState(1662);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,212,_ctx);
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LastFormalParameterArgContext extends ParserRuleContext {
public TerminalNode Ellipsis() { return getToken(TypeScriptParser.Ellipsis, 0); }
public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); }
public LastFormalParameterArgContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_lastFormalParameterArg; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterLastFormalParameterArg(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitLastFormalParameterArg(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitLastFormalParameterArg(this);
else return visitor.visitChildren(this);
}
}
public final LastFormalParameterArgContext lastFormalParameterArg() throws RecognitionException {
LastFormalParameterArgContext _localctx = new LastFormalParameterArgContext(_ctx, getState());
enterRule(_localctx, 258, RULE_lastFormalParameterArg);
try {
enterOuterAlt(_localctx, 1);
{
setState(1665);
match(Ellipsis);
setState(1666);
match(Identifier);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FunctionBodyContext extends ParserRuleContext {
public SourceElementsContext sourceElements() {
return getRuleContext(SourceElementsContext.class,0);
}
public FunctionBodyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_functionBody; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterFunctionBody(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitFunctionBody(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitFunctionBody(this);
else return visitor.visitChildren(this);
}
}
public final FunctionBodyContext functionBody() throws RecognitionException {
FunctionBodyContext _localctx = new FunctionBodyContext(_ctx, getState());
enterRule(_localctx, 260, RULE_functionBody);
try {
enterOuterAlt(_localctx, 1);
{
setState(1669);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,214,_ctx) ) {
case 1:
{
setState(1668);
sourceElements();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SourceElementsContext extends ParserRuleContext {
public List sourceElement() {
return getRuleContexts(SourceElementContext.class);
}
public SourceElementContext sourceElement(int i) {
return getRuleContext(SourceElementContext.class,i);
}
public SourceElementsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_sourceElements; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterSourceElements(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitSourceElements(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitSourceElements(this);
else return visitor.visitChildren(this);
}
}
public final SourceElementsContext sourceElements() throws RecognitionException {
SourceElementsContext _localctx = new SourceElementsContext(_ctx, getState());
enterRule(_localctx, 262, RULE_sourceElements);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1672);
_errHandler.sync(this);
_alt = 1;
do {
switch (_alt) {
case 1:
{
{
setState(1671);
sourceElement();
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(1674);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,215,_ctx);
} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ArrayLiteralContext extends ParserRuleContext {
public TerminalNode OpenBracket() { return getToken(TypeScriptParser.OpenBracket, 0); }
public TerminalNode CloseBracket() { return getToken(TypeScriptParser.CloseBracket, 0); }
public ElementListContext elementList() {
return getRuleContext(ElementListContext.class,0);
}
public ArrayLiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_arrayLiteral; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterArrayLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitArrayLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitArrayLiteral(this);
else return visitor.visitChildren(this);
}
}
public final ArrayLiteralContext arrayLiteral() throws RecognitionException {
ArrayLiteralContext _localctx = new ArrayLiteralContext(_ctx, getState());
enterRule(_localctx, 264, RULE_arrayLiteral);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
{
setState(1676);
match(OpenBracket);
setState(1678);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << RegularExpressionLiteral) | (1L << OpenBracket) | (1L << OpenParen) | (1L << OpenBrace) | (1L << Ellipsis) | (1L << PlusPlus) | (1L << MinusMinus) | (1L << Plus) | (1L << Minus) | (1L << BitNot) | (1L << Not) | (1L << LessThan) | (1L << Lodash) | (1L << Dollar) | (1L << NullLiteral) | (1L << BooleanLiteral) | (1L << DecimalLiteral))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (HexIntegerLiteral - 64)) | (1L << (OctalIntegerLiteral - 64)) | (1L << (OctalIntegerLiteral2 - 64)) | (1L << (BinaryIntegerLiteral - 64)) | (1L << (Break - 64)) | (1L << (Do - 64)) | (1L << (Instanceof - 64)) | (1L << (Typeof - 64)) | (1L << (Keyof - 64)) | (1L << (Case - 64)) | (1L << (Else - 64)) | (1L << (New - 64)) | (1L << (Var - 64)) | (1L << (Catch - 64)) | (1L << (Finally - 64)) | (1L << (Return - 64)) | (1L << (Void - 64)) | (1L << (Continue - 64)) | (1L << (For - 64)) | (1L << (Switch - 64)) | (1L << (While - 64)) | (1L << (Debugger - 64)) | (1L << (Function_ - 64)) | (1L << (This - 64)) | (1L << (With - 64)) | (1L << (If - 64)) | (1L << (Throw - 64)) | (1L << (Delete - 64)) | (1L << (In - 64)) | (1L << (Try - 64)) | (1L << (From - 64)) | (1L << (ReadOnly - 64)) | (1L << (Async - 64)) | (1L << (Await - 64)) | (1L << (Class - 64)) | (1L << (Enum - 64)) | (1L << (Extends - 64)) | (1L << (Super - 64)) | (1L << (Const - 64)) | (1L << (Export - 64)) | (1L << (Import - 64)) | (1L << (Implements - 64)) | (1L << (Let - 64)) | (1L << (Private - 64)) | (1L << (Public - 64)) | (1L << (Interface - 64)) | (1L << (Package - 64)) | (1L << (Protected - 64)) | (1L << (Static - 64)) | (1L << (Yield - 64)) | (1L << (Any - 64)) | (1L << (Number - 64)) | (1L << (Boolean - 64)) | (1L << (String - 64)) | (1L << (TypeAlias - 64)) | (1L << (Get - 64)) | (1L << (Set - 64)) | (1L << (Namespace - 64)) | (1L << (Require - 64)))) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & ((1L << (Module - 128)) | (1L << (Undefined - 128)) | (1L << (Is - 128)) | (1L << (Identifier - 128)) | (1L << (StringLiteral - 128)) | (1L << (BackTick - 128)))) != 0)) {
{
setState(1677);
elementList();
}
}
setState(1680);
match(CloseBracket);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ElementListContext extends ParserRuleContext {
public List arrayElement() {
return getRuleContexts(ArrayElementContext.class);
}
public ArrayElementContext arrayElement(int i) {
return getRuleContext(ArrayElementContext.class,i);
}
public List Comma() { return getTokens(TypeScriptParser.Comma); }
public TerminalNode Comma(int i) {
return getToken(TypeScriptParser.Comma, i);
}
public ElementListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_elementList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterElementList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitElementList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitElementList(this);
else return visitor.visitChildren(this);
}
}
public final ElementListContext elementList() throws RecognitionException {
ElementListContext _localctx = new ElementListContext(_ctx, getState());
enterRule(_localctx, 266, RULE_elementList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1682);
arrayElement();
setState(1691);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==Comma) {
{
{
setState(1684);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(1683);
match(Comma);
}
}
setState(1686);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==Comma );
setState(1688);
arrayElement();
}
}
setState(1693);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ArrayElementContext extends ParserRuleContext {
public SingleExpressionContext singleExpression() {
return getRuleContext(SingleExpressionContext.class,0);
}
public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); }
public TerminalNode Ellipsis() { return getToken(TypeScriptParser.Ellipsis, 0); }
public TerminalNode Comma() { return getToken(TypeScriptParser.Comma, 0); }
public ArrayElementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_arrayElement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterArrayElement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitArrayElement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitArrayElement(this);
else return visitor.visitChildren(this);
}
}
public final ArrayElementContext arrayElement() throws RecognitionException {
ArrayElementContext _localctx = new ArrayElementContext(_ctx, getState());
enterRule(_localctx, 268, RULE_arrayElement);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1695);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Ellipsis) {
{
setState(1694);
match(Ellipsis);
}
}
setState(1699);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,220,_ctx) ) {
case 1:
{
setState(1697);
singleExpression(0);
}
break;
case 2:
{
setState(1698);
match(Identifier);
}
break;
}
setState(1702);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,221,_ctx) ) {
case 1:
{
setState(1701);
match(Comma);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ObjectLiteralContext extends ParserRuleContext {
public TerminalNode OpenBrace() { return getToken(TypeScriptParser.OpenBrace, 0); }
public TerminalNode CloseBrace() { return getToken(TypeScriptParser.CloseBrace, 0); }
public List propertyAssignment() {
return getRuleContexts(PropertyAssignmentContext.class);
}
public PropertyAssignmentContext propertyAssignment(int i) {
return getRuleContext(PropertyAssignmentContext.class,i);
}
public List Comma() { return getTokens(TypeScriptParser.Comma); }
public TerminalNode Comma(int i) {
return getToken(TypeScriptParser.Comma, i);
}
public ObjectLiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_objectLiteral; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterObjectLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitObjectLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitObjectLiteral(this);
else return visitor.visitChildren(this);
}
}
public final ObjectLiteralContext objectLiteral() throws RecognitionException {
ObjectLiteralContext _localctx = new ObjectLiteralContext(_ctx, getState());
enterRule(_localctx, 270, RULE_objectLiteral);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1704);
match(OpenBrace);
setState(1716);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << OpenBracket) | (1L << Ellipsis) | (1L << Multiply) | (1L << Lodash) | (1L << Dollar) | (1L << NullLiteral) | (1L << BooleanLiteral) | (1L << DecimalLiteral))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (HexIntegerLiteral - 64)) | (1L << (OctalIntegerLiteral - 64)) | (1L << (OctalIntegerLiteral2 - 64)) | (1L << (BinaryIntegerLiteral - 64)) | (1L << (Break - 64)) | (1L << (Do - 64)) | (1L << (Instanceof - 64)) | (1L << (Typeof - 64)) | (1L << (Keyof - 64)) | (1L << (Case - 64)) | (1L << (Else - 64)) | (1L << (New - 64)) | (1L << (Var - 64)) | (1L << (Catch - 64)) | (1L << (Finally - 64)) | (1L << (Return - 64)) | (1L << (Void - 64)) | (1L << (Continue - 64)) | (1L << (For - 64)) | (1L << (Switch - 64)) | (1L << (While - 64)) | (1L << (Debugger - 64)) | (1L << (Function_ - 64)) | (1L << (This - 64)) | (1L << (With - 64)) | (1L << (Default - 64)) | (1L << (If - 64)) | (1L << (Throw - 64)) | (1L << (Delete - 64)) | (1L << (In - 64)) | (1L << (Try - 64)) | (1L << (From - 64)) | (1L << (ReadOnly - 64)) | (1L << (Async - 64)) | (1L << (Class - 64)) | (1L << (Enum - 64)) | (1L << (Extends - 64)) | (1L << (Super - 64)) | (1L << (Const - 64)) | (1L << (Export - 64)) | (1L << (Import - 64)) | (1L << (Implements - 64)) | (1L << (Let - 64)) | (1L << (Private - 64)) | (1L << (Public - 64)) | (1L << (Interface - 64)) | (1L << (Package - 64)) | (1L << (Protected - 64)) | (1L << (Static - 64)) | (1L << (Yield - 64)) | (1L << (Any - 64)) | (1L << (Number - 64)) | (1L << (Boolean - 64)) | (1L << (String - 64)) | (1L << (Symbol - 64)) | (1L << (TypeAlias - 64)) | (1L << (Get - 64)) | (1L << (Set - 64)) | (1L << (Namespace - 64)) | (1L << (Require - 64)))) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & ((1L << (Module - 128)) | (1L << (Undefined - 128)) | (1L << (Is - 128)) | (1L << (Identifier - 128)) | (1L << (StringLiteral - 128)))) != 0)) {
{
setState(1705);
propertyAssignment();
setState(1710);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,222,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1706);
match(Comma);
setState(1707);
propertyAssignment();
}
}
}
setState(1712);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,222,_ctx);
}
setState(1714);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Comma) {
{
setState(1713);
match(Comma);
}
}
}
}
setState(1718);
match(CloseBrace);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PropertyAssignmentContext extends ParserRuleContext {
public PropertyAssignmentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_propertyAssignment; }
public PropertyAssignmentContext() { }
public void copyFrom(PropertyAssignmentContext ctx) {
super.copyFrom(ctx);
}
}
public static class PropertyExpressionAssignmentContext extends PropertyAssignmentContext {
public PropertyNameContext propertyName() {
return getRuleContext(PropertyNameContext.class,0);
}
public SingleExpressionContext singleExpression() {
return getRuleContext(SingleExpressionContext.class,0);
}
public TerminalNode Colon() { return getToken(TypeScriptParser.Colon, 0); }
public TerminalNode Assign() { return getToken(TypeScriptParser.Assign, 0); }
public PropertyExpressionAssignmentContext(PropertyAssignmentContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterPropertyExpressionAssignment(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitPropertyExpressionAssignment(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitPropertyExpressionAssignment(this);
else return visitor.visitChildren(this);
}
}
public static class ComputedPropertyExpressionAssignmentContext extends PropertyAssignmentContext {
public TerminalNode OpenBracket() { return getToken(TypeScriptParser.OpenBracket, 0); }
public List singleExpression() {
return getRuleContexts(SingleExpressionContext.class);
}
public SingleExpressionContext singleExpression(int i) {
return getRuleContext(SingleExpressionContext.class,i);
}
public TerminalNode CloseBracket() { return getToken(TypeScriptParser.CloseBracket, 0); }
public TerminalNode Colon() { return getToken(TypeScriptParser.Colon, 0); }
public ComputedPropertyExpressionAssignmentContext(PropertyAssignmentContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterComputedPropertyExpressionAssignment(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitComputedPropertyExpressionAssignment(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitComputedPropertyExpressionAssignment(this);
else return visitor.visitChildren(this);
}
}
public static class PropertyShorthandContext extends PropertyAssignmentContext {
public IdentifierOrKeyWordContext identifierOrKeyWord() {
return getRuleContext(IdentifierOrKeyWordContext.class,0);
}
public DefaultKeyWordContext defaultKeyWord() {
return getRuleContext(DefaultKeyWordContext.class,0);
}
public PropertyShorthandContext(PropertyAssignmentContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterPropertyShorthand(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitPropertyShorthand(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitPropertyShorthand(this);
else return visitor.visitChildren(this);
}
}
public static class PropertySetterContext extends PropertyAssignmentContext {
public SetAccessorContext setAccessor() {
return getRuleContext(SetAccessorContext.class,0);
}
public PropertySetterContext(PropertyAssignmentContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterPropertySetter(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitPropertySetter(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitPropertySetter(this);
else return visitor.visitChildren(this);
}
}
public static class PropertyGetterContext extends PropertyAssignmentContext {
public GetAccessorContext getAccessor() {
return getRuleContext(GetAccessorContext.class,0);
}
public PropertyGetterContext(PropertyAssignmentContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterPropertyGetter(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitPropertyGetter(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitPropertyGetter(this);
else return visitor.visitChildren(this);
}
}
public static class RestParameterInObjectContext extends PropertyAssignmentContext {
public RestParameterContext restParameter() {
return getRuleContext(RestParameterContext.class,0);
}
public RestParameterInObjectContext(PropertyAssignmentContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterRestParameterInObject(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitRestParameterInObject(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitRestParameterInObject(this);
else return visitor.visitChildren(this);
}
}
public static class MethodPropertyContext extends PropertyAssignmentContext {
public GeneratorMethodContext generatorMethod() {
return getRuleContext(GeneratorMethodContext.class,0);
}
public MethodPropertyContext(PropertyAssignmentContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterMethodProperty(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitMethodProperty(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitMethodProperty(this);
else return visitor.visitChildren(this);
}
}
public final PropertyAssignmentContext propertyAssignment() throws RecognitionException {
PropertyAssignmentContext _localctx = new PropertyAssignmentContext(_ctx, getState());
enterRule(_localctx, 272, RULE_propertyAssignment);
int _la;
try {
setState(1736);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,225,_ctx) ) {
case 1:
_localctx = new PropertyExpressionAssignmentContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(1720);
propertyName();
setState(1721);
_la = _input.LA(1);
if ( !(_la==Assign || _la==Colon) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1722);
singleExpression(0);
}
break;
case 2:
_localctx = new ComputedPropertyExpressionAssignmentContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(1724);
match(OpenBracket);
setState(1725);
singleExpression(0);
setState(1726);
match(CloseBracket);
setState(1727);
match(Colon);
setState(1728);
singleExpression(0);
}
break;
case 3:
_localctx = new PropertyGetterContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(1730);
getAccessor();
}
break;
case 4:
_localctx = new PropertySetterContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(1731);
setAccessor();
}
break;
case 5:
_localctx = new MethodPropertyContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(1732);
generatorMethod();
}
break;
case 6:
_localctx = new PropertyShorthandContext(_localctx);
enterOuterAlt(_localctx, 6);
{
setState(1733);
identifierOrKeyWord();
}
break;
case 7:
_localctx = new PropertyShorthandContext(_localctx);
enterOuterAlt(_localctx, 7);
{
setState(1734);
defaultKeyWord();
}
break;
case 8:
_localctx = new RestParameterInObjectContext(_localctx);
enterOuterAlt(_localctx, 8);
{
setState(1735);
restParameter();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GetAccessorContext extends ParserRuleContext {
public GetterContext getter() {
return getRuleContext(GetterContext.class,0);
}
public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); }
public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); }
public TerminalNode OpenBrace() { return getToken(TypeScriptParser.OpenBrace, 0); }
public FunctionBodyContext functionBody() {
return getRuleContext(FunctionBodyContext.class,0);
}
public TerminalNode CloseBrace() { return getToken(TypeScriptParser.CloseBrace, 0); }
public TypeAnnotationContext typeAnnotation() {
return getRuleContext(TypeAnnotationContext.class,0);
}
public GetAccessorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_getAccessor; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterGetAccessor(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitGetAccessor(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitGetAccessor(this);
else return visitor.visitChildren(this);
}
}
public final GetAccessorContext getAccessor() throws RecognitionException {
GetAccessorContext _localctx = new GetAccessorContext(_ctx, getState());
enterRule(_localctx, 274, RULE_getAccessor);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1738);
getter();
setState(1739);
match(OpenParen);
setState(1740);
match(CloseParen);
setState(1742);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Colon) {
{
setState(1741);
typeAnnotation();
}
}
setState(1744);
match(OpenBrace);
setState(1745);
functionBody();
setState(1746);
match(CloseBrace);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SetAccessorContext extends ParserRuleContext {
public SetterContext setter() {
return getRuleContext(SetterContext.class,0);
}
public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); }
public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); }
public TerminalNode OpenBrace() { return getToken(TypeScriptParser.OpenBrace, 0); }
public FunctionBodyContext functionBody() {
return getRuleContext(FunctionBodyContext.class,0);
}
public TerminalNode CloseBrace() { return getToken(TypeScriptParser.CloseBrace, 0); }
public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); }
public BindingPatternContext bindingPattern() {
return getRuleContext(BindingPatternContext.class,0);
}
public TypeAnnotationContext typeAnnotation() {
return getRuleContext(TypeAnnotationContext.class,0);
}
public SetAccessorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_setAccessor; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterSetAccessor(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitSetAccessor(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitSetAccessor(this);
else return visitor.visitChildren(this);
}
}
public final SetAccessorContext setAccessor() throws RecognitionException {
SetAccessorContext _localctx = new SetAccessorContext(_ctx, getState());
enterRule(_localctx, 276, RULE_setAccessor);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1748);
setter();
setState(1749);
match(OpenParen);
setState(1752);
_errHandler.sync(this);
switch (_input.LA(1)) {
case Identifier:
{
setState(1750);
match(Identifier);
}
break;
case OpenBracket:
case OpenBrace:
{
setState(1751);
bindingPattern();
}
break;
default:
throw new NoViableAltException(this);
}
setState(1755);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Colon) {
{
setState(1754);
typeAnnotation();
}
}
setState(1757);
match(CloseParen);
setState(1758);
match(OpenBrace);
setState(1759);
functionBody();
setState(1760);
match(CloseBrace);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PropertyNameContext extends ParserRuleContext {
public IdentifierNameContext identifierName() {
return getRuleContext(IdentifierNameContext.class,0);
}
public TerminalNode StringLiteral() { return getToken(TypeScriptParser.StringLiteral, 0); }
public NumericLiteralContext numericLiteral() {
return getRuleContext(NumericLiteralContext.class,0);
}
public KeywordContext keyword() {
return getRuleContext(KeywordContext.class,0);
}
public TerminalNode Default() { return getToken(TypeScriptParser.Default, 0); }
public PredefinedTypeContext predefinedType() {
return getRuleContext(PredefinedTypeContext.class,0);
}
public PropertyNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_propertyName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterPropertyName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitPropertyName(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor)visitor).visitPropertyName(this);
else return visitor.visitChildren(this);
}
}
public final PropertyNameContext propertyName() throws RecognitionException {
PropertyNameContext _localctx = new PropertyNameContext(_ctx, getState());
enterRule(_localctx, 278, RULE_propertyName);
try {
setState(1768);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,229,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1762);
identifierName();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1763);
match(StringLiteral);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1764);
numericLiteral();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(1765);
keyword();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(1766);
match(Default);
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(1767);
predefinedType();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ArgumentsContext extends ParserRuleContext {
public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); }
public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); }
public ArgumentListContext argumentList() {
return getRuleContext(ArgumentListContext.class,0);
}
public TerminalNode Comma() { return getToken(TypeScriptParser.Comma, 0); }
public ArgumentsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_arguments; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterArguments(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitArguments(this);
}
@Override
public 