chapi.ast.antlr.RustParser Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of chapi-ast-rust Show documentation
Show all versions of chapi-ast-rust Show documentation
Chapi is A common language meta information convertor, convert different languages to same meta-data model
The newest version!
// Generated from RustParser.g4 by ANTLR 4.13.1
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", "CheckReturnValue"})
public class RustParser extends RustParserBase {
static { RuntimeMetaData.checkVersion("4.13.1", RuntimeMetaData.VERSION); }
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
KW_AS=1, KW_BREAK=2, KW_CONST=3, KW_CONTINUE=4, KW_CRATE=5, KW_ELSE=6,
KW_ENUM=7, KW_EXTERN=8, KW_FALSE=9, KW_FN=10, KW_FOR=11, KW_IF=12, KW_IMPL=13,
KW_IN=14, KW_LET=15, KW_LOOP=16, KW_MATCH=17, KW_MOD=18, KW_MOVE=19, KW_MUT=20,
KW_PUB=21, KW_REF=22, KW_RETURN=23, KW_SELFVALUE=24, KW_SELFTYPE=25, KW_STATIC=26,
KW_STRUCT=27, KW_SUPER=28, KW_TRAIT=29, KW_TRUE=30, KW_TYPE=31, KW_UNSAFE=32,
KW_USE=33, KW_WHERE=34, KW_WHILE=35, KW_ASYNC=36, KW_AWAIT=37, KW_DYN=38,
KW_ABSTRACT=39, KW_BECOME=40, KW_BOX=41, KW_DO=42, KW_FINAL=43, KW_MACRO=44,
KW_OVERRIDE=45, KW_PRIV=46, KW_TYPEOF=47, KW_UNSIZED=48, KW_VIRTUAL=49,
KW_YIELD=50, KW_TRY=51, KW_UNION=52, KW_STATICLIFETIME=53, KW_MACRORULES=54,
KW_UNDERLINELIFETIME=55, KW_DOLLARCRATE=56, NON_KEYWORD_IDENTIFIER=57,
RAW_IDENTIFIER=58, LINE_COMMENT=59, BLOCK_COMMENT=60, INNER_LINE_DOC=61,
INNER_BLOCK_DOC=62, OUTER_LINE_DOC=63, OUTER_BLOCK_DOC=64, BLOCK_COMMENT_OR_DOC=65,
SHEBANG=66, WHITESPACE=67, NEWLINE=68, CHAR_LITERAL=69, STRING_LITERAL=70,
RAW_STRING_LITERAL=71, BYTE_LITERAL=72, BYTE_STRING_LITERAL=73, RAW_BYTE_STRING_LITERAL=74,
INTEGER_LITERAL=75, DEC_LITERAL=76, HEX_LITERAL=77, OCT_LITERAL=78, BIN_LITERAL=79,
FLOAT_LITERAL=80, LIFETIME_OR_LABEL=81, PLUS=82, MINUS=83, STAR=84, SLASH=85,
PERCENT=86, CARET=87, NOT=88, AND=89, OR=90, ANDAND=91, OROR=92, PLUSEQ=93,
MINUSEQ=94, STAREQ=95, SLASHEQ=96, PERCENTEQ=97, CARETEQ=98, ANDEQ=99,
OREQ=100, SHLEQ=101, SHREQ=102, EQ=103, EQEQ=104, NE=105, GT=106, LT=107,
GE=108, LE=109, AT=110, UNDERSCORE=111, DOT=112, DOTDOT=113, DOTDOTDOT=114,
DOTDOTEQ=115, COMMA=116, SEMI=117, COLON=118, PATHSEP=119, RARROW=120,
FATARROW=121, POUND=122, DOLLAR=123, QUESTION=124, LCURLYBRACE=125, RCURLYBRACE=126,
LSQUAREBRACKET=127, RSQUAREBRACKET=128, LPAREN=129, RPAREN=130;
public static final int
RULE_crate = 0, RULE_macroInvocation = 1, RULE_delimTokenTree = 2, RULE_tokenTree = 3,
RULE_tokenTreeToken = 4, RULE_macroInvocationSemi = 5, RULE_macroRulesDefinition = 6,
RULE_macroRulesDef = 7, RULE_macroRules = 8, RULE_macroRule = 9, RULE_macroMatcher = 10,
RULE_macroMatch = 11, RULE_macroMatchToken = 12, RULE_macroFragSpec = 13,
RULE_macroRepSep = 14, RULE_macroRepOp = 15, RULE_macroTranscriber = 16,
RULE_item = 17, RULE_visItem = 18, RULE_macroItem = 19, RULE_module = 20,
RULE_externCrate = 21, RULE_crateRef = 22, RULE_asClause = 23, RULE_useDeclaration = 24,
RULE_useTree = 25, RULE_function_ = 26, RULE_functionQualifiers = 27,
RULE_abi = 28, RULE_functionParameters = 29, RULE_selfParam = 30, RULE_shorthandSelf = 31,
RULE_typedSelf = 32, RULE_functionParam = 33, RULE_functionParamPattern = 34,
RULE_functionReturnType = 35, RULE_typeAlias = 36, RULE_struct_ = 37,
RULE_structStruct = 38, RULE_tupleStruct = 39, RULE_structFields = 40,
RULE_structField = 41, RULE_tupleFields = 42, RULE_tupleField = 43, RULE_enumeration = 44,
RULE_enumItems = 45, RULE_enumItem = 46, RULE_enumItemTuple = 47, RULE_enumItemStruct = 48,
RULE_enumItemDiscriminant = 49, RULE_union_ = 50, RULE_constantItem = 51,
RULE_staticItem = 52, RULE_trait_ = 53, RULE_implementation = 54, RULE_inherentImpl = 55,
RULE_traitImpl = 56, RULE_externBlock = 57, RULE_externalItem = 58, RULE_genericParams = 59,
RULE_genericParam = 60, RULE_lifetimeParam = 61, RULE_typeParam = 62,
RULE_constParam = 63, RULE_whereClause = 64, RULE_whereClauseItem = 65,
RULE_lifetimeWhereClauseItem = 66, RULE_typeBoundWhereClauseItem = 67,
RULE_forLifetimes = 68, RULE_associatedItem = 69, RULE_innerAttribute = 70,
RULE_outerAttribute = 71, RULE_attr = 72, RULE_attrInput = 73, RULE_statement = 74,
RULE_letStatement = 75, RULE_expressionStatement = 76, RULE_expression = 77,
RULE_comparisonOperator = 78, RULE_compoundAssignOperator = 79, RULE_expressionWithBlock = 80,
RULE_literalExpression = 81, RULE_pathExpression = 82, RULE_blockExpression = 83,
RULE_statements = 84, RULE_asyncBlockExpression = 85, RULE_unsafeBlockExpression = 86,
RULE_arrayElements = 87, RULE_tupleElements = 88, RULE_tupleIndex = 89,
RULE_structExpression = 90, RULE_structExprStruct = 91, RULE_structExprFields = 92,
RULE_structExprField = 93, RULE_structBase = 94, RULE_structExprTuple = 95,
RULE_structExprUnit = 96, RULE_enumerationVariantExpression = 97, RULE_enumExprStruct = 98,
RULE_enumExprFields = 99, RULE_enumExprField = 100, RULE_enumExprTuple = 101,
RULE_enumExprFieldless = 102, RULE_callParams = 103, RULE_closureExpression = 104,
RULE_closureParameters = 105, RULE_closureParam = 106, RULE_loopExpression = 107,
RULE_infiniteLoopExpression = 108, RULE_predicateLoopExpression = 109,
RULE_predicatePatternLoopExpression = 110, RULE_iteratorLoopExpression = 111,
RULE_loopLabel = 112, RULE_ifExpression = 113, RULE_ifLetExpression = 114,
RULE_matchExpression = 115, RULE_matchArms = 116, RULE_matchArmExpression = 117,
RULE_matchArm = 118, RULE_matchArmGuard = 119, RULE_pattern = 120, RULE_patternNoTopAlt = 121,
RULE_patternWithoutRange = 122, RULE_literalPattern = 123, RULE_identifierPattern = 124,
RULE_wildcardPattern = 125, RULE_restPattern = 126, RULE_rangePattern = 127,
RULE_rangePatternBound = 128, RULE_referencePattern = 129, RULE_structPattern = 130,
RULE_structPatternElements = 131, RULE_structPatternFields = 132, RULE_structPatternField = 133,
RULE_structPatternEtCetera = 134, RULE_tupleStructPattern = 135, RULE_tupleStructItems = 136,
RULE_tuplePattern = 137, RULE_tuplePatternItems = 138, RULE_groupedPattern = 139,
RULE_slicePattern = 140, RULE_slicePatternItems = 141, RULE_pathPattern = 142,
RULE_type_ = 143, RULE_typeNoBounds = 144, RULE_parenthesizedType = 145,
RULE_neverType = 146, RULE_tupleType = 147, RULE_arrayType = 148, RULE_sliceType = 149,
RULE_referenceType = 150, RULE_rawPointerType = 151, RULE_bareFunctionType = 152,
RULE_functionTypeQualifiers = 153, RULE_bareFunctionReturnType = 154,
RULE_functionParametersMaybeNamedVariadic = 155, RULE_maybeNamedFunctionParameters = 156,
RULE_maybeNamedParam = 157, RULE_maybeNamedFunctionParametersVariadic = 158,
RULE_traitObjectType = 159, RULE_traitObjectTypeOneBound = 160, RULE_implTraitType = 161,
RULE_implTraitTypeOneBound = 162, RULE_inferredType = 163, RULE_typeParamBounds = 164,
RULE_typeParamBound = 165, RULE_traitBound = 166, RULE_lifetimeBounds = 167,
RULE_lifetime = 168, RULE_simplePath = 169, RULE_simplePathSegment = 170,
RULE_pathInExpression = 171, RULE_pathExprSegment = 172, RULE_pathIdentSegment = 173,
RULE_genericArgs = 174, RULE_genericArg = 175, RULE_genericArgsConst = 176,
RULE_genericArgsLifetimes = 177, RULE_genericArgsTypes = 178, RULE_genericArgsBindings = 179,
RULE_genericArgsBinding = 180, RULE_qualifiedPathInExpression = 181, RULE_qualifiedPathType = 182,
RULE_qualifiedPathInType = 183, RULE_typePath = 184, RULE_typePathSegment = 185,
RULE_typePathFn = 186, RULE_typePathInputs = 187, RULE_visibility = 188,
RULE_identifier = 189, RULE_keyword = 190, RULE_macroIdentifierLikeToken = 191,
RULE_macroLiteralToken = 192, RULE_macroPunctuationToken = 193, RULE_shl = 194,
RULE_shr = 195;
private static String[] makeRuleNames() {
return new String[] {
"crate", "macroInvocation", "delimTokenTree", "tokenTree", "tokenTreeToken",
"macroInvocationSemi", "macroRulesDefinition", "macroRulesDef", "macroRules",
"macroRule", "macroMatcher", "macroMatch", "macroMatchToken", "macroFragSpec",
"macroRepSep", "macroRepOp", "macroTranscriber", "item", "visItem", "macroItem",
"module", "externCrate", "crateRef", "asClause", "useDeclaration", "useTree",
"function_", "functionQualifiers", "abi", "functionParameters", "selfParam",
"shorthandSelf", "typedSelf", "functionParam", "functionParamPattern",
"functionReturnType", "typeAlias", "struct_", "structStruct", "tupleStruct",
"structFields", "structField", "tupleFields", "tupleField", "enumeration",
"enumItems", "enumItem", "enumItemTuple", "enumItemStruct", "enumItemDiscriminant",
"union_", "constantItem", "staticItem", "trait_", "implementation", "inherentImpl",
"traitImpl", "externBlock", "externalItem", "genericParams", "genericParam",
"lifetimeParam", "typeParam", "constParam", "whereClause", "whereClauseItem",
"lifetimeWhereClauseItem", "typeBoundWhereClauseItem", "forLifetimes",
"associatedItem", "innerAttribute", "outerAttribute", "attr", "attrInput",
"statement", "letStatement", "expressionStatement", "expression", "comparisonOperator",
"compoundAssignOperator", "expressionWithBlock", "literalExpression",
"pathExpression", "blockExpression", "statements", "asyncBlockExpression",
"unsafeBlockExpression", "arrayElements", "tupleElements", "tupleIndex",
"structExpression", "structExprStruct", "structExprFields", "structExprField",
"structBase", "structExprTuple", "structExprUnit", "enumerationVariantExpression",
"enumExprStruct", "enumExprFields", "enumExprField", "enumExprTuple",
"enumExprFieldless", "callParams", "closureExpression", "closureParameters",
"closureParam", "loopExpression", "infiniteLoopExpression", "predicateLoopExpression",
"predicatePatternLoopExpression", "iteratorLoopExpression", "loopLabel",
"ifExpression", "ifLetExpression", "matchExpression", "matchArms", "matchArmExpression",
"matchArm", "matchArmGuard", "pattern", "patternNoTopAlt", "patternWithoutRange",
"literalPattern", "identifierPattern", "wildcardPattern", "restPattern",
"rangePattern", "rangePatternBound", "referencePattern", "structPattern",
"structPatternElements", "structPatternFields", "structPatternField",
"structPatternEtCetera", "tupleStructPattern", "tupleStructItems", "tuplePattern",
"tuplePatternItems", "groupedPattern", "slicePattern", "slicePatternItems",
"pathPattern", "type_", "typeNoBounds", "parenthesizedType", "neverType",
"tupleType", "arrayType", "sliceType", "referenceType", "rawPointerType",
"bareFunctionType", "functionTypeQualifiers", "bareFunctionReturnType",
"functionParametersMaybeNamedVariadic", "maybeNamedFunctionParameters",
"maybeNamedParam", "maybeNamedFunctionParametersVariadic", "traitObjectType",
"traitObjectTypeOneBound", "implTraitType", "implTraitTypeOneBound",
"inferredType", "typeParamBounds", "typeParamBound", "traitBound", "lifetimeBounds",
"lifetime", "simplePath", "simplePathSegment", "pathInExpression", "pathExprSegment",
"pathIdentSegment", "genericArgs", "genericArg", "genericArgsConst",
"genericArgsLifetimes", "genericArgsTypes", "genericArgsBindings", "genericArgsBinding",
"qualifiedPathInExpression", "qualifiedPathType", "qualifiedPathInType",
"typePath", "typePathSegment", "typePathFn", "typePathInputs", "visibility",
"identifier", "keyword", "macroIdentifierLikeToken", "macroLiteralToken",
"macroPunctuationToken", "shl", "shr"
};
}
public static final String[] ruleNames = makeRuleNames();
private static String[] makeLiteralNames() {
return new String[] {
null, "'as'", "'break'", "'const'", "'continue'", "'crate'", "'else'",
"'enum'", "'extern'", "'false'", "'fn'", "'for'", "'if'", "'impl'", "'in'",
"'let'", "'loop'", "'match'", "'mod'", "'move'", "'mut'", "'pub'", "'ref'",
"'return'", "'self'", "'Self'", "'static'", "'struct'", "'super'", "'trait'",
"'true'", "'type'", "'unsafe'", "'use'", "'where'", "'while'", "'async'",
"'await'", "'dyn'", "'abstract'", "'become'", "'box'", "'do'", "'final'",
"'macro'", "'override'", "'priv'", "'typeof'", "'unsized'", "'virtual'",
"'yield'", "'try'", "'union'", "''static'", "'macro_rules'", "''_'",
"'$crate'", null, null, null, null, null, null, null, null, null, null,
null, null, null, null, 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, "KW_AS", "KW_BREAK", "KW_CONST", "KW_CONTINUE", "KW_CRATE", "KW_ELSE",
"KW_ENUM", "KW_EXTERN", "KW_FALSE", "KW_FN", "KW_FOR", "KW_IF", "KW_IMPL",
"KW_IN", "KW_LET", "KW_LOOP", "KW_MATCH", "KW_MOD", "KW_MOVE", "KW_MUT",
"KW_PUB", "KW_REF", "KW_RETURN", "KW_SELFVALUE", "KW_SELFTYPE", "KW_STATIC",
"KW_STRUCT", "KW_SUPER", "KW_TRAIT", "KW_TRUE", "KW_TYPE", "KW_UNSAFE",
"KW_USE", "KW_WHERE", "KW_WHILE", "KW_ASYNC", "KW_AWAIT", "KW_DYN", "KW_ABSTRACT",
"KW_BECOME", "KW_BOX", "KW_DO", "KW_FINAL", "KW_MACRO", "KW_OVERRIDE",
"KW_PRIV", "KW_TYPEOF", "KW_UNSIZED", "KW_VIRTUAL", "KW_YIELD", "KW_TRY",
"KW_UNION", "KW_STATICLIFETIME", "KW_MACRORULES", "KW_UNDERLINELIFETIME",
"KW_DOLLARCRATE", "NON_KEYWORD_IDENTIFIER", "RAW_IDENTIFIER", "LINE_COMMENT",
"BLOCK_COMMENT", "INNER_LINE_DOC", "INNER_BLOCK_DOC", "OUTER_LINE_DOC",
"OUTER_BLOCK_DOC", "BLOCK_COMMENT_OR_DOC", "SHEBANG", "WHITESPACE", "NEWLINE",
"CHAR_LITERAL", "STRING_LITERAL", "RAW_STRING_LITERAL", "BYTE_LITERAL",
"BYTE_STRING_LITERAL", "RAW_BYTE_STRING_LITERAL", "INTEGER_LITERAL",
"DEC_LITERAL", "HEX_LITERAL", "OCT_LITERAL", "BIN_LITERAL", "FLOAT_LITERAL",
"LIFETIME_OR_LABEL", "PLUS", "MINUS", "STAR", "SLASH", "PERCENT", "CARET",
"NOT", "AND", "OR", "ANDAND", "OROR", "PLUSEQ", "MINUSEQ", "STAREQ",
"SLASHEQ", "PERCENTEQ", "CARETEQ", "ANDEQ", "OREQ", "SHLEQ", "SHREQ",
"EQ", "EQEQ", "NE", "GT", "LT", "GE", "LE", "AT", "UNDERSCORE", "DOT",
"DOTDOT", "DOTDOTDOT", "DOTDOTEQ", "COMMA", "SEMI", "COLON", "PATHSEP",
"RARROW", "FATARROW", "POUND", "DOLLAR", "QUESTION", "LCURLYBRACE", "RCURLYBRACE",
"LSQUAREBRACKET", "RSQUAREBRACKET", "LPAREN", "RPAREN"
};
}
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 "RustParser.g4"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
public RustParser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
@SuppressWarnings("CheckReturnValue")
public static class CrateContext extends ParserRuleContext {
public TerminalNode EOF() { return getToken(RustParser.EOF, 0); }
public List innerAttribute() {
return getRuleContexts(InnerAttributeContext.class);
}
public InnerAttributeContext innerAttribute(int i) {
return getRuleContext(InnerAttributeContext.class,i);
}
public List item() {
return getRuleContexts(ItemContext.class);
}
public ItemContext item(int i) {
return getRuleContext(ItemContext.class,i);
}
public CrateContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_crate; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterCrate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitCrate(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitCrate(this);
else return visitor.visitChildren(this);
}
}
public final CrateContext crate() throws RecognitionException {
CrateContext _localctx = new CrateContext(_ctx, getState());
enterRule(_localctx, 0, RULE_crate);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(395);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,0,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(392);
innerAttribute();
}
}
}
setState(397);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,0,_ctx);
}
setState(401);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 526921241179989416L) != 0) || _la==PATHSEP || _la==POUND) {
{
{
setState(398);
item();
}
}
setState(403);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(404);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class MacroInvocationContext extends ParserRuleContext {
public SimplePathContext simplePath() {
return getRuleContext(SimplePathContext.class,0);
}
public TerminalNode NOT() { return getToken(RustParser.NOT, 0); }
public DelimTokenTreeContext delimTokenTree() {
return getRuleContext(DelimTokenTreeContext.class,0);
}
public MacroInvocationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_macroInvocation; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterMacroInvocation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitMacroInvocation(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitMacroInvocation(this);
else return visitor.visitChildren(this);
}
}
public final MacroInvocationContext macroInvocation() throws RecognitionException {
MacroInvocationContext _localctx = new MacroInvocationContext(_ctx, getState());
enterRule(_localctx, 2, RULE_macroInvocation);
try {
enterOuterAlt(_localctx, 1);
{
setState(406);
simplePath();
setState(407);
match(NOT);
setState(408);
delimTokenTree();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class DelimTokenTreeContext extends ParserRuleContext {
public TerminalNode LPAREN() { return getToken(RustParser.LPAREN, 0); }
public TerminalNode RPAREN() { return getToken(RustParser.RPAREN, 0); }
public List tokenTree() {
return getRuleContexts(TokenTreeContext.class);
}
public TokenTreeContext tokenTree(int i) {
return getRuleContext(TokenTreeContext.class,i);
}
public TerminalNode LSQUAREBRACKET() { return getToken(RustParser.LSQUAREBRACKET, 0); }
public TerminalNode RSQUAREBRACKET() { return getToken(RustParser.RSQUAREBRACKET, 0); }
public TerminalNode LCURLYBRACE() { return getToken(RustParser.LCURLYBRACE, 0); }
public TerminalNode RCURLYBRACE() { return getToken(RustParser.RCURLYBRACE, 0); }
public DelimTokenTreeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_delimTokenTree; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterDelimTokenTree(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitDelimTokenTree(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitDelimTokenTree(this);
else return visitor.visitChildren(this);
}
}
public final DelimTokenTreeContext delimTokenTree() throws RecognitionException {
DelimTokenTreeContext _localctx = new DelimTokenTreeContext(_ctx, getState());
enterRule(_localctx, 4, RULE_delimTokenTree);
int _la;
try {
setState(434);
_errHandler.sync(this);
switch (_input.LA(1)) {
case LPAREN:
enterOuterAlt(_localctx, 1);
{
setState(410);
match(LPAREN);
setState(414);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 576460752303423486L) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & 1585267068834412671L) != 0)) {
{
{
setState(411);
tokenTree();
}
}
setState(416);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(417);
match(RPAREN);
}
break;
case LSQUAREBRACKET:
enterOuterAlt(_localctx, 2);
{
setState(418);
match(LSQUAREBRACKET);
setState(422);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 576460752303423486L) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & 1585267068834412671L) != 0)) {
{
{
setState(419);
tokenTree();
}
}
setState(424);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(425);
match(RSQUAREBRACKET);
}
break;
case LCURLYBRACE:
enterOuterAlt(_localctx, 3);
{
setState(426);
match(LCURLYBRACE);
setState(430);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 576460752303423486L) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & 1585267068834412671L) != 0)) {
{
{
setState(427);
tokenTree();
}
}
setState(432);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(433);
match(RCURLYBRACE);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class TokenTreeContext extends ParserRuleContext {
public List tokenTreeToken() {
return getRuleContexts(TokenTreeTokenContext.class);
}
public TokenTreeTokenContext tokenTreeToken(int i) {
return getRuleContext(TokenTreeTokenContext.class,i);
}
public DelimTokenTreeContext delimTokenTree() {
return getRuleContext(DelimTokenTreeContext.class,0);
}
public TokenTreeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_tokenTree; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterTokenTree(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitTokenTree(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitTokenTree(this);
else return visitor.visitChildren(this);
}
}
public final TokenTreeContext tokenTree() throws RecognitionException {
TokenTreeContext _localctx = new TokenTreeContext(_ctx, getState());
enterRule(_localctx, 6, RULE_tokenTree);
try {
int _alt;
setState(442);
_errHandler.sync(this);
switch (_input.LA(1)) {
case KW_AS:
case KW_BREAK:
case KW_CONST:
case KW_CONTINUE:
case KW_CRATE:
case KW_ELSE:
case KW_ENUM:
case KW_EXTERN:
case KW_FALSE:
case KW_FN:
case KW_FOR:
case KW_IF:
case KW_IMPL:
case KW_IN:
case KW_LET:
case KW_LOOP:
case KW_MATCH:
case KW_MOD:
case KW_MOVE:
case KW_MUT:
case KW_PUB:
case KW_REF:
case KW_RETURN:
case KW_SELFVALUE:
case KW_SELFTYPE:
case KW_STATIC:
case KW_STRUCT:
case KW_SUPER:
case KW_TRAIT:
case KW_TRUE:
case KW_TYPE:
case KW_UNSAFE:
case KW_USE:
case KW_WHERE:
case KW_WHILE:
case KW_ASYNC:
case KW_AWAIT:
case KW_DYN:
case KW_ABSTRACT:
case KW_BECOME:
case KW_BOX:
case KW_DO:
case KW_FINAL:
case KW_MACRO:
case KW_OVERRIDE:
case KW_PRIV:
case KW_TYPEOF:
case KW_UNSIZED:
case KW_VIRTUAL:
case KW_YIELD:
case KW_TRY:
case KW_UNION:
case KW_STATICLIFETIME:
case KW_MACRORULES:
case KW_UNDERLINELIFETIME:
case KW_DOLLARCRATE:
case NON_KEYWORD_IDENTIFIER:
case RAW_IDENTIFIER:
case CHAR_LITERAL:
case STRING_LITERAL:
case RAW_STRING_LITERAL:
case BYTE_LITERAL:
case BYTE_STRING_LITERAL:
case RAW_BYTE_STRING_LITERAL:
case INTEGER_LITERAL:
case FLOAT_LITERAL:
case LIFETIME_OR_LABEL:
case PLUS:
case MINUS:
case STAR:
case SLASH:
case PERCENT:
case CARET:
case NOT:
case AND:
case OR:
case ANDAND:
case OROR:
case PLUSEQ:
case MINUSEQ:
case STAREQ:
case SLASHEQ:
case PERCENTEQ:
case CARETEQ:
case ANDEQ:
case OREQ:
case SHLEQ:
case SHREQ:
case EQ:
case EQEQ:
case NE:
case GT:
case LT:
case GE:
case LE:
case AT:
case UNDERSCORE:
case DOT:
case DOTDOT:
case DOTDOTDOT:
case DOTDOTEQ:
case COMMA:
case SEMI:
case COLON:
case PATHSEP:
case RARROW:
case FATARROW:
case POUND:
case DOLLAR:
case QUESTION:
enterOuterAlt(_localctx, 1);
{
setState(437);
_errHandler.sync(this);
_alt = 1;
do {
switch (_alt) {
case 1:
{
{
setState(436);
tokenTreeToken();
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(439);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,6,_ctx);
} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
}
break;
case LCURLYBRACE:
case LSQUAREBRACKET:
case LPAREN:
enterOuterAlt(_localctx, 2);
{
setState(441);
delimTokenTree();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class TokenTreeTokenContext extends ParserRuleContext {
public MacroIdentifierLikeTokenContext macroIdentifierLikeToken() {
return getRuleContext(MacroIdentifierLikeTokenContext.class,0);
}
public MacroLiteralTokenContext macroLiteralToken() {
return getRuleContext(MacroLiteralTokenContext.class,0);
}
public MacroPunctuationTokenContext macroPunctuationToken() {
return getRuleContext(MacroPunctuationTokenContext.class,0);
}
public MacroRepOpContext macroRepOp() {
return getRuleContext(MacroRepOpContext.class,0);
}
public TerminalNode DOLLAR() { return getToken(RustParser.DOLLAR, 0); }
public TokenTreeTokenContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_tokenTreeToken; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterTokenTreeToken(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitTokenTreeToken(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitTokenTreeToken(this);
else return visitor.visitChildren(this);
}
}
public final TokenTreeTokenContext tokenTreeToken() throws RecognitionException {
TokenTreeTokenContext _localctx = new TokenTreeTokenContext(_ctx, getState());
enterRule(_localctx, 8, RULE_tokenTreeToken);
try {
setState(449);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,8,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(444);
macroIdentifierLikeToken();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(445);
macroLiteralToken();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(446);
macroPunctuationToken();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(447);
macroRepOp();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(448);
match(DOLLAR);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class MacroInvocationSemiContext extends ParserRuleContext {
public SimplePathContext simplePath() {
return getRuleContext(SimplePathContext.class,0);
}
public TerminalNode NOT() { return getToken(RustParser.NOT, 0); }
public TerminalNode LPAREN() { return getToken(RustParser.LPAREN, 0); }
public TerminalNode RPAREN() { return getToken(RustParser.RPAREN, 0); }
public TerminalNode SEMI() { return getToken(RustParser.SEMI, 0); }
public List tokenTree() {
return getRuleContexts(TokenTreeContext.class);
}
public TokenTreeContext tokenTree(int i) {
return getRuleContext(TokenTreeContext.class,i);
}
public TerminalNode LSQUAREBRACKET() { return getToken(RustParser.LSQUAREBRACKET, 0); }
public TerminalNode RSQUAREBRACKET() { return getToken(RustParser.RSQUAREBRACKET, 0); }
public TerminalNode LCURLYBRACE() { return getToken(RustParser.LCURLYBRACE, 0); }
public TerminalNode RCURLYBRACE() { return getToken(RustParser.RCURLYBRACE, 0); }
public MacroInvocationSemiContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_macroInvocationSemi; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterMacroInvocationSemi(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitMacroInvocationSemi(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitMacroInvocationSemi(this);
else return visitor.visitChildren(this);
}
}
public final MacroInvocationSemiContext macroInvocationSemi() throws RecognitionException {
MacroInvocationSemiContext _localctx = new MacroInvocationSemiContext(_ctx, getState());
enterRule(_localctx, 10, RULE_macroInvocationSemi);
int _la;
try {
setState(486);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(451);
simplePath();
setState(452);
match(NOT);
setState(453);
match(LPAREN);
setState(457);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 576460752303423486L) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & 1585267068834412671L) != 0)) {
{
{
setState(454);
tokenTree();
}
}
setState(459);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(460);
match(RPAREN);
setState(461);
match(SEMI);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(463);
simplePath();
setState(464);
match(NOT);
setState(465);
match(LSQUAREBRACKET);
setState(469);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 576460752303423486L) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & 1585267068834412671L) != 0)) {
{
{
setState(466);
tokenTree();
}
}
setState(471);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(472);
match(RSQUAREBRACKET);
setState(473);
match(SEMI);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(475);
simplePath();
setState(476);
match(NOT);
setState(477);
match(LCURLYBRACE);
setState(481);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 576460752303423486L) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & 1585267068834412671L) != 0)) {
{
{
setState(478);
tokenTree();
}
}
setState(483);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(484);
match(RCURLYBRACE);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class MacroRulesDefinitionContext extends ParserRuleContext {
public TerminalNode KW_MACRORULES() { return getToken(RustParser.KW_MACRORULES, 0); }
public TerminalNode NOT() { return getToken(RustParser.NOT, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public MacroRulesDefContext macroRulesDef() {
return getRuleContext(MacroRulesDefContext.class,0);
}
public MacroRulesDefinitionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_macroRulesDefinition; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterMacroRulesDefinition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitMacroRulesDefinition(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitMacroRulesDefinition(this);
else return visitor.visitChildren(this);
}
}
public final MacroRulesDefinitionContext macroRulesDefinition() throws RecognitionException {
MacroRulesDefinitionContext _localctx = new MacroRulesDefinitionContext(_ctx, getState());
enterRule(_localctx, 12, RULE_macroRulesDefinition);
try {
enterOuterAlt(_localctx, 1);
{
setState(488);
match(KW_MACRORULES);
setState(489);
match(NOT);
setState(490);
identifier();
setState(491);
macroRulesDef();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class MacroRulesDefContext extends ParserRuleContext {
public TerminalNode LPAREN() { return getToken(RustParser.LPAREN, 0); }
public MacroRulesContext macroRules() {
return getRuleContext(MacroRulesContext.class,0);
}
public TerminalNode RPAREN() { return getToken(RustParser.RPAREN, 0); }
public TerminalNode SEMI() { return getToken(RustParser.SEMI, 0); }
public TerminalNode LSQUAREBRACKET() { return getToken(RustParser.LSQUAREBRACKET, 0); }
public TerminalNode RSQUAREBRACKET() { return getToken(RustParser.RSQUAREBRACKET, 0); }
public TerminalNode LCURLYBRACE() { return getToken(RustParser.LCURLYBRACE, 0); }
public TerminalNode RCURLYBRACE() { return getToken(RustParser.RCURLYBRACE, 0); }
public MacroRulesDefContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_macroRulesDef; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterMacroRulesDef(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitMacroRulesDef(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitMacroRulesDef(this);
else return visitor.visitChildren(this);
}
}
public final MacroRulesDefContext macroRulesDef() throws RecognitionException {
MacroRulesDefContext _localctx = new MacroRulesDefContext(_ctx, getState());
enterRule(_localctx, 14, RULE_macroRulesDef);
try {
setState(507);
_errHandler.sync(this);
switch (_input.LA(1)) {
case LPAREN:
enterOuterAlt(_localctx, 1);
{
setState(493);
match(LPAREN);
setState(494);
macroRules();
setState(495);
match(RPAREN);
setState(496);
match(SEMI);
}
break;
case LSQUAREBRACKET:
enterOuterAlt(_localctx, 2);
{
setState(498);
match(LSQUAREBRACKET);
setState(499);
macroRules();
setState(500);
match(RSQUAREBRACKET);
setState(501);
match(SEMI);
}
break;
case LCURLYBRACE:
enterOuterAlt(_localctx, 3);
{
setState(503);
match(LCURLYBRACE);
setState(504);
macroRules();
setState(505);
match(RCURLYBRACE);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class MacroRulesContext extends ParserRuleContext {
public List macroRule() {
return getRuleContexts(MacroRuleContext.class);
}
public MacroRuleContext macroRule(int i) {
return getRuleContext(MacroRuleContext.class,i);
}
public List SEMI() { return getTokens(RustParser.SEMI); }
public TerminalNode SEMI(int i) {
return getToken(RustParser.SEMI, i);
}
public MacroRulesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_macroRules; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterMacroRules(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitMacroRules(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitMacroRules(this);
else return visitor.visitChildren(this);
}
}
public final MacroRulesContext macroRules() throws RecognitionException {
MacroRulesContext _localctx = new MacroRulesContext(_ctx, getState());
enterRule(_localctx, 16, RULE_macroRules);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(509);
macroRule();
setState(514);
_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 ) {
{
{
setState(510);
match(SEMI);
setState(511);
macroRule();
}
}
}
setState(516);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,14,_ctx);
}
setState(518);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SEMI) {
{
setState(517);
match(SEMI);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class MacroRuleContext extends ParserRuleContext {
public MacroMatcherContext macroMatcher() {
return getRuleContext(MacroMatcherContext.class,0);
}
public TerminalNode FATARROW() { return getToken(RustParser.FATARROW, 0); }
public MacroTranscriberContext macroTranscriber() {
return getRuleContext(MacroTranscriberContext.class,0);
}
public MacroRuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_macroRule; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterMacroRule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitMacroRule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitMacroRule(this);
else return visitor.visitChildren(this);
}
}
public final MacroRuleContext macroRule() throws RecognitionException {
MacroRuleContext _localctx = new MacroRuleContext(_ctx, getState());
enterRule(_localctx, 18, RULE_macroRule);
try {
enterOuterAlt(_localctx, 1);
{
setState(520);
macroMatcher();
setState(521);
match(FATARROW);
setState(522);
macroTranscriber();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class MacroMatcherContext extends ParserRuleContext {
public TerminalNode LPAREN() { return getToken(RustParser.LPAREN, 0); }
public TerminalNode RPAREN() { return getToken(RustParser.RPAREN, 0); }
public List macroMatch() {
return getRuleContexts(MacroMatchContext.class);
}
public MacroMatchContext macroMatch(int i) {
return getRuleContext(MacroMatchContext.class,i);
}
public TerminalNode LSQUAREBRACKET() { return getToken(RustParser.LSQUAREBRACKET, 0); }
public TerminalNode RSQUAREBRACKET() { return getToken(RustParser.RSQUAREBRACKET, 0); }
public TerminalNode LCURLYBRACE() { return getToken(RustParser.LCURLYBRACE, 0); }
public TerminalNode RCURLYBRACE() { return getToken(RustParser.RCURLYBRACE, 0); }
public MacroMatcherContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_macroMatcher; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterMacroMatcher(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitMacroMatcher(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitMacroMatcher(this);
else return visitor.visitChildren(this);
}
}
public final MacroMatcherContext macroMatcher() throws RecognitionException {
MacroMatcherContext _localctx = new MacroMatcherContext(_ctx, getState());
enterRule(_localctx, 20, RULE_macroMatcher);
int _la;
try {
setState(548);
_errHandler.sync(this);
switch (_input.LA(1)) {
case LPAREN:
enterOuterAlt(_localctx, 1);
{
setState(524);
match(LPAREN);
setState(528);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 576460752303423486L) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & 1585267068834412671L) != 0)) {
{
{
setState(525);
macroMatch();
}
}
setState(530);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(531);
match(RPAREN);
}
break;
case LSQUAREBRACKET:
enterOuterAlt(_localctx, 2);
{
setState(532);
match(LSQUAREBRACKET);
setState(536);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 576460752303423486L) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & 1585267068834412671L) != 0)) {
{
{
setState(533);
macroMatch();
}
}
setState(538);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(539);
match(RSQUAREBRACKET);
}
break;
case LCURLYBRACE:
enterOuterAlt(_localctx, 3);
{
setState(540);
match(LCURLYBRACE);
setState(544);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 576460752303423486L) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & 1585267068834412671L) != 0)) {
{
{
setState(541);
macroMatch();
}
}
setState(546);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(547);
match(RCURLYBRACE);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class MacroMatchContext extends ParserRuleContext {
public List macroMatchToken() {
return getRuleContexts(MacroMatchTokenContext.class);
}
public MacroMatchTokenContext macroMatchToken(int i) {
return getRuleContext(MacroMatchTokenContext.class,i);
}
public MacroMatcherContext macroMatcher() {
return getRuleContext(MacroMatcherContext.class,0);
}
public TerminalNode DOLLAR() { return getToken(RustParser.DOLLAR, 0); }
public TerminalNode COLON() { return getToken(RustParser.COLON, 0); }
public MacroFragSpecContext macroFragSpec() {
return getRuleContext(MacroFragSpecContext.class,0);
}
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode KW_SELFVALUE() { return getToken(RustParser.KW_SELFVALUE, 0); }
public TerminalNode LPAREN() { return getToken(RustParser.LPAREN, 0); }
public TerminalNode RPAREN() { return getToken(RustParser.RPAREN, 0); }
public MacroRepOpContext macroRepOp() {
return getRuleContext(MacroRepOpContext.class,0);
}
public List macroMatch() {
return getRuleContexts(MacroMatchContext.class);
}
public MacroMatchContext macroMatch(int i) {
return getRuleContext(MacroMatchContext.class,i);
}
public MacroRepSepContext macroRepSep() {
return getRuleContext(MacroRepSepContext.class,0);
}
public MacroMatchContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_macroMatch; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterMacroMatch(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitMacroMatch(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitMacroMatch(this);
else return visitor.visitChildren(this);
}
}
public final MacroMatchContext macroMatch() throws RecognitionException {
MacroMatchContext _localctx = new MacroMatchContext(_ctx, getState());
enterRule(_localctx, 22, RULE_macroMatch);
int _la;
try {
int _alt;
setState(576);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,24,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(551);
_errHandler.sync(this);
_alt = 1;
do {
switch (_alt) {
case 1:
{
{
setState(550);
macroMatchToken();
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(553);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,20,_ctx);
} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(555);
macroMatcher();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(556);
match(DOLLAR);
setState(559);
_errHandler.sync(this);
switch (_input.LA(1)) {
case KW_MACRORULES:
case NON_KEYWORD_IDENTIFIER:
case RAW_IDENTIFIER:
{
setState(557);
identifier();
}
break;
case KW_SELFVALUE:
{
setState(558);
match(KW_SELFVALUE);
}
break;
default:
throw new NoViableAltException(this);
}
setState(561);
match(COLON);
setState(562);
macroFragSpec();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(563);
match(DOLLAR);
setState(564);
match(LPAREN);
setState(566);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(565);
macroMatch();
}
}
setState(568);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & 576460752303423486L) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & 1585267068834412671L) != 0) );
setState(570);
match(RPAREN);
setState(572);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 576460752303423486L) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & 36028797018921087L) != 0)) {
{
setState(571);
macroRepSep();
}
}
setState(574);
macroRepOp();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class MacroMatchTokenContext extends ParserRuleContext {
public MacroIdentifierLikeTokenContext macroIdentifierLikeToken() {
return getRuleContext(MacroIdentifierLikeTokenContext.class,0);
}
public MacroLiteralTokenContext macroLiteralToken() {
return getRuleContext(MacroLiteralTokenContext.class,0);
}
public MacroPunctuationTokenContext macroPunctuationToken() {
return getRuleContext(MacroPunctuationTokenContext.class,0);
}
public MacroRepOpContext macroRepOp() {
return getRuleContext(MacroRepOpContext.class,0);
}
public MacroMatchTokenContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_macroMatchToken; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterMacroMatchToken(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitMacroMatchToken(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitMacroMatchToken(this);
else return visitor.visitChildren(this);
}
}
public final MacroMatchTokenContext macroMatchToken() throws RecognitionException {
MacroMatchTokenContext _localctx = new MacroMatchTokenContext(_ctx, getState());
enterRule(_localctx, 24, RULE_macroMatchToken);
try {
setState(582);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,25,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(578);
macroIdentifierLikeToken();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(579);
macroLiteralToken();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(580);
macroPunctuationToken();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(581);
macroRepOp();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class MacroFragSpecContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public MacroFragSpecContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_macroFragSpec; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterMacroFragSpec(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitMacroFragSpec(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitMacroFragSpec(this);
else return visitor.visitChildren(this);
}
}
public final MacroFragSpecContext macroFragSpec() throws RecognitionException {
MacroFragSpecContext _localctx = new MacroFragSpecContext(_ctx, getState());
enterRule(_localctx, 26, RULE_macroFragSpec);
try {
enterOuterAlt(_localctx, 1);
{
setState(584);
identifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class MacroRepSepContext extends ParserRuleContext {
public MacroIdentifierLikeTokenContext macroIdentifierLikeToken() {
return getRuleContext(MacroIdentifierLikeTokenContext.class,0);
}
public MacroLiteralTokenContext macroLiteralToken() {
return getRuleContext(MacroLiteralTokenContext.class,0);
}
public MacroPunctuationTokenContext macroPunctuationToken() {
return getRuleContext(MacroPunctuationTokenContext.class,0);
}
public TerminalNode DOLLAR() { return getToken(RustParser.DOLLAR, 0); }
public MacroRepSepContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_macroRepSep; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterMacroRepSep(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitMacroRepSep(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitMacroRepSep(this);
else return visitor.visitChildren(this);
}
}
public final MacroRepSepContext macroRepSep() throws RecognitionException {
MacroRepSepContext _localctx = new MacroRepSepContext(_ctx, getState());
enterRule(_localctx, 28, RULE_macroRepSep);
try {
setState(590);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,26,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(586);
macroIdentifierLikeToken();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(587);
macroLiteralToken();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(588);
macroPunctuationToken();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(589);
match(DOLLAR);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class MacroRepOpContext extends ParserRuleContext {
public TerminalNode STAR() { return getToken(RustParser.STAR, 0); }
public TerminalNode PLUS() { return getToken(RustParser.PLUS, 0); }
public TerminalNode QUESTION() { return getToken(RustParser.QUESTION, 0); }
public MacroRepOpContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_macroRepOp; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterMacroRepOp(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitMacroRepOp(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitMacroRepOp(this);
else return visitor.visitChildren(this);
}
}
public final MacroRepOpContext macroRepOp() throws RecognitionException {
MacroRepOpContext _localctx = new MacroRepOpContext(_ctx, getState());
enterRule(_localctx, 30, RULE_macroRepOp);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(592);
_la = _input.LA(1);
if ( !(((((_la - 82)) & ~0x3f) == 0 && ((1L << (_la - 82)) & 4398046511109L) != 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;
}
@SuppressWarnings("CheckReturnValue")
public static class MacroTranscriberContext extends ParserRuleContext {
public DelimTokenTreeContext delimTokenTree() {
return getRuleContext(DelimTokenTreeContext.class,0);
}
public MacroTranscriberContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_macroTranscriber; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterMacroTranscriber(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitMacroTranscriber(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitMacroTranscriber(this);
else return visitor.visitChildren(this);
}
}
public final MacroTranscriberContext macroTranscriber() throws RecognitionException {
MacroTranscriberContext _localctx = new MacroTranscriberContext(_ctx, getState());
enterRule(_localctx, 32, RULE_macroTranscriber);
try {
enterOuterAlt(_localctx, 1);
{
setState(594);
delimTokenTree();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ItemContext extends ParserRuleContext {
public VisItemContext visItem() {
return getRuleContext(VisItemContext.class,0);
}
public MacroItemContext macroItem() {
return getRuleContext(MacroItemContext.class,0);
}
public List outerAttribute() {
return getRuleContexts(OuterAttributeContext.class);
}
public OuterAttributeContext outerAttribute(int i) {
return getRuleContext(OuterAttributeContext.class,i);
}
public ItemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_item; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterItem(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitItem(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitItem(this);
else return visitor.visitChildren(this);
}
}
public final ItemContext item() throws RecognitionException {
ItemContext _localctx = new ItemContext(_ctx, getState());
enterRule(_localctx, 34, RULE_item);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(599);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==POUND) {
{
{
setState(596);
outerAttribute();
}
}
setState(601);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(604);
_errHandler.sync(this);
switch (_input.LA(1)) {
case KW_CONST:
case KW_ENUM:
case KW_EXTERN:
case KW_FN:
case KW_IMPL:
case KW_MOD:
case KW_PUB:
case KW_STATIC:
case KW_STRUCT:
case KW_TRAIT:
case KW_TYPE:
case KW_UNSAFE:
case KW_USE:
case KW_ASYNC:
case KW_UNION:
{
setState(602);
visItem();
}
break;
case KW_CRATE:
case KW_SELFVALUE:
case KW_SUPER:
case KW_MACRORULES:
case KW_DOLLARCRATE:
case NON_KEYWORD_IDENTIFIER:
case RAW_IDENTIFIER:
case PATHSEP:
{
setState(603);
macroItem();
}
break;
default:
throw new NoViableAltException(this);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class VisItemContext extends ParserRuleContext {
public ModuleContext module() {
return getRuleContext(ModuleContext.class,0);
}
public ExternCrateContext externCrate() {
return getRuleContext(ExternCrateContext.class,0);
}
public UseDeclarationContext useDeclaration() {
return getRuleContext(UseDeclarationContext.class,0);
}
public Function_Context function_() {
return getRuleContext(Function_Context.class,0);
}
public TypeAliasContext typeAlias() {
return getRuleContext(TypeAliasContext.class,0);
}
public Struct_Context struct_() {
return getRuleContext(Struct_Context.class,0);
}
public EnumerationContext enumeration() {
return getRuleContext(EnumerationContext.class,0);
}
public Union_Context union_() {
return getRuleContext(Union_Context.class,0);
}
public ConstantItemContext constantItem() {
return getRuleContext(ConstantItemContext.class,0);
}
public StaticItemContext staticItem() {
return getRuleContext(StaticItemContext.class,0);
}
public Trait_Context trait_() {
return getRuleContext(Trait_Context.class,0);
}
public ImplementationContext implementation() {
return getRuleContext(ImplementationContext.class,0);
}
public ExternBlockContext externBlock() {
return getRuleContext(ExternBlockContext.class,0);
}
public VisibilityContext visibility() {
return getRuleContext(VisibilityContext.class,0);
}
public VisItemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_visItem; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterVisItem(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitVisItem(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitVisItem(this);
else return visitor.visitChildren(this);
}
}
public final VisItemContext visItem() throws RecognitionException {
VisItemContext _localctx = new VisItemContext(_ctx, getState());
enterRule(_localctx, 36, RULE_visItem);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(607);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==KW_PUB) {
{
setState(606);
visibility();
}
}
setState(622);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,30,_ctx) ) {
case 1:
{
setState(609);
module();
}
break;
case 2:
{
setState(610);
externCrate();
}
break;
case 3:
{
setState(611);
useDeclaration();
}
break;
case 4:
{
setState(612);
function_();
}
break;
case 5:
{
setState(613);
typeAlias();
}
break;
case 6:
{
setState(614);
struct_();
}
break;
case 7:
{
setState(615);
enumeration();
}
break;
case 8:
{
setState(616);
union_();
}
break;
case 9:
{
setState(617);
constantItem();
}
break;
case 10:
{
setState(618);
staticItem();
}
break;
case 11:
{
setState(619);
trait_();
}
break;
case 12:
{
setState(620);
implementation();
}
break;
case 13:
{
setState(621);
externBlock();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class MacroItemContext extends ParserRuleContext {
public MacroInvocationSemiContext macroInvocationSemi() {
return getRuleContext(MacroInvocationSemiContext.class,0);
}
public MacroRulesDefinitionContext macroRulesDefinition() {
return getRuleContext(MacroRulesDefinitionContext.class,0);
}
public MacroItemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_macroItem; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterMacroItem(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitMacroItem(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitMacroItem(this);
else return visitor.visitChildren(this);
}
}
public final MacroItemContext macroItem() throws RecognitionException {
MacroItemContext _localctx = new MacroItemContext(_ctx, getState());
enterRule(_localctx, 38, RULE_macroItem);
try {
setState(626);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,31,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(624);
macroInvocationSemi();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(625);
macroRulesDefinition();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ModuleContext extends ParserRuleContext {
public TerminalNode KW_MOD() { return getToken(RustParser.KW_MOD, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode SEMI() { return getToken(RustParser.SEMI, 0); }
public TerminalNode LCURLYBRACE() { return getToken(RustParser.LCURLYBRACE, 0); }
public TerminalNode RCURLYBRACE() { return getToken(RustParser.RCURLYBRACE, 0); }
public TerminalNode KW_UNSAFE() { return getToken(RustParser.KW_UNSAFE, 0); }
public List innerAttribute() {
return getRuleContexts(InnerAttributeContext.class);
}
public InnerAttributeContext innerAttribute(int i) {
return getRuleContext(InnerAttributeContext.class,i);
}
public List item() {
return getRuleContexts(ItemContext.class);
}
public ItemContext item(int i) {
return getRuleContext(ItemContext.class,i);
}
public ModuleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_module; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterModule(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitModule(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitModule(this);
else return visitor.visitChildren(this);
}
}
public final ModuleContext module() throws RecognitionException {
ModuleContext _localctx = new ModuleContext(_ctx, getState());
enterRule(_localctx, 40, RULE_module);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(629);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==KW_UNSAFE) {
{
setState(628);
match(KW_UNSAFE);
}
}
setState(631);
match(KW_MOD);
setState(632);
identifier();
setState(648);
_errHandler.sync(this);
switch (_input.LA(1)) {
case SEMI:
{
setState(633);
match(SEMI);
}
break;
case LCURLYBRACE:
{
setState(634);
match(LCURLYBRACE);
setState(638);
_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(635);
innerAttribute();
}
}
}
setState(640);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,33,_ctx);
}
setState(644);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 526921241179989416L) != 0) || _la==PATHSEP || _la==POUND) {
{
{
setState(641);
item();
}
}
setState(646);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(647);
match(RCURLYBRACE);
}
break;
default:
throw new NoViableAltException(this);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ExternCrateContext extends ParserRuleContext {
public TerminalNode KW_EXTERN() { return getToken(RustParser.KW_EXTERN, 0); }
public TerminalNode KW_CRATE() { return getToken(RustParser.KW_CRATE, 0); }
public CrateRefContext crateRef() {
return getRuleContext(CrateRefContext.class,0);
}
public TerminalNode SEMI() { return getToken(RustParser.SEMI, 0); }
public AsClauseContext asClause() {
return getRuleContext(AsClauseContext.class,0);
}
public ExternCrateContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_externCrate; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterExternCrate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitExternCrate(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitExternCrate(this);
else return visitor.visitChildren(this);
}
}
public final ExternCrateContext externCrate() throws RecognitionException {
ExternCrateContext _localctx = new ExternCrateContext(_ctx, getState());
enterRule(_localctx, 42, RULE_externCrate);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(650);
match(KW_EXTERN);
setState(651);
match(KW_CRATE);
setState(652);
crateRef();
setState(654);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==KW_AS) {
{
setState(653);
asClause();
}
}
setState(656);
match(SEMI);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class CrateRefContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode KW_SELFVALUE() { return getToken(RustParser.KW_SELFVALUE, 0); }
public CrateRefContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_crateRef; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterCrateRef(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitCrateRef(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitCrateRef(this);
else return visitor.visitChildren(this);
}
}
public final CrateRefContext crateRef() throws RecognitionException {
CrateRefContext _localctx = new CrateRefContext(_ctx, getState());
enterRule(_localctx, 44, RULE_crateRef);
try {
setState(660);
_errHandler.sync(this);
switch (_input.LA(1)) {
case KW_MACRORULES:
case NON_KEYWORD_IDENTIFIER:
case RAW_IDENTIFIER:
enterOuterAlt(_localctx, 1);
{
setState(658);
identifier();
}
break;
case KW_SELFVALUE:
enterOuterAlt(_localctx, 2);
{
setState(659);
match(KW_SELFVALUE);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class AsClauseContext extends ParserRuleContext {
public TerminalNode KW_AS() { return getToken(RustParser.KW_AS, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode UNDERSCORE() { return getToken(RustParser.UNDERSCORE, 0); }
public AsClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_asClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterAsClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitAsClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitAsClause(this);
else return visitor.visitChildren(this);
}
}
public final AsClauseContext asClause() throws RecognitionException {
AsClauseContext _localctx = new AsClauseContext(_ctx, getState());
enterRule(_localctx, 46, RULE_asClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(662);
match(KW_AS);
setState(665);
_errHandler.sync(this);
switch (_input.LA(1)) {
case KW_MACRORULES:
case NON_KEYWORD_IDENTIFIER:
case RAW_IDENTIFIER:
{
setState(663);
identifier();
}
break;
case UNDERSCORE:
{
setState(664);
match(UNDERSCORE);
}
break;
default:
throw new NoViableAltException(this);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class UseDeclarationContext extends ParserRuleContext {
public TerminalNode KW_USE() { return getToken(RustParser.KW_USE, 0); }
public UseTreeContext useTree() {
return getRuleContext(UseTreeContext.class,0);
}
public TerminalNode SEMI() { return getToken(RustParser.SEMI, 0); }
public UseDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_useDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterUseDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitUseDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitUseDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final UseDeclarationContext useDeclaration() throws RecognitionException {
UseDeclarationContext _localctx = new UseDeclarationContext(_ctx, getState());
enterRule(_localctx, 48, RULE_useDeclaration);
try {
enterOuterAlt(_localctx, 1);
{
setState(667);
match(KW_USE);
setState(668);
useTree();
setState(669);
match(SEMI);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class UseTreeContext extends ParserRuleContext {
public TerminalNode STAR() { return getToken(RustParser.STAR, 0); }
public TerminalNode LCURLYBRACE() { return getToken(RustParser.LCURLYBRACE, 0); }
public TerminalNode RCURLYBRACE() { return getToken(RustParser.RCURLYBRACE, 0); }
public TerminalNode PATHSEP() { return getToken(RustParser.PATHSEP, 0); }
public List useTree() {
return getRuleContexts(UseTreeContext.class);
}
public UseTreeContext useTree(int i) {
return getRuleContext(UseTreeContext.class,i);
}
public SimplePathContext simplePath() {
return getRuleContext(SimplePathContext.class,0);
}
public List COMMA() { return getTokens(RustParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(RustParser.COMMA, i);
}
public TerminalNode KW_AS() { return getToken(RustParser.KW_AS, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode UNDERSCORE() { return getToken(RustParser.UNDERSCORE, 0); }
public UseTreeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_useTree; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterUseTree(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitUseTree(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitUseTree(this);
else return visitor.visitChildren(this);
}
}
public final UseTreeContext useTree() throws RecognitionException {
UseTreeContext _localctx = new UseTreeContext(_ctx, getState());
enterRule(_localctx, 50, RULE_useTree);
int _la;
try {
int _alt;
setState(703);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,47,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(675);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 522417557060190240L) != 0) || _la==PATHSEP) {
{
setState(672);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,39,_ctx) ) {
case 1:
{
setState(671);
simplePath();
}
break;
}
setState(674);
match(PATHSEP);
}
}
setState(693);
_errHandler.sync(this);
switch (_input.LA(1)) {
case STAR:
{
setState(677);
match(STAR);
}
break;
case LCURLYBRACE:
{
setState(678);
match(LCURLYBRACE);
setState(690);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 522417557060190240L) != 0) || ((((_la - 84)) & ~0x3f) == 0 && ((1L << (_la - 84)) & 2233382993921L) != 0)) {
{
setState(679);
useTree();
setState(684);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,41,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(680);
match(COMMA);
setState(681);
useTree();
}
}
}
setState(686);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,41,_ctx);
}
setState(688);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(687);
match(COMMA);
}
}
}
}
setState(692);
match(RCURLYBRACE);
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(695);
simplePath();
setState(701);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==KW_AS) {
{
setState(696);
match(KW_AS);
setState(699);
_errHandler.sync(this);
switch (_input.LA(1)) {
case KW_MACRORULES:
case NON_KEYWORD_IDENTIFIER:
case RAW_IDENTIFIER:
{
setState(697);
identifier();
}
break;
case UNDERSCORE:
{
setState(698);
match(UNDERSCORE);
}
break;
default:
throw new NoViableAltException(this);
}
}
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Function_Context extends ParserRuleContext {
public FunctionQualifiersContext functionQualifiers() {
return getRuleContext(FunctionQualifiersContext.class,0);
}
public TerminalNode KW_FN() { return getToken(RustParser.KW_FN, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode LPAREN() { return getToken(RustParser.LPAREN, 0); }
public TerminalNode RPAREN() { return getToken(RustParser.RPAREN, 0); }
public BlockExpressionContext blockExpression() {
return getRuleContext(BlockExpressionContext.class,0);
}
public TerminalNode SEMI() { return getToken(RustParser.SEMI, 0); }
public GenericParamsContext genericParams() {
return getRuleContext(GenericParamsContext.class,0);
}
public FunctionParametersContext functionParameters() {
return getRuleContext(FunctionParametersContext.class,0);
}
public FunctionReturnTypeContext functionReturnType() {
return getRuleContext(FunctionReturnTypeContext.class,0);
}
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public Function_Context(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_function_; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterFunction_(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitFunction_(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitFunction_(this);
else return visitor.visitChildren(this);
}
}
public final Function_Context function_() throws RecognitionException {
Function_Context _localctx = new Function_Context(_ctx, getState());
enterRule(_localctx, 52, RULE_function_);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(705);
functionQualifiers();
setState(706);
match(KW_FN);
setState(707);
identifier();
setState(709);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(708);
genericParams();
}
}
setState(711);
match(LPAREN);
setState(713);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 567453833619320608L) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & 1487371226429577343L) != 0)) {
{
setState(712);
functionParameters();
}
}
setState(715);
match(RPAREN);
setState(717);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==RARROW) {
{
setState(716);
functionReturnType();
}
}
setState(720);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==KW_WHERE) {
{
setState(719);
whereClause();
}
}
setState(724);
_errHandler.sync(this);
switch (_input.LA(1)) {
case LCURLYBRACE:
{
setState(722);
blockExpression();
}
break;
case SEMI:
{
setState(723);
match(SEMI);
}
break;
default:
throw new NoViableAltException(this);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class FunctionQualifiersContext extends ParserRuleContext {
public TerminalNode KW_CONST() { return getToken(RustParser.KW_CONST, 0); }
public TerminalNode KW_ASYNC() { return getToken(RustParser.KW_ASYNC, 0); }
public TerminalNode KW_UNSAFE() { return getToken(RustParser.KW_UNSAFE, 0); }
public TerminalNode KW_EXTERN() { return getToken(RustParser.KW_EXTERN, 0); }
public AbiContext abi() {
return getRuleContext(AbiContext.class,0);
}
public FunctionQualifiersContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_functionQualifiers; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterFunctionQualifiers(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitFunctionQualifiers(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitFunctionQualifiers(this);
else return visitor.visitChildren(this);
}
}
public final FunctionQualifiersContext functionQualifiers() throws RecognitionException {
FunctionQualifiersContext _localctx = new FunctionQualifiersContext(_ctx, getState());
enterRule(_localctx, 54, RULE_functionQualifiers);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(727);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==KW_CONST) {
{
setState(726);
match(KW_CONST);
}
}
setState(730);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==KW_ASYNC) {
{
setState(729);
match(KW_ASYNC);
}
}
setState(733);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==KW_UNSAFE) {
{
setState(732);
match(KW_UNSAFE);
}
}
setState(739);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==KW_EXTERN) {
{
setState(735);
match(KW_EXTERN);
setState(737);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==STRING_LITERAL || _la==RAW_STRING_LITERAL) {
{
setState(736);
abi();
}
}
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class AbiContext extends ParserRuleContext {
public TerminalNode STRING_LITERAL() { return getToken(RustParser.STRING_LITERAL, 0); }
public TerminalNode RAW_STRING_LITERAL() { return getToken(RustParser.RAW_STRING_LITERAL, 0); }
public AbiContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_abi; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterAbi(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitAbi(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitAbi(this);
else return visitor.visitChildren(this);
}
}
public final AbiContext abi() throws RecognitionException {
AbiContext _localctx = new AbiContext(_ctx, getState());
enterRule(_localctx, 56, RULE_abi);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(741);
_la = _input.LA(1);
if ( !(_la==STRING_LITERAL || _la==RAW_STRING_LITERAL) ) {
_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;
}
@SuppressWarnings("CheckReturnValue")
public static class FunctionParametersContext extends ParserRuleContext {
public SelfParamContext selfParam() {
return getRuleContext(SelfParamContext.class,0);
}
public List COMMA() { return getTokens(RustParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(RustParser.COMMA, i);
}
public List functionParam() {
return getRuleContexts(FunctionParamContext.class);
}
public FunctionParamContext functionParam(int i) {
return getRuleContext(FunctionParamContext.class,i);
}
public FunctionParametersContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_functionParameters; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterFunctionParameters(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitFunctionParameters(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitFunctionParameters(this);
else return visitor.visitChildren(this);
}
}
public final FunctionParametersContext functionParameters() throws RecognitionException {
FunctionParametersContext _localctx = new FunctionParametersContext(_ctx, getState());
enterRule(_localctx, 58, RULE_functionParameters);
int _la;
try {
int _alt;
setState(763);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,62,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(743);
selfParam();
setState(745);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(744);
match(COMMA);
}
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(750);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,59,_ctx) ) {
case 1:
{
setState(747);
selfParam();
setState(748);
match(COMMA);
}
break;
}
setState(752);
functionParam();
setState(757);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,60,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(753);
match(COMMA);
setState(754);
functionParam();
}
}
}
setState(759);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,60,_ctx);
}
setState(761);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(760);
match(COMMA);
}
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SelfParamContext extends ParserRuleContext {
public ShorthandSelfContext shorthandSelf() {
return getRuleContext(ShorthandSelfContext.class,0);
}
public TypedSelfContext typedSelf() {
return getRuleContext(TypedSelfContext.class,0);
}
public List outerAttribute() {
return getRuleContexts(OuterAttributeContext.class);
}
public OuterAttributeContext outerAttribute(int i) {
return getRuleContext(OuterAttributeContext.class,i);
}
public SelfParamContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_selfParam; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterSelfParam(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitSelfParam(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitSelfParam(this);
else return visitor.visitChildren(this);
}
}
public final SelfParamContext selfParam() throws RecognitionException {
SelfParamContext _localctx = new SelfParamContext(_ctx, getState());
enterRule(_localctx, 60, RULE_selfParam);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(768);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==POUND) {
{
{
setState(765);
outerAttribute();
}
}
setState(770);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(773);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,64,_ctx) ) {
case 1:
{
setState(771);
shorthandSelf();
}
break;
case 2:
{
setState(772);
typedSelf();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ShorthandSelfContext extends ParserRuleContext {
public TerminalNode KW_SELFVALUE() { return getToken(RustParser.KW_SELFVALUE, 0); }
public TerminalNode AND() { return getToken(RustParser.AND, 0); }
public TerminalNode KW_MUT() { return getToken(RustParser.KW_MUT, 0); }
public LifetimeContext lifetime() {
return getRuleContext(LifetimeContext.class,0);
}
public ShorthandSelfContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_shorthandSelf; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterShorthandSelf(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitShorthandSelf(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitShorthandSelf(this);
else return visitor.visitChildren(this);
}
}
public final ShorthandSelfContext shorthandSelf() throws RecognitionException {
ShorthandSelfContext _localctx = new ShorthandSelfContext(_ctx, getState());
enterRule(_localctx, 62, RULE_shorthandSelf);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(779);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AND) {
{
setState(775);
match(AND);
setState(777);
_errHandler.sync(this);
_la = _input.LA(1);
if (((((_la - 53)) & ~0x3f) == 0 && ((1L << (_la - 53)) & 268435461L) != 0)) {
{
setState(776);
lifetime();
}
}
}
}
setState(782);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==KW_MUT) {
{
setState(781);
match(KW_MUT);
}
}
setState(784);
match(KW_SELFVALUE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class TypedSelfContext extends ParserRuleContext {
public TerminalNode KW_SELFVALUE() { return getToken(RustParser.KW_SELFVALUE, 0); }
public TerminalNode COLON() { return getToken(RustParser.COLON, 0); }
public Type_Context type_() {
return getRuleContext(Type_Context.class,0);
}
public TerminalNode KW_MUT() { return getToken(RustParser.KW_MUT, 0); }
public TypedSelfContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typedSelf; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterTypedSelf(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitTypedSelf(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitTypedSelf(this);
else return visitor.visitChildren(this);
}
}
public final TypedSelfContext typedSelf() throws RecognitionException {
TypedSelfContext _localctx = new TypedSelfContext(_ctx, getState());
enterRule(_localctx, 64, RULE_typedSelf);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(787);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==KW_MUT) {
{
setState(786);
match(KW_MUT);
}
}
setState(789);
match(KW_SELFVALUE);
setState(790);
match(COLON);
setState(791);
type_();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class FunctionParamContext extends ParserRuleContext {
public FunctionParamPatternContext functionParamPattern() {
return getRuleContext(FunctionParamPatternContext.class,0);
}
public TerminalNode DOTDOTDOT() { return getToken(RustParser.DOTDOTDOT, 0); }
public Type_Context type_() {
return getRuleContext(Type_Context.class,0);
}
public List outerAttribute() {
return getRuleContexts(OuterAttributeContext.class);
}
public OuterAttributeContext outerAttribute(int i) {
return getRuleContext(OuterAttributeContext.class,i);
}
public FunctionParamContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_functionParam; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterFunctionParam(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitFunctionParam(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitFunctionParam(this);
else return visitor.visitChildren(this);
}
}
public final FunctionParamContext functionParam() throws RecognitionException {
FunctionParamContext _localctx = new FunctionParamContext(_ctx, getState());
enterRule(_localctx, 66, RULE_functionParam);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(796);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==POUND) {
{
{
setState(793);
outerAttribute();
}
}
setState(798);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(802);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,70,_ctx) ) {
case 1:
{
setState(799);
functionParamPattern();
}
break;
case 2:
{
setState(800);
match(DOTDOTDOT);
}
break;
case 3:
{
setState(801);
type_();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class FunctionParamPatternContext extends ParserRuleContext {
public PatternContext pattern() {
return getRuleContext(PatternContext.class,0);
}
public TerminalNode COLON() { return getToken(RustParser.COLON, 0); }
public Type_Context type_() {
return getRuleContext(Type_Context.class,0);
}
public TerminalNode DOTDOTDOT() { return getToken(RustParser.DOTDOTDOT, 0); }
public FunctionParamPatternContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_functionParamPattern; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterFunctionParamPattern(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitFunctionParamPattern(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitFunctionParamPattern(this);
else return visitor.visitChildren(this);
}
}
public final FunctionParamPatternContext functionParamPattern() throws RecognitionException {
FunctionParamPatternContext _localctx = new FunctionParamPatternContext(_ctx, getState());
enterRule(_localctx, 68, RULE_functionParamPattern);
try {
enterOuterAlt(_localctx, 1);
{
setState(804);
pattern();
setState(805);
match(COLON);
setState(808);
_errHandler.sync(this);
switch (_input.LA(1)) {
case KW_CRATE:
case KW_EXTERN:
case KW_FN:
case KW_FOR:
case KW_IMPL:
case KW_SELFVALUE:
case KW_SELFTYPE:
case KW_SUPER:
case KW_UNSAFE:
case KW_DYN:
case KW_STATICLIFETIME:
case KW_MACRORULES:
case KW_UNDERLINELIFETIME:
case KW_DOLLARCRATE:
case NON_KEYWORD_IDENTIFIER:
case RAW_IDENTIFIER:
case LIFETIME_OR_LABEL:
case STAR:
case NOT:
case AND:
case LT:
case UNDERSCORE:
case PATHSEP:
case QUESTION:
case LSQUAREBRACKET:
case LPAREN:
{
setState(806);
type_();
}
break;
case DOTDOTDOT:
{
setState(807);
match(DOTDOTDOT);
}
break;
default:
throw new NoViableAltException(this);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class FunctionReturnTypeContext extends ParserRuleContext {
public TerminalNode RARROW() { return getToken(RustParser.RARROW, 0); }
public Type_Context type_() {
return getRuleContext(Type_Context.class,0);
}
public FunctionReturnTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_functionReturnType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterFunctionReturnType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitFunctionReturnType(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitFunctionReturnType(this);
else return visitor.visitChildren(this);
}
}
public final FunctionReturnTypeContext functionReturnType() throws RecognitionException {
FunctionReturnTypeContext _localctx = new FunctionReturnTypeContext(_ctx, getState());
enterRule(_localctx, 70, RULE_functionReturnType);
try {
enterOuterAlt(_localctx, 1);
{
setState(810);
match(RARROW);
setState(811);
type_();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class TypeAliasContext extends ParserRuleContext {
public TerminalNode KW_TYPE() { return getToken(RustParser.KW_TYPE, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode SEMI() { return getToken(RustParser.SEMI, 0); }
public GenericParamsContext genericParams() {
return getRuleContext(GenericParamsContext.class,0);
}
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public TerminalNode EQ() { return getToken(RustParser.EQ, 0); }
public Type_Context type_() {
return getRuleContext(Type_Context.class,0);
}
public TypeAliasContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeAlias; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterTypeAlias(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitTypeAlias(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitTypeAlias(this);
else return visitor.visitChildren(this);
}
}
public final TypeAliasContext typeAlias() throws RecognitionException {
TypeAliasContext _localctx = new TypeAliasContext(_ctx, getState());
enterRule(_localctx, 72, RULE_typeAlias);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(813);
match(KW_TYPE);
setState(814);
identifier();
setState(816);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(815);
genericParams();
}
}
setState(819);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==KW_WHERE) {
{
setState(818);
whereClause();
}
}
setState(823);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQ) {
{
setState(821);
match(EQ);
setState(822);
type_();
}
}
setState(825);
match(SEMI);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Struct_Context extends ParserRuleContext {
public StructStructContext structStruct() {
return getRuleContext(StructStructContext.class,0);
}
public TupleStructContext tupleStruct() {
return getRuleContext(TupleStructContext.class,0);
}
public Struct_Context(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_struct_; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterStruct_(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitStruct_(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitStruct_(this);
else return visitor.visitChildren(this);
}
}
public final Struct_Context struct_() throws RecognitionException {
Struct_Context _localctx = new Struct_Context(_ctx, getState());
enterRule(_localctx, 74, RULE_struct_);
try {
setState(829);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,75,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(827);
structStruct();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(828);
tupleStruct();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class StructStructContext extends ParserRuleContext {
public TerminalNode KW_STRUCT() { return getToken(RustParser.KW_STRUCT, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode LCURLYBRACE() { return getToken(RustParser.LCURLYBRACE, 0); }
public TerminalNode RCURLYBRACE() { return getToken(RustParser.RCURLYBRACE, 0); }
public TerminalNode SEMI() { return getToken(RustParser.SEMI, 0); }
public GenericParamsContext genericParams() {
return getRuleContext(GenericParamsContext.class,0);
}
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public StructFieldsContext structFields() {
return getRuleContext(StructFieldsContext.class,0);
}
public StructStructContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_structStruct; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterStructStruct(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitStructStruct(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitStructStruct(this);
else return visitor.visitChildren(this);
}
}
public final StructStructContext structStruct() throws RecognitionException {
StructStructContext _localctx = new StructStructContext(_ctx, getState());
enterRule(_localctx, 76, RULE_structStruct);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(831);
match(KW_STRUCT);
setState(832);
identifier();
setState(834);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(833);
genericParams();
}
}
setState(837);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==KW_WHERE) {
{
setState(836);
whereClause();
}
}
setState(845);
_errHandler.sync(this);
switch (_input.LA(1)) {
case LCURLYBRACE:
{
setState(839);
match(LCURLYBRACE);
setState(841);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 450359962739146752L) != 0) || _la==POUND) {
{
setState(840);
structFields();
}
}
setState(843);
match(RCURLYBRACE);
}
break;
case SEMI:
{
setState(844);
match(SEMI);
}
break;
default:
throw new NoViableAltException(this);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class TupleStructContext extends ParserRuleContext {
public TerminalNode KW_STRUCT() { return getToken(RustParser.KW_STRUCT, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode LPAREN() { return getToken(RustParser.LPAREN, 0); }
public TerminalNode RPAREN() { return getToken(RustParser.RPAREN, 0); }
public TerminalNode SEMI() { return getToken(RustParser.SEMI, 0); }
public GenericParamsContext genericParams() {
return getRuleContext(GenericParamsContext.class,0);
}
public TupleFieldsContext tupleFields() {
return getRuleContext(TupleFieldsContext.class,0);
}
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public TupleStructContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_tupleStruct; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterTupleStruct(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitTupleStruct(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitTupleStruct(this);
else return visitor.visitChildren(this);
}
}
public final TupleStructContext tupleStruct() throws RecognitionException {
TupleStructContext _localctx = new TupleStructContext(_ctx, getState());
enterRule(_localctx, 78, RULE_tupleStruct);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(847);
match(KW_STRUCT);
setState(848);
identifier();
setState(850);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(849);
genericParams();
}
}
setState(852);
match(LPAREN);
setState(854);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 567453832542432544L) != 0) || ((((_la - 81)) & ~0x3f) == 0 && ((1L << (_la - 81)) & 363114855924105L) != 0)) {
{
setState(853);
tupleFields();
}
}
setState(856);
match(RPAREN);
setState(858);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==KW_WHERE) {
{
setState(857);
whereClause();
}
}
setState(860);
match(SEMI);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class StructFieldsContext extends ParserRuleContext {
public List structField() {
return getRuleContexts(StructFieldContext.class);
}
public StructFieldContext structField(int i) {
return getRuleContext(StructFieldContext.class,i);
}
public List COMMA() { return getTokens(RustParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(RustParser.COMMA, i);
}
public StructFieldsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_structFields; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterStructFields(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitStructFields(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitStructFields(this);
else return visitor.visitChildren(this);
}
}
public final StructFieldsContext structFields() throws RecognitionException {
StructFieldsContext _localctx = new StructFieldsContext(_ctx, getState());
enterRule(_localctx, 80, RULE_structFields);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(862);
structField();
setState(867);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,83,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(863);
match(COMMA);
setState(864);
structField();
}
}
}
setState(869);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,83,_ctx);
}
setState(871);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(870);
match(COMMA);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class StructFieldContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode COLON() { return getToken(RustParser.COLON, 0); }
public Type_Context type_() {
return getRuleContext(Type_Context.class,0);
}
public List outerAttribute() {
return getRuleContexts(OuterAttributeContext.class);
}
public OuterAttributeContext outerAttribute(int i) {
return getRuleContext(OuterAttributeContext.class,i);
}
public VisibilityContext visibility() {
return getRuleContext(VisibilityContext.class,0);
}
public StructFieldContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_structField; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterStructField(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitStructField(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitStructField(this);
else return visitor.visitChildren(this);
}
}
public final StructFieldContext structField() throws RecognitionException {
StructFieldContext _localctx = new StructFieldContext(_ctx, getState());
enterRule(_localctx, 82, RULE_structField);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(876);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==POUND) {
{
{
setState(873);
outerAttribute();
}
}
setState(878);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(880);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==KW_PUB) {
{
setState(879);
visibility();
}
}
setState(882);
identifier();
setState(883);
match(COLON);
setState(884);
type_();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class TupleFieldsContext extends ParserRuleContext {
public List tupleField() {
return getRuleContexts(TupleFieldContext.class);
}
public TupleFieldContext tupleField(int i) {
return getRuleContext(TupleFieldContext.class,i);
}
public List COMMA() { return getTokens(RustParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(RustParser.COMMA, i);
}
public TupleFieldsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_tupleFields; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterTupleFields(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitTupleFields(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitTupleFields(this);
else return visitor.visitChildren(this);
}
}
public final TupleFieldsContext tupleFields() throws RecognitionException {
TupleFieldsContext _localctx = new TupleFieldsContext(_ctx, getState());
enterRule(_localctx, 84, RULE_tupleFields);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(886);
tupleField();
setState(891);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,87,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(887);
match(COMMA);
setState(888);
tupleField();
}
}
}
setState(893);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,87,_ctx);
}
setState(895);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(894);
match(COMMA);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class TupleFieldContext extends ParserRuleContext {
public Type_Context type_() {
return getRuleContext(Type_Context.class,0);
}
public List outerAttribute() {
return getRuleContexts(OuterAttributeContext.class);
}
public OuterAttributeContext outerAttribute(int i) {
return getRuleContext(OuterAttributeContext.class,i);
}
public VisibilityContext visibility() {
return getRuleContext(VisibilityContext.class,0);
}
public TupleFieldContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_tupleField; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterTupleField(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitTupleField(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitTupleField(this);
else return visitor.visitChildren(this);
}
}
public final TupleFieldContext tupleField() throws RecognitionException {
TupleFieldContext _localctx = new TupleFieldContext(_ctx, getState());
enterRule(_localctx, 86, RULE_tupleField);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(900);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==POUND) {
{
{
setState(897);
outerAttribute();
}
}
setState(902);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(904);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==KW_PUB) {
{
setState(903);
visibility();
}
}
setState(906);
type_();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class EnumerationContext extends ParserRuleContext {
public TerminalNode KW_ENUM() { return getToken(RustParser.KW_ENUM, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode LCURLYBRACE() { return getToken(RustParser.LCURLYBRACE, 0); }
public TerminalNode RCURLYBRACE() { return getToken(RustParser.RCURLYBRACE, 0); }
public GenericParamsContext genericParams() {
return getRuleContext(GenericParamsContext.class,0);
}
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public EnumItemsContext enumItems() {
return getRuleContext(EnumItemsContext.class,0);
}
public EnumerationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_enumeration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterEnumeration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitEnumeration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitEnumeration(this);
else return visitor.visitChildren(this);
}
}
public final EnumerationContext enumeration() throws RecognitionException {
EnumerationContext _localctx = new EnumerationContext(_ctx, getState());
enterRule(_localctx, 88, RULE_enumeration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(908);
match(KW_ENUM);
setState(909);
identifier();
setState(911);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(910);
genericParams();
}
}
setState(914);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==KW_WHERE) {
{
setState(913);
whereClause();
}
}
setState(916);
match(LCURLYBRACE);
setState(918);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 450359962739146752L) != 0) || _la==POUND) {
{
setState(917);
enumItems();
}
}
setState(920);
match(RCURLYBRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class EnumItemsContext extends ParserRuleContext {
public List enumItem() {
return getRuleContexts(EnumItemContext.class);
}
public EnumItemContext enumItem(int i) {
return getRuleContext(EnumItemContext.class,i);
}
public List COMMA() { return getTokens(RustParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(RustParser.COMMA, i);
}
public EnumItemsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_enumItems; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterEnumItems(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitEnumItems(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitEnumItems(this);
else return visitor.visitChildren(this);
}
}
public final EnumItemsContext enumItems() throws RecognitionException {
EnumItemsContext _localctx = new EnumItemsContext(_ctx, getState());
enterRule(_localctx, 90, RULE_enumItems);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(922);
enumItem();
setState(927);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,94,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(923);
match(COMMA);
setState(924);
enumItem();
}
}
}
setState(929);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,94,_ctx);
}
setState(931);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(930);
match(COMMA);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class EnumItemContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public List outerAttribute() {
return getRuleContexts(OuterAttributeContext.class);
}
public OuterAttributeContext outerAttribute(int i) {
return getRuleContext(OuterAttributeContext.class,i);
}
public VisibilityContext visibility() {
return getRuleContext(VisibilityContext.class,0);
}
public EnumItemTupleContext enumItemTuple() {
return getRuleContext(EnumItemTupleContext.class,0);
}
public EnumItemStructContext enumItemStruct() {
return getRuleContext(EnumItemStructContext.class,0);
}
public EnumItemDiscriminantContext enumItemDiscriminant() {
return getRuleContext(EnumItemDiscriminantContext.class,0);
}
public EnumItemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_enumItem; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterEnumItem(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitEnumItem(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitEnumItem(this);
else return visitor.visitChildren(this);
}
}
public final EnumItemContext enumItem() throws RecognitionException {
EnumItemContext _localctx = new EnumItemContext(_ctx, getState());
enterRule(_localctx, 92, RULE_enumItem);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(936);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==POUND) {
{
{
setState(933);
outerAttribute();
}
}
setState(938);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(940);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==KW_PUB) {
{
setState(939);
visibility();
}
}
setState(942);
identifier();
setState(946);
_errHandler.sync(this);
switch (_input.LA(1)) {
case LPAREN:
{
setState(943);
enumItemTuple();
}
break;
case LCURLYBRACE:
{
setState(944);
enumItemStruct();
}
break;
case EQ:
{
setState(945);
enumItemDiscriminant();
}
break;
case COMMA:
case RCURLYBRACE:
break;
default:
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class EnumItemTupleContext extends ParserRuleContext {
public TerminalNode LPAREN() { return getToken(RustParser.LPAREN, 0); }
public TerminalNode RPAREN() { return getToken(RustParser.RPAREN, 0); }
public TupleFieldsContext tupleFields() {
return getRuleContext(TupleFieldsContext.class,0);
}
public EnumItemTupleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_enumItemTuple; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterEnumItemTuple(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitEnumItemTuple(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitEnumItemTuple(this);
else return visitor.visitChildren(this);
}
}
public final EnumItemTupleContext enumItemTuple() throws RecognitionException {
EnumItemTupleContext _localctx = new EnumItemTupleContext(_ctx, getState());
enterRule(_localctx, 94, RULE_enumItemTuple);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(948);
match(LPAREN);
setState(950);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 567453832542432544L) != 0) || ((((_la - 81)) & ~0x3f) == 0 && ((1L << (_la - 81)) & 363114855924105L) != 0)) {
{
setState(949);
tupleFields();
}
}
setState(952);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class EnumItemStructContext extends ParserRuleContext {
public TerminalNode LCURLYBRACE() { return getToken(RustParser.LCURLYBRACE, 0); }
public TerminalNode RCURLYBRACE() { return getToken(RustParser.RCURLYBRACE, 0); }
public StructFieldsContext structFields() {
return getRuleContext(StructFieldsContext.class,0);
}
public EnumItemStructContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_enumItemStruct; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterEnumItemStruct(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitEnumItemStruct(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitEnumItemStruct(this);
else return visitor.visitChildren(this);
}
}
public final EnumItemStructContext enumItemStruct() throws RecognitionException {
EnumItemStructContext _localctx = new EnumItemStructContext(_ctx, getState());
enterRule(_localctx, 96, RULE_enumItemStruct);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(954);
match(LCURLYBRACE);
setState(956);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 450359962739146752L) != 0) || _la==POUND) {
{
setState(955);
structFields();
}
}
setState(958);
match(RCURLYBRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class EnumItemDiscriminantContext extends ParserRuleContext {
public TerminalNode EQ() { return getToken(RustParser.EQ, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public EnumItemDiscriminantContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_enumItemDiscriminant; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterEnumItemDiscriminant(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitEnumItemDiscriminant(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitEnumItemDiscriminant(this);
else return visitor.visitChildren(this);
}
}
public final EnumItemDiscriminantContext enumItemDiscriminant() throws RecognitionException {
EnumItemDiscriminantContext _localctx = new EnumItemDiscriminantContext(_ctx, getState());
enterRule(_localctx, 98, RULE_enumItemDiscriminant);
try {
enterOuterAlt(_localctx, 1);
{
setState(960);
match(EQ);
setState(961);
expression(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Union_Context extends ParserRuleContext {
public TerminalNode KW_UNION() { return getToken(RustParser.KW_UNION, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode LCURLYBRACE() { return getToken(RustParser.LCURLYBRACE, 0); }
public StructFieldsContext structFields() {
return getRuleContext(StructFieldsContext.class,0);
}
public TerminalNode RCURLYBRACE() { return getToken(RustParser.RCURLYBRACE, 0); }
public GenericParamsContext genericParams() {
return getRuleContext(GenericParamsContext.class,0);
}
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public Union_Context(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_union_; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterUnion_(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitUnion_(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitUnion_(this);
else return visitor.visitChildren(this);
}
}
public final Union_Context union_() throws RecognitionException {
Union_Context _localctx = new Union_Context(_ctx, getState());
enterRule(_localctx, 100, RULE_union_);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(963);
match(KW_UNION);
setState(964);
identifier();
setState(966);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(965);
genericParams();
}
}
setState(969);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==KW_WHERE) {
{
setState(968);
whereClause();
}
}
setState(971);
match(LCURLYBRACE);
setState(972);
structFields();
setState(973);
match(RCURLYBRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ConstantItemContext extends ParserRuleContext {
public TerminalNode KW_CONST() { return getToken(RustParser.KW_CONST, 0); }
public TerminalNode COLON() { return getToken(RustParser.COLON, 0); }
public Type_Context type_() {
return getRuleContext(Type_Context.class,0);
}
public TerminalNode SEMI() { return getToken(RustParser.SEMI, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode UNDERSCORE() { return getToken(RustParser.UNDERSCORE, 0); }
public TerminalNode EQ() { return getToken(RustParser.EQ, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public ConstantItemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_constantItem; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterConstantItem(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitConstantItem(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitConstantItem(this);
else return visitor.visitChildren(this);
}
}
public final ConstantItemContext constantItem() throws RecognitionException {
ConstantItemContext _localctx = new ConstantItemContext(_ctx, getState());
enterRule(_localctx, 102, RULE_constantItem);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(975);
match(KW_CONST);
setState(978);
_errHandler.sync(this);
switch (_input.LA(1)) {
case KW_MACRORULES:
case NON_KEYWORD_IDENTIFIER:
case RAW_IDENTIFIER:
{
setState(976);
identifier();
}
break;
case UNDERSCORE:
{
setState(977);
match(UNDERSCORE);
}
break;
default:
throw new NoViableAltException(this);
}
setState(980);
match(COLON);
setState(981);
type_();
setState(984);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQ) {
{
setState(982);
match(EQ);
setState(983);
expression(0);
}
}
setState(986);
match(SEMI);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class StaticItemContext extends ParserRuleContext {
public TerminalNode KW_STATIC() { return getToken(RustParser.KW_STATIC, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode COLON() { return getToken(RustParser.COLON, 0); }
public Type_Context type_() {
return getRuleContext(Type_Context.class,0);
}
public TerminalNode SEMI() { return getToken(RustParser.SEMI, 0); }
public TerminalNode KW_MUT() { return getToken(RustParser.KW_MUT, 0); }
public TerminalNode EQ() { return getToken(RustParser.EQ, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public StaticItemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_staticItem; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterStaticItem(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitStaticItem(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitStaticItem(this);
else return visitor.visitChildren(this);
}
}
public final StaticItemContext staticItem() throws RecognitionException {
StaticItemContext _localctx = new StaticItemContext(_ctx, getState());
enterRule(_localctx, 104, RULE_staticItem);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(988);
match(KW_STATIC);
setState(990);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==KW_MUT) {
{
setState(989);
match(KW_MUT);
}
}
setState(992);
identifier();
setState(993);
match(COLON);
setState(994);
type_();
setState(997);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQ) {
{
setState(995);
match(EQ);
setState(996);
expression(0);
}
}
setState(999);
match(SEMI);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Trait_Context extends ParserRuleContext {
public TerminalNode KW_TRAIT() { return getToken(RustParser.KW_TRAIT, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode LCURLYBRACE() { return getToken(RustParser.LCURLYBRACE, 0); }
public TerminalNode RCURLYBRACE() { return getToken(RustParser.RCURLYBRACE, 0); }
public TerminalNode KW_UNSAFE() { return getToken(RustParser.KW_UNSAFE, 0); }
public GenericParamsContext genericParams() {
return getRuleContext(GenericParamsContext.class,0);
}
public TerminalNode COLON() { return getToken(RustParser.COLON, 0); }
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public List innerAttribute() {
return getRuleContexts(InnerAttributeContext.class);
}
public InnerAttributeContext innerAttribute(int i) {
return getRuleContext(InnerAttributeContext.class,i);
}
public List associatedItem() {
return getRuleContexts(AssociatedItemContext.class);
}
public AssociatedItemContext associatedItem(int i) {
return getRuleContext(AssociatedItemContext.class,i);
}
public TypeParamBoundsContext typeParamBounds() {
return getRuleContext(TypeParamBoundsContext.class,0);
}
public Trait_Context(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_trait_; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterTrait_(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitTrait_(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitTrait_(this);
else return visitor.visitChildren(this);
}
}
public final Trait_Context trait_() throws RecognitionException {
Trait_Context _localctx = new Trait_Context(_ctx, getState());
enterRule(_localctx, 106, RULE_trait_);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1002);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==KW_UNSAFE) {
{
setState(1001);
match(KW_UNSAFE);
}
}
setState(1004);
match(KW_TRAIT);
setState(1005);
identifier();
setState(1007);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(1006);
genericParams();
}
}
setState(1013);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COLON) {
{
setState(1009);
match(COLON);
setState(1011);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 567453553367451680L) != 0) || ((((_la - 81)) & ~0x3f) == 0 && ((1L << (_la - 81)) & 290545947639809L) != 0)) {
{
setState(1010);
typeParamBounds();
}
}
}
}
setState(1016);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==KW_WHERE) {
{
setState(1015);
whereClause();
}
}
setState(1018);
match(LCURLYBRACE);
setState(1022);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,112,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1019);
innerAttribute();
}
}
}
setState(1024);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,112,_ctx);
}
setState(1028);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 522417632224216360L) != 0) || _la==PATHSEP || _la==POUND) {
{
{
setState(1025);
associatedItem();
}
}
setState(1030);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1031);
match(RCURLYBRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ImplementationContext extends ParserRuleContext {
public InherentImplContext inherentImpl() {
return getRuleContext(InherentImplContext.class,0);
}
public TraitImplContext traitImpl() {
return getRuleContext(TraitImplContext.class,0);
}
public ImplementationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_implementation; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterImplementation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitImplementation(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitImplementation(this);
else return visitor.visitChildren(this);
}
}
public final ImplementationContext implementation() throws RecognitionException {
ImplementationContext _localctx = new ImplementationContext(_ctx, getState());
enterRule(_localctx, 108, RULE_implementation);
try {
setState(1035);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,114,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1033);
inherentImpl();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1034);
traitImpl();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class InherentImplContext extends ParserRuleContext {
public TerminalNode KW_IMPL() { return getToken(RustParser.KW_IMPL, 0); }
public Type_Context type_() {
return getRuleContext(Type_Context.class,0);
}
public TerminalNode LCURLYBRACE() { return getToken(RustParser.LCURLYBRACE, 0); }
public TerminalNode RCURLYBRACE() { return getToken(RustParser.RCURLYBRACE, 0); }
public GenericParamsContext genericParams() {
return getRuleContext(GenericParamsContext.class,0);
}
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public List innerAttribute() {
return getRuleContexts(InnerAttributeContext.class);
}
public InnerAttributeContext innerAttribute(int i) {
return getRuleContext(InnerAttributeContext.class,i);
}
public List associatedItem() {
return getRuleContexts(AssociatedItemContext.class);
}
public AssociatedItemContext associatedItem(int i) {
return getRuleContext(AssociatedItemContext.class,i);
}
public InherentImplContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_inherentImpl; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterInherentImpl(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitInherentImpl(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitInherentImpl(this);
else return visitor.visitChildren(this);
}
}
public final InherentImplContext inherentImpl() throws RecognitionException {
InherentImplContext _localctx = new InherentImplContext(_ctx, getState());
enterRule(_localctx, 110, RULE_inherentImpl);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1037);
match(KW_IMPL);
setState(1039);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,115,_ctx) ) {
case 1:
{
setState(1038);
genericParams();
}
break;
}
setState(1041);
type_();
setState(1043);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==KW_WHERE) {
{
setState(1042);
whereClause();
}
}
setState(1045);
match(LCURLYBRACE);
setState(1049);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,117,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1046);
innerAttribute();
}
}
}
setState(1051);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,117,_ctx);
}
setState(1055);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 522417632224216360L) != 0) || _la==PATHSEP || _la==POUND) {
{
{
setState(1052);
associatedItem();
}
}
setState(1057);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1058);
match(RCURLYBRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class TraitImplContext extends ParserRuleContext {
public TerminalNode KW_IMPL() { return getToken(RustParser.KW_IMPL, 0); }
public TypePathContext typePath() {
return getRuleContext(TypePathContext.class,0);
}
public TerminalNode KW_FOR() { return getToken(RustParser.KW_FOR, 0); }
public Type_Context type_() {
return getRuleContext(Type_Context.class,0);
}
public TerminalNode LCURLYBRACE() { return getToken(RustParser.LCURLYBRACE, 0); }
public TerminalNode RCURLYBRACE() { return getToken(RustParser.RCURLYBRACE, 0); }
public TerminalNode KW_UNSAFE() { return getToken(RustParser.KW_UNSAFE, 0); }
public GenericParamsContext genericParams() {
return getRuleContext(GenericParamsContext.class,0);
}
public TerminalNode NOT() { return getToken(RustParser.NOT, 0); }
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public List innerAttribute() {
return getRuleContexts(InnerAttributeContext.class);
}
public InnerAttributeContext innerAttribute(int i) {
return getRuleContext(InnerAttributeContext.class,i);
}
public List associatedItem() {
return getRuleContexts(AssociatedItemContext.class);
}
public AssociatedItemContext associatedItem(int i) {
return getRuleContext(AssociatedItemContext.class,i);
}
public TraitImplContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_traitImpl; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterTraitImpl(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitTraitImpl(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitTraitImpl(this);
else return visitor.visitChildren(this);
}
}
public final TraitImplContext traitImpl() throws RecognitionException {
TraitImplContext _localctx = new TraitImplContext(_ctx, getState());
enterRule(_localctx, 112, RULE_traitImpl);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1061);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==KW_UNSAFE) {
{
setState(1060);
match(KW_UNSAFE);
}
}
setState(1063);
match(KW_IMPL);
setState(1065);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(1064);
genericParams();
}
}
setState(1068);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(1067);
match(NOT);
}
}
setState(1070);
typePath();
setState(1071);
match(KW_FOR);
setState(1072);
type_();
setState(1074);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==KW_WHERE) {
{
setState(1073);
whereClause();
}
}
setState(1076);
match(LCURLYBRACE);
setState(1080);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,123,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1077);
innerAttribute();
}
}
}
setState(1082);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,123,_ctx);
}
setState(1086);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 522417632224216360L) != 0) || _la==PATHSEP || _la==POUND) {
{
{
setState(1083);
associatedItem();
}
}
setState(1088);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1089);
match(RCURLYBRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ExternBlockContext extends ParserRuleContext {
public TerminalNode KW_EXTERN() { return getToken(RustParser.KW_EXTERN, 0); }
public TerminalNode LCURLYBRACE() { return getToken(RustParser.LCURLYBRACE, 0); }
public TerminalNode RCURLYBRACE() { return getToken(RustParser.RCURLYBRACE, 0); }
public TerminalNode KW_UNSAFE() { return getToken(RustParser.KW_UNSAFE, 0); }
public AbiContext abi() {
return getRuleContext(AbiContext.class,0);
}
public List innerAttribute() {
return getRuleContexts(InnerAttributeContext.class);
}
public InnerAttributeContext innerAttribute(int i) {
return getRuleContext(InnerAttributeContext.class,i);
}
public List externalItem() {
return getRuleContexts(ExternalItemContext.class);
}
public ExternalItemContext externalItem(int i) {
return getRuleContext(ExternalItemContext.class,i);
}
public ExternBlockContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_externBlock; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterExternBlock(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitExternBlock(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitExternBlock(this);
else return visitor.visitChildren(this);
}
}
public final ExternBlockContext externBlock() throws RecognitionException {
ExternBlockContext _localctx = new ExternBlockContext(_ctx, getState());
enterRule(_localctx, 114, RULE_externBlock);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1092);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==KW_UNSAFE) {
{
setState(1091);
match(KW_UNSAFE);
}
}
setState(1094);
match(KW_EXTERN);
setState(1096);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==STRING_LITERAL || _la==RAW_STRING_LITERAL) {
{
setState(1095);
abi();
}
}
setState(1098);
match(LCURLYBRACE);
setState(1102);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,127,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1099);
innerAttribute();
}
}
}
setState(1104);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,127,_ctx);
}
setState(1108);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 522417630143841576L) != 0) || _la==PATHSEP || _la==POUND) {
{
{
setState(1105);
externalItem();
}
}
setState(1110);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1111);
match(RCURLYBRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ExternalItemContext extends ParserRuleContext {
public MacroInvocationSemiContext macroInvocationSemi() {
return getRuleContext(MacroInvocationSemiContext.class,0);
}
public List outerAttribute() {
return getRuleContexts(OuterAttributeContext.class);
}
public OuterAttributeContext outerAttribute(int i) {
return getRuleContext(OuterAttributeContext.class,i);
}
public StaticItemContext staticItem() {
return getRuleContext(StaticItemContext.class,0);
}
public Function_Context function_() {
return getRuleContext(Function_Context.class,0);
}
public VisibilityContext visibility() {
return getRuleContext(VisibilityContext.class,0);
}
public ExternalItemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_externalItem; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterExternalItem(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitExternalItem(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitExternalItem(this);
else return visitor.visitChildren(this);
}
}
public final ExternalItemContext externalItem() throws RecognitionException {
ExternalItemContext _localctx = new ExternalItemContext(_ctx, getState());
enterRule(_localctx, 116, RULE_externalItem);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1116);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==POUND) {
{
{
setState(1113);
outerAttribute();
}
}
setState(1118);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1127);
_errHandler.sync(this);
switch (_input.LA(1)) {
case KW_CRATE:
case KW_SELFVALUE:
case KW_SUPER:
case KW_MACRORULES:
case KW_DOLLARCRATE:
case NON_KEYWORD_IDENTIFIER:
case RAW_IDENTIFIER:
case PATHSEP:
{
setState(1119);
macroInvocationSemi();
}
break;
case KW_CONST:
case KW_EXTERN:
case KW_FN:
case KW_PUB:
case KW_STATIC:
case KW_UNSAFE:
case KW_ASYNC:
{
setState(1121);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==KW_PUB) {
{
setState(1120);
visibility();
}
}
setState(1125);
_errHandler.sync(this);
switch (_input.LA(1)) {
case KW_STATIC:
{
setState(1123);
staticItem();
}
break;
case KW_CONST:
case KW_EXTERN:
case KW_FN:
case KW_UNSAFE:
case KW_ASYNC:
{
setState(1124);
function_();
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
default:
throw new NoViableAltException(this);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class GenericParamsContext extends ParserRuleContext {
public TerminalNode LT() { return getToken(RustParser.LT, 0); }
public TerminalNode GT() { return getToken(RustParser.GT, 0); }
public List genericParam() {
return getRuleContexts(GenericParamContext.class);
}
public GenericParamContext genericParam(int i) {
return getRuleContext(GenericParamContext.class,i);
}
public List COMMA() { return getTokens(RustParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(RustParser.COMMA, i);
}
public GenericParamsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_genericParams; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterGenericParams(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitGenericParams(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitGenericParams(this);
else return visitor.visitChildren(this);
}
}
public final GenericParamsContext genericParams() throws RecognitionException {
GenericParamsContext _localctx = new GenericParamsContext(_ctx, getState());
enterRule(_localctx, 118, RULE_genericParams);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1129);
match(LT);
setState(1142);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 450359962737049608L) != 0) || _la==LIFETIME_OR_LABEL || _la==POUND) {
{
setState(1135);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,133,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1130);
genericParam();
setState(1131);
match(COMMA);
}
}
}
setState(1137);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,133,_ctx);
}
setState(1138);
genericParam();
setState(1140);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(1139);
match(COMMA);
}
}
}
}
setState(1144);
match(GT);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class GenericParamContext extends ParserRuleContext {
public LifetimeParamContext lifetimeParam() {
return getRuleContext(LifetimeParamContext.class,0);
}
public TypeParamContext typeParam() {
return getRuleContext(TypeParamContext.class,0);
}
public ConstParamContext constParam() {
return getRuleContext(ConstParamContext.class,0);
}
public List outerAttribute() {
return getRuleContexts(OuterAttributeContext.class);
}
public OuterAttributeContext outerAttribute(int i) {
return getRuleContext(OuterAttributeContext.class,i);
}
public GenericParamContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_genericParam; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterGenericParam(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitGenericParam(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitGenericParam(this);
else return visitor.visitChildren(this);
}
}
public final GenericParamContext genericParam() throws RecognitionException {
GenericParamContext _localctx = new GenericParamContext(_ctx, getState());
enterRule(_localctx, 120, RULE_genericParam);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1149);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,136,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1146);
outerAttribute();
}
}
}
setState(1151);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,136,_ctx);
}
setState(1155);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,137,_ctx) ) {
case 1:
{
setState(1152);
lifetimeParam();
}
break;
case 2:
{
setState(1153);
typeParam();
}
break;
case 3:
{
setState(1154);
constParam();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class LifetimeParamContext extends ParserRuleContext {
public TerminalNode LIFETIME_OR_LABEL() { return getToken(RustParser.LIFETIME_OR_LABEL, 0); }
public OuterAttributeContext outerAttribute() {
return getRuleContext(OuterAttributeContext.class,0);
}
public TerminalNode COLON() { return getToken(RustParser.COLON, 0); }
public LifetimeBoundsContext lifetimeBounds() {
return getRuleContext(LifetimeBoundsContext.class,0);
}
public LifetimeParamContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_lifetimeParam; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterLifetimeParam(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitLifetimeParam(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitLifetimeParam(this);
else return visitor.visitChildren(this);
}
}
public final LifetimeParamContext lifetimeParam() throws RecognitionException {
LifetimeParamContext _localctx = new LifetimeParamContext(_ctx, getState());
enterRule(_localctx, 122, RULE_lifetimeParam);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1158);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==POUND) {
{
setState(1157);
outerAttribute();
}
}
setState(1160);
match(LIFETIME_OR_LABEL);
setState(1163);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COLON) {
{
setState(1161);
match(COLON);
setState(1162);
lifetimeBounds();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class TypeParamContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public OuterAttributeContext outerAttribute() {
return getRuleContext(OuterAttributeContext.class,0);
}
public TerminalNode COLON() { return getToken(RustParser.COLON, 0); }
public TerminalNode EQ() { return getToken(RustParser.EQ, 0); }
public Type_Context type_() {
return getRuleContext(Type_Context.class,0);
}
public TypeParamBoundsContext typeParamBounds() {
return getRuleContext(TypeParamBoundsContext.class,0);
}
public TypeParamContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeParam; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterTypeParam(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitTypeParam(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitTypeParam(this);
else return visitor.visitChildren(this);
}
}
public final TypeParamContext typeParam() throws RecognitionException {
TypeParamContext _localctx = new TypeParamContext(_ctx, getState());
enterRule(_localctx, 124, RULE_typeParam);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1166);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==POUND) {
{
setState(1165);
outerAttribute();
}
}
setState(1168);
identifier();
setState(1173);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COLON) {
{
setState(1169);
match(COLON);
setState(1171);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 567453553367451680L) != 0) || ((((_la - 81)) & ~0x3f) == 0 && ((1L << (_la - 81)) & 290545947639809L) != 0)) {
{
setState(1170);
typeParamBounds();
}
}
}
}
setState(1177);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQ) {
{
setState(1175);
match(EQ);
setState(1176);
type_();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ConstParamContext extends ParserRuleContext {
public TerminalNode KW_CONST() { return getToken(RustParser.KW_CONST, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode COLON() { return getToken(RustParser.COLON, 0); }
public Type_Context type_() {
return getRuleContext(Type_Context.class,0);
}
public ConstParamContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_constParam; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterConstParam(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitConstParam(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitConstParam(this);
else return visitor.visitChildren(this);
}
}
public final ConstParamContext constParam() throws RecognitionException {
ConstParamContext _localctx = new ConstParamContext(_ctx, getState());
enterRule(_localctx, 126, RULE_constParam);
try {
enterOuterAlt(_localctx, 1);
{
setState(1179);
match(KW_CONST);
setState(1180);
identifier();
setState(1181);
match(COLON);
setState(1182);
type_();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class WhereClauseContext extends ParserRuleContext {
public TerminalNode KW_WHERE() { return getToken(RustParser.KW_WHERE, 0); }
public List whereClauseItem() {
return getRuleContexts(WhereClauseItemContext.class);
}
public WhereClauseItemContext whereClauseItem(int i) {
return getRuleContext(WhereClauseItemContext.class,i);
}
public List COMMA() { return getTokens(RustParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(RustParser.COMMA, i);
}
public WhereClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_whereClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterWhereClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitWhereClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitWhereClause(this);
else return visitor.visitChildren(this);
}
}
public final WhereClauseContext whereClause() throws RecognitionException {
WhereClauseContext _localctx = new WhereClauseContext(_ctx, getState());
enterRule(_localctx, 128, RULE_whereClause);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1184);
match(KW_WHERE);
setState(1190);
_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(1185);
whereClauseItem();
setState(1186);
match(COMMA);
}
}
}
setState(1192);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,144,_ctx);
}
setState(1194);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 567453832540335392L) != 0) || ((((_la - 81)) & ~0x3f) == 0 && ((1L << (_la - 81)) & 360915832668553L) != 0)) {
{
setState(1193);
whereClauseItem();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class WhereClauseItemContext extends ParserRuleContext {
public LifetimeWhereClauseItemContext lifetimeWhereClauseItem() {
return getRuleContext(LifetimeWhereClauseItemContext.class,0);
}
public TypeBoundWhereClauseItemContext typeBoundWhereClauseItem() {
return getRuleContext(TypeBoundWhereClauseItemContext.class,0);
}
public WhereClauseItemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_whereClauseItem; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterWhereClauseItem(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitWhereClauseItem(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitWhereClauseItem(this);
else return visitor.visitChildren(this);
}
}
public final WhereClauseItemContext whereClauseItem() throws RecognitionException {
WhereClauseItemContext _localctx = new WhereClauseItemContext(_ctx, getState());
enterRule(_localctx, 130, RULE_whereClauseItem);
try {
setState(1198);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,146,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1196);
lifetimeWhereClauseItem();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1197);
typeBoundWhereClauseItem();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class LifetimeWhereClauseItemContext extends ParserRuleContext {
public LifetimeContext lifetime() {
return getRuleContext(LifetimeContext.class,0);
}
public TerminalNode COLON() { return getToken(RustParser.COLON, 0); }
public LifetimeBoundsContext lifetimeBounds() {
return getRuleContext(LifetimeBoundsContext.class,0);
}
public LifetimeWhereClauseItemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_lifetimeWhereClauseItem; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterLifetimeWhereClauseItem(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitLifetimeWhereClauseItem(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitLifetimeWhereClauseItem(this);
else return visitor.visitChildren(this);
}
}
public final LifetimeWhereClauseItemContext lifetimeWhereClauseItem() throws RecognitionException {
LifetimeWhereClauseItemContext _localctx = new LifetimeWhereClauseItemContext(_ctx, getState());
enterRule(_localctx, 132, RULE_lifetimeWhereClauseItem);
try {
enterOuterAlt(_localctx, 1);
{
setState(1200);
lifetime();
setState(1201);
match(COLON);
setState(1202);
lifetimeBounds();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class TypeBoundWhereClauseItemContext extends ParserRuleContext {
public Type_Context type_() {
return getRuleContext(Type_Context.class,0);
}
public TerminalNode COLON() { return getToken(RustParser.COLON, 0); }
public ForLifetimesContext forLifetimes() {
return getRuleContext(ForLifetimesContext.class,0);
}
public TypeParamBoundsContext typeParamBounds() {
return getRuleContext(TypeParamBoundsContext.class,0);
}
public TypeBoundWhereClauseItemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeBoundWhereClauseItem; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterTypeBoundWhereClauseItem(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitTypeBoundWhereClauseItem(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitTypeBoundWhereClauseItem(this);
else return visitor.visitChildren(this);
}
}
public final TypeBoundWhereClauseItemContext typeBoundWhereClauseItem() throws RecognitionException {
TypeBoundWhereClauseItemContext _localctx = new TypeBoundWhereClauseItemContext(_ctx, getState());
enterRule(_localctx, 134, RULE_typeBoundWhereClauseItem);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1205);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,147,_ctx) ) {
case 1:
{
setState(1204);
forLifetimes();
}
break;
}
setState(1207);
type_();
setState(1208);
match(COLON);
setState(1210);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 567453553367451680L) != 0) || ((((_la - 81)) & ~0x3f) == 0 && ((1L << (_la - 81)) & 290545947639809L) != 0)) {
{
setState(1209);
typeParamBounds();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ForLifetimesContext extends ParserRuleContext {
public TerminalNode KW_FOR() { return getToken(RustParser.KW_FOR, 0); }
public GenericParamsContext genericParams() {
return getRuleContext(GenericParamsContext.class,0);
}
public ForLifetimesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_forLifetimes; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterForLifetimes(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitForLifetimes(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitForLifetimes(this);
else return visitor.visitChildren(this);
}
}
public final ForLifetimesContext forLifetimes() throws RecognitionException {
ForLifetimesContext _localctx = new ForLifetimesContext(_ctx, getState());
enterRule(_localctx, 136, RULE_forLifetimes);
try {
enterOuterAlt(_localctx, 1);
{
setState(1212);
match(KW_FOR);
setState(1213);
genericParams();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class AssociatedItemContext extends ParserRuleContext {
public MacroInvocationSemiContext macroInvocationSemi() {
return getRuleContext(MacroInvocationSemiContext.class,0);
}
public List outerAttribute() {
return getRuleContexts(OuterAttributeContext.class);
}
public OuterAttributeContext outerAttribute(int i) {
return getRuleContext(OuterAttributeContext.class,i);
}
public TypeAliasContext typeAlias() {
return getRuleContext(TypeAliasContext.class,0);
}
public ConstantItemContext constantItem() {
return getRuleContext(ConstantItemContext.class,0);
}
public Function_Context function_() {
return getRuleContext(Function_Context.class,0);
}
public VisibilityContext visibility() {
return getRuleContext(VisibilityContext.class,0);
}
public AssociatedItemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_associatedItem; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterAssociatedItem(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitAssociatedItem(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitAssociatedItem(this);
else return visitor.visitChildren(this);
}
}
public final AssociatedItemContext associatedItem() throws RecognitionException {
AssociatedItemContext _localctx = new AssociatedItemContext(_ctx, getState());
enterRule(_localctx, 138, RULE_associatedItem);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1218);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==POUND) {
{
{
setState(1215);
outerAttribute();
}
}
setState(1220);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1230);
_errHandler.sync(this);
switch (_input.LA(1)) {
case KW_CRATE:
case KW_SELFVALUE:
case KW_SUPER:
case KW_MACRORULES:
case KW_DOLLARCRATE:
case NON_KEYWORD_IDENTIFIER:
case RAW_IDENTIFIER:
case PATHSEP:
{
setState(1221);
macroInvocationSemi();
}
break;
case KW_CONST:
case KW_EXTERN:
case KW_FN:
case KW_PUB:
case KW_TYPE:
case KW_UNSAFE:
case KW_ASYNC:
{
setState(1223);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==KW_PUB) {
{
setState(1222);
visibility();
}
}
setState(1228);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,151,_ctx) ) {
case 1:
{
setState(1225);
typeAlias();
}
break;
case 2:
{
setState(1226);
constantItem();
}
break;
case 3:
{
setState(1227);
function_();
}
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;
}
@SuppressWarnings("CheckReturnValue")
public static class InnerAttributeContext extends ParserRuleContext {
public TerminalNode POUND() { return getToken(RustParser.POUND, 0); }
public TerminalNode NOT() { return getToken(RustParser.NOT, 0); }
public TerminalNode LSQUAREBRACKET() { return getToken(RustParser.LSQUAREBRACKET, 0); }
public AttrContext attr() {
return getRuleContext(AttrContext.class,0);
}
public TerminalNode RSQUAREBRACKET() { return getToken(RustParser.RSQUAREBRACKET, 0); }
public InnerAttributeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_innerAttribute; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterInnerAttribute(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitInnerAttribute(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitInnerAttribute(this);
else return visitor.visitChildren(this);
}
}
public final InnerAttributeContext innerAttribute() throws RecognitionException {
InnerAttributeContext _localctx = new InnerAttributeContext(_ctx, getState());
enterRule(_localctx, 140, RULE_innerAttribute);
try {
enterOuterAlt(_localctx, 1);
{
setState(1232);
match(POUND);
setState(1233);
match(NOT);
setState(1234);
match(LSQUAREBRACKET);
setState(1235);
attr();
setState(1236);
match(RSQUAREBRACKET);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class OuterAttributeContext extends ParserRuleContext {
public TerminalNode POUND() { return getToken(RustParser.POUND, 0); }
public TerminalNode LSQUAREBRACKET() { return getToken(RustParser.LSQUAREBRACKET, 0); }
public AttrContext attr() {
return getRuleContext(AttrContext.class,0);
}
public TerminalNode RSQUAREBRACKET() { return getToken(RustParser.RSQUAREBRACKET, 0); }
public OuterAttributeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_outerAttribute; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterOuterAttribute(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitOuterAttribute(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitOuterAttribute(this);
else return visitor.visitChildren(this);
}
}
public final OuterAttributeContext outerAttribute() throws RecognitionException {
OuterAttributeContext _localctx = new OuterAttributeContext(_ctx, getState());
enterRule(_localctx, 142, RULE_outerAttribute);
try {
enterOuterAlt(_localctx, 1);
{
setState(1238);
match(POUND);
setState(1239);
match(LSQUAREBRACKET);
setState(1240);
attr();
setState(1241);
match(RSQUAREBRACKET);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class AttrContext extends ParserRuleContext {
public SimplePathContext simplePath() {
return getRuleContext(SimplePathContext.class,0);
}
public AttrInputContext attrInput() {
return getRuleContext(AttrInputContext.class,0);
}
public AttrContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_attr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterAttr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitAttr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitAttr(this);
else return visitor.visitChildren(this);
}
}
public final AttrContext attr() throws RecognitionException {
AttrContext _localctx = new AttrContext(_ctx, getState());
enterRule(_localctx, 144, RULE_attr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1243);
simplePath();
setState(1245);
_errHandler.sync(this);
_la = _input.LA(1);
if (((((_la - 103)) & ~0x3f) == 0 && ((1L << (_la - 103)) & 88080385L) != 0)) {
{
setState(1244);
attrInput();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class AttrInputContext extends ParserRuleContext {
public DelimTokenTreeContext delimTokenTree() {
return getRuleContext(DelimTokenTreeContext.class,0);
}
public TerminalNode EQ() { return getToken(RustParser.EQ, 0); }
public LiteralExpressionContext literalExpression() {
return getRuleContext(LiteralExpressionContext.class,0);
}
public AttrInputContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_attrInput; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterAttrInput(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitAttrInput(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitAttrInput(this);
else return visitor.visitChildren(this);
}
}
public final AttrInputContext attrInput() throws RecognitionException {
AttrInputContext _localctx = new AttrInputContext(_ctx, getState());
enterRule(_localctx, 146, RULE_attrInput);
try {
setState(1250);
_errHandler.sync(this);
switch (_input.LA(1)) {
case LCURLYBRACE:
case LSQUAREBRACKET:
case LPAREN:
enterOuterAlt(_localctx, 1);
{
setState(1247);
delimTokenTree();
}
break;
case EQ:
enterOuterAlt(_localctx, 2);
{
setState(1248);
match(EQ);
setState(1249);
literalExpression();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class StatementContext extends ParserRuleContext {
public TerminalNode SEMI() { return getToken(RustParser.SEMI, 0); }
public ItemContext item() {
return getRuleContext(ItemContext.class,0);
}
public LetStatementContext letStatement() {
return getRuleContext(LetStatementContext.class,0);
}
public ExpressionStatementContext expressionStatement() {
return getRuleContext(ExpressionStatementContext.class,0);
}
public MacroInvocationSemiContext macroInvocationSemi() {
return getRuleContext(MacroInvocationSemiContext.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 RustParserListener ) ((RustParserListener)listener).enterStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitStatement(this);
else return visitor.visitChildren(this);
}
}
public final StatementContext statement() throws RecognitionException {
StatementContext _localctx = new StatementContext(_ctx, getState());
enterRule(_localctx, 148, RULE_statement);
try {
setState(1257);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,155,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1252);
match(SEMI);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1253);
item();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1254);
letStatement();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(1255);
expressionStatement();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(1256);
macroInvocationSemi();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class LetStatementContext extends ParserRuleContext {
public TerminalNode KW_LET() { return getToken(RustParser.KW_LET, 0); }
public PatternNoTopAltContext patternNoTopAlt() {
return getRuleContext(PatternNoTopAltContext.class,0);
}
public TerminalNode SEMI() { return getToken(RustParser.SEMI, 0); }
public List outerAttribute() {
return getRuleContexts(OuterAttributeContext.class);
}
public OuterAttributeContext outerAttribute(int i) {
return getRuleContext(OuterAttributeContext.class,i);
}
public TerminalNode COLON() { return getToken(RustParser.COLON, 0); }
public Type_Context type_() {
return getRuleContext(Type_Context.class,0);
}
public TerminalNode EQ() { return getToken(RustParser.EQ, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public LetStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_letStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterLetStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitLetStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitLetStatement(this);
else return visitor.visitChildren(this);
}
}
public final LetStatementContext letStatement() throws RecognitionException {
LetStatementContext _localctx = new LetStatementContext(_ctx, getState());
enterRule(_localctx, 150, RULE_letStatement);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1262);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==POUND) {
{
{
setState(1259);
outerAttribute();
}
}
setState(1264);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1265);
match(KW_LET);
setState(1266);
patternNoTopAlt();
setState(1269);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COLON) {
{
setState(1267);
match(COLON);
setState(1268);
type_();
}
}
setState(1273);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQ) {
{
setState(1271);
match(EQ);
setState(1272);
expression(0);
}
}
setState(1275);
match(SEMI);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ExpressionStatementContext extends ParserRuleContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode SEMI() { return getToken(RustParser.SEMI, 0); }
public ExpressionWithBlockContext expressionWithBlock() {
return getRuleContext(ExpressionWithBlockContext.class,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 RustParserListener ) ((RustParserListener)listener).enterExpressionStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitExpressionStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitExpressionStatement(this);
else return visitor.visitChildren(this);
}
}
public final ExpressionStatementContext expressionStatement() throws RecognitionException {
ExpressionStatementContext _localctx = new ExpressionStatementContext(_ctx, getState());
enterRule(_localctx, 152, RULE_expressionStatement);
try {
setState(1284);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,160,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1277);
expression(0);
setState(1278);
match(SEMI);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1280);
expressionWithBlock();
setState(1282);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,159,_ctx) ) {
case 1:
{
setState(1281);
match(SEMI);
}
break;
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ExpressionContext extends ParserRuleContext {
public ExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expression; }
public ExpressionContext() { }
public void copyFrom(ExpressionContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class TypeCastExpressionContext extends ExpressionContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode KW_AS() { return getToken(RustParser.KW_AS, 0); }
public TypeNoBoundsContext typeNoBounds() {
return getRuleContext(TypeNoBoundsContext.class,0);
}
public TypeCastExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterTypeCastExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitTypeCastExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitTypeCastExpression(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class PathExpression_Context extends ExpressionContext {
public PathExpressionContext pathExpression() {
return getRuleContext(PathExpressionContext.class,0);
}
public PathExpression_Context(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterPathExpression_(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitPathExpression_(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitPathExpression_(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class TupleExpressionContext extends ExpressionContext {
public TerminalNode LPAREN() { return getToken(RustParser.LPAREN, 0); }
public TerminalNode RPAREN() { return getToken(RustParser.RPAREN, 0); }
public List innerAttribute() {
return getRuleContexts(InnerAttributeContext.class);
}
public InnerAttributeContext innerAttribute(int i) {
return getRuleContext(InnerAttributeContext.class,i);
}
public TupleElementsContext tupleElements() {
return getRuleContext(TupleElementsContext.class,0);
}
public TupleExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterTupleExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitTupleExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitTupleExpression(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class IndexExpressionContext extends ExpressionContext {
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TerminalNode LSQUAREBRACKET() { return getToken(RustParser.LSQUAREBRACKET, 0); }
public TerminalNode RSQUAREBRACKET() { return getToken(RustParser.RSQUAREBRACKET, 0); }
public IndexExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterIndexExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitIndexExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitIndexExpression(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class RangeExpressionContext extends ExpressionContext {
public TerminalNode DOTDOT() { return getToken(RustParser.DOTDOT, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TerminalNode DOTDOTEQ() { return getToken(RustParser.DOTDOTEQ, 0); }
public RangeExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterRangeExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitRangeExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitRangeExpression(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class MacroInvocationAsExpressionContext extends ExpressionContext {
public MacroInvocationContext macroInvocation() {
return getRuleContext(MacroInvocationContext.class,0);
}
public MacroInvocationAsExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterMacroInvocationAsExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitMacroInvocationAsExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitMacroInvocationAsExpression(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ReturnExpressionContext extends ExpressionContext {
public TerminalNode KW_RETURN() { return getToken(RustParser.KW_RETURN, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public ReturnExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterReturnExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitReturnExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitReturnExpression(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AwaitExpressionContext extends ExpressionContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode DOT() { return getToken(RustParser.DOT, 0); }
public TerminalNode KW_AWAIT() { return getToken(RustParser.KW_AWAIT, 0); }
public AwaitExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterAwaitExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitAwaitExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitAwaitExpression(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ErrorPropagationExpressionContext extends ExpressionContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode QUESTION() { return getToken(RustParser.QUESTION, 0); }
public ErrorPropagationExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterErrorPropagationExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitErrorPropagationExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitErrorPropagationExpression(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ContinueExpressionContext extends ExpressionContext {
public TerminalNode KW_CONTINUE() { return getToken(RustParser.KW_CONTINUE, 0); }
public TerminalNode LIFETIME_OR_LABEL() { return getToken(RustParser.LIFETIME_OR_LABEL, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public ContinueExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterContinueExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitContinueExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitContinueExpression(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AssignmentExpressionContext extends ExpressionContext {
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TerminalNode EQ() { return getToken(RustParser.EQ, 0); }
public AssignmentExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterAssignmentExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitAssignmentExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitAssignmentExpression(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class MethodCallExpressionContext extends ExpressionContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode DOT() { return getToken(RustParser.DOT, 0); }
public PathExprSegmentContext pathExprSegment() {
return getRuleContext(PathExprSegmentContext.class,0);
}
public TerminalNode LPAREN() { return getToken(RustParser.LPAREN, 0); }
public TerminalNode RPAREN() { return getToken(RustParser.RPAREN, 0); }
public CallParamsContext callParams() {
return getRuleContext(CallParamsContext.class,0);
}
public MethodCallExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterMethodCallExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitMethodCallExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitMethodCallExpression(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class LiteralExpression_Context extends ExpressionContext {
public LiteralExpressionContext literalExpression() {
return getRuleContext(LiteralExpressionContext.class,0);
}
public LiteralExpression_Context(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterLiteralExpression_(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitLiteralExpression_(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitLiteralExpression_(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class StructExpression_Context extends ExpressionContext {
public StructExpressionContext structExpression() {
return getRuleContext(StructExpressionContext.class,0);
}
public StructExpression_Context(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterStructExpression_(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitStructExpression_(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitStructExpression_(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class TupleIndexingExpressionContext extends ExpressionContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode DOT() { return getToken(RustParser.DOT, 0); }
public TupleIndexContext tupleIndex() {
return getRuleContext(TupleIndexContext.class,0);
}
public TupleIndexingExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterTupleIndexingExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitTupleIndexingExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitTupleIndexingExpression(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class NegationExpressionContext extends ExpressionContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode MINUS() { return getToken(RustParser.MINUS, 0); }
public TerminalNode NOT() { return getToken(RustParser.NOT, 0); }
public NegationExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterNegationExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitNegationExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitNegationExpression(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CallExpressionContext extends ExpressionContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode LPAREN() { return getToken(RustParser.LPAREN, 0); }
public TerminalNode RPAREN() { return getToken(RustParser.RPAREN, 0); }
public CallParamsContext callParams() {
return getRuleContext(CallParamsContext.class,0);
}
public CallExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterCallExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitCallExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitCallExpression(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class LazyBooleanExpressionContext extends ExpressionContext {
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TerminalNode ANDAND() { return getToken(RustParser.ANDAND, 0); }
public TerminalNode OROR() { return getToken(RustParser.OROR, 0); }
public LazyBooleanExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterLazyBooleanExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitLazyBooleanExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitLazyBooleanExpression(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class DereferenceExpressionContext extends ExpressionContext {
public TerminalNode STAR() { return getToken(RustParser.STAR, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public DereferenceExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterDereferenceExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitDereferenceExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitDereferenceExpression(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ExpressionWithBlock_Context extends ExpressionContext {
public ExpressionWithBlockContext expressionWithBlock() {
return getRuleContext(ExpressionWithBlockContext.class,0);
}
public ExpressionWithBlock_Context(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterExpressionWithBlock_(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitExpressionWithBlock_(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitExpressionWithBlock_(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class GroupedExpressionContext extends ExpressionContext {
public TerminalNode LPAREN() { return getToken(RustParser.LPAREN, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode RPAREN() { return getToken(RustParser.RPAREN, 0); }
public List innerAttribute() {
return getRuleContexts(InnerAttributeContext.class);
}
public InnerAttributeContext innerAttribute(int i) {
return getRuleContext(InnerAttributeContext.class,i);
}
public GroupedExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterGroupedExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitGroupedExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitGroupedExpression(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class BreakExpressionContext extends ExpressionContext {
public TerminalNode KW_BREAK() { return getToken(RustParser.KW_BREAK, 0); }
public TerminalNode LIFETIME_OR_LABEL() { return getToken(RustParser.LIFETIME_OR_LABEL, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public BreakExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterBreakExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitBreakExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitBreakExpression(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ArithmeticOrLogicalExpressionContext extends ExpressionContext {
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TerminalNode STAR() { return getToken(RustParser.STAR, 0); }
public TerminalNode SLASH() { return getToken(RustParser.SLASH, 0); }
public TerminalNode PERCENT() { return getToken(RustParser.PERCENT, 0); }
public TerminalNode PLUS() { return getToken(RustParser.PLUS, 0); }
public TerminalNode MINUS() { return getToken(RustParser.MINUS, 0); }
public ShlContext shl() {
return getRuleContext(ShlContext.class,0);
}
public ShrContext shr() {
return getRuleContext(ShrContext.class,0);
}
public TerminalNode AND() { return getToken(RustParser.AND, 0); }
public TerminalNode CARET() { return getToken(RustParser.CARET, 0); }
public TerminalNode OR() { return getToken(RustParser.OR, 0); }
public ArithmeticOrLogicalExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterArithmeticOrLogicalExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitArithmeticOrLogicalExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitArithmeticOrLogicalExpression(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class FieldExpressionContext extends ExpressionContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode DOT() { return getToken(RustParser.DOT, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public FieldExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterFieldExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitFieldExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitFieldExpression(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class EnumerationVariantExpression_Context extends ExpressionContext {
public EnumerationVariantExpressionContext enumerationVariantExpression() {
return getRuleContext(EnumerationVariantExpressionContext.class,0);
}
public EnumerationVariantExpression_Context(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterEnumerationVariantExpression_(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitEnumerationVariantExpression_(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitEnumerationVariantExpression_(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ComparisonExpressionContext extends ExpressionContext {
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public ComparisonOperatorContext comparisonOperator() {
return getRuleContext(ComparisonOperatorContext.class,0);
}
public ComparisonExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterComparisonExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitComparisonExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitComparisonExpression(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AttributedExpressionContext extends ExpressionContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public List outerAttribute() {
return getRuleContexts(OuterAttributeContext.class);
}
public OuterAttributeContext outerAttribute(int i) {
return getRuleContext(OuterAttributeContext.class,i);
}
public AttributedExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterAttributedExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitAttributedExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitAttributedExpression(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class BorrowExpressionContext extends ExpressionContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode AND() { return getToken(RustParser.AND, 0); }
public TerminalNode ANDAND() { return getToken(RustParser.ANDAND, 0); }
public TerminalNode KW_MUT() { return getToken(RustParser.KW_MUT, 0); }
public BorrowExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterBorrowExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitBorrowExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitBorrowExpression(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CompoundAssignmentExpressionContext extends ExpressionContext {
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public CompoundAssignOperatorContext compoundAssignOperator() {
return getRuleContext(CompoundAssignOperatorContext.class,0);
}
public CompoundAssignmentExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterCompoundAssignmentExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitCompoundAssignmentExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitCompoundAssignmentExpression(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ClosureExpression_Context extends ExpressionContext {
public ClosureExpressionContext closureExpression() {
return getRuleContext(ClosureExpressionContext.class,0);
}
public ClosureExpression_Context(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterClosureExpression_(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitClosureExpression_(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitClosureExpression_(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ArrayExpressionContext extends ExpressionContext {
public TerminalNode LSQUAREBRACKET() { return getToken(RustParser.LSQUAREBRACKET, 0); }
public TerminalNode RSQUAREBRACKET() { return getToken(RustParser.RSQUAREBRACKET, 0); }
public List innerAttribute() {
return getRuleContexts(InnerAttributeContext.class);
}
public InnerAttributeContext innerAttribute(int i) {
return getRuleContext(InnerAttributeContext.class,i);
}
public ArrayElementsContext arrayElements() {
return getRuleContext(ArrayElementsContext.class,0);
}
public ArrayExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterArrayExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitArrayExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitArrayExpression(this);
else return visitor.visitChildren(this);
}
}
public final ExpressionContext expression() throws RecognitionException {
return expression(0);
}
private ExpressionContext expression(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
ExpressionContext _localctx = new ExpressionContext(_ctx, _parentState);
ExpressionContext _prevctx = _localctx;
int _startState = 154;
enterRecursionRule(_localctx, 154, RULE_expression, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1366);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,174,_ctx) ) {
case 1:
{
_localctx = new AttributedExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1288);
_errHandler.sync(this);
_alt = 1;
do {
switch (_alt) {
case 1:
{
{
setState(1287);
outerAttribute();
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(1290);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,161,_ctx);
} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
setState(1292);
expression(40);
}
break;
case 2:
{
_localctx = new LiteralExpression_Context(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1294);
literalExpression();
}
break;
case 3:
{
_localctx = new PathExpression_Context(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1295);
pathExpression();
}
break;
case 4:
{
_localctx = new BorrowExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1296);
_la = _input.LA(1);
if ( !(_la==AND || _la==ANDAND) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1298);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==KW_MUT) {
{
setState(1297);
match(KW_MUT);
}
}
setState(1300);
expression(30);
}
break;
case 5:
{
_localctx = new DereferenceExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1301);
match(STAR);
setState(1302);
expression(29);
}
break;
case 6:
{
_localctx = new NegationExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1303);
_la = _input.LA(1);
if ( !(_la==MINUS || _la==NOT) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1304);
expression(28);
}
break;
case 7:
{
_localctx = new RangeExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1305);
match(DOTDOT);
setState(1307);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,163,_ctx) ) {
case 1:
{
setState(1306);
expression(0);
}
break;
}
}
break;
case 8:
{
_localctx = new RangeExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1309);
match(DOTDOTEQ);
setState(1310);
expression(15);
}
break;
case 9:
{
_localctx = new ContinueExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1311);
match(KW_CONTINUE);
setState(1313);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,164,_ctx) ) {
case 1:
{
setState(1312);
match(LIFETIME_OR_LABEL);
}
break;
}
setState(1316);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,165,_ctx) ) {
case 1:
{
setState(1315);
expression(0);
}
break;
}
}
break;
case 10:
{
_localctx = new BreakExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1318);
match(KW_BREAK);
setState(1320);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,166,_ctx) ) {
case 1:
{
setState(1319);
match(LIFETIME_OR_LABEL);
}
break;
}
setState(1323);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,167,_ctx) ) {
case 1:
{
setState(1322);
expression(0);
}
break;
}
}
break;
case 11:
{
_localctx = new ReturnExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1325);
match(KW_RETURN);
setState(1327);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,168,_ctx) ) {
case 1:
{
setState(1326);
expression(0);
}
break;
}
}
break;
case 12:
{
_localctx = new GroupedExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1329);
match(LPAREN);
setState(1333);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,169,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1330);
innerAttribute();
}
}
}
setState(1335);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,169,_ctx);
}
setState(1336);
expression(0);
setState(1337);
match(RPAREN);
}
break;
case 13:
{
_localctx = new ArrayExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1339);
match(LSQUAREBRACKET);
setState(1343);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,170,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1340);
innerAttribute();
}
}
}
setState(1345);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,170,_ctx);
}
setState(1347);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 522417665550785076L) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & 1523430809782507647L) != 0)) {
{
setState(1346);
arrayElements();
}
}
setState(1349);
match(RSQUAREBRACKET);
}
break;
case 14:
{
_localctx = new TupleExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1350);
match(LPAREN);
setState(1354);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,172,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1351);
innerAttribute();
}
}
}
setState(1356);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,172,_ctx);
}
setState(1358);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 522417665550785076L) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & 1523430809782507647L) != 0)) {
{
setState(1357);
tupleElements();
}
}
setState(1360);
match(RPAREN);
}
break;
case 15:
{
_localctx = new StructExpression_Context(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1361);
structExpression();
}
break;
case 16:
{
_localctx = new EnumerationVariantExpression_Context(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1362);
enumerationVariantExpression();
}
break;
case 17:
{
_localctx = new ClosureExpression_Context(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1363);
closureExpression();
}
break;
case 18:
{
_localctx = new ExpressionWithBlock_Context(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1364);
expressionWithBlock();
}
break;
case 19:
{
_localctx = new MacroInvocationAsExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1365);
macroInvocation();
}
break;
}
_ctx.stop = _input.LT(-1);
setState(1451);
_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 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(1449);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,179,_ctx) ) {
case 1:
{
_localctx = new ArithmeticOrLogicalExpressionContext(new ExpressionContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1368);
if (!(precpred(_ctx, 26))) throw new FailedPredicateException(this, "precpred(_ctx, 26)");
setState(1369);
_la = _input.LA(1);
if ( !(((((_la - 84)) & ~0x3f) == 0 && ((1L << (_la - 84)) & 7L) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1370);
expression(27);
}
break;
case 2:
{
_localctx = new ArithmeticOrLogicalExpressionContext(new ExpressionContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1371);
if (!(precpred(_ctx, 25))) throw new FailedPredicateException(this, "precpred(_ctx, 25)");
setState(1372);
_la = _input.LA(1);
if ( !(_la==PLUS || _la==MINUS) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1373);
expression(26);
}
break;
case 3:
{
_localctx = new ArithmeticOrLogicalExpressionContext(new ExpressionContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1374);
if (!(precpred(_ctx, 24))) throw new FailedPredicateException(this, "precpred(_ctx, 24)");
setState(1377);
_errHandler.sync(this);
switch (_input.LA(1)) {
case LT:
{
setState(1375);
shl();
}
break;
case GT:
{
setState(1376);
shr();
}
break;
default:
throw new NoViableAltException(this);
}
setState(1379);
expression(25);
}
break;
case 4:
{
_localctx = new ArithmeticOrLogicalExpressionContext(new ExpressionContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1381);
if (!(precpred(_ctx, 23))) throw new FailedPredicateException(this, "precpred(_ctx, 23)");
setState(1382);
match(AND);
setState(1383);
expression(24);
}
break;
case 5:
{
_localctx = new ArithmeticOrLogicalExpressionContext(new ExpressionContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1384);
if (!(precpred(_ctx, 22))) throw new FailedPredicateException(this, "precpred(_ctx, 22)");
setState(1385);
match(CARET);
setState(1386);
expression(23);
}
break;
case 6:
{
_localctx = new ArithmeticOrLogicalExpressionContext(new ExpressionContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1387);
if (!(precpred(_ctx, 21))) throw new FailedPredicateException(this, "precpred(_ctx, 21)");
setState(1388);
match(OR);
setState(1389);
expression(22);
}
break;
case 7:
{
_localctx = new ComparisonExpressionContext(new ExpressionContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1390);
if (!(precpred(_ctx, 20))) throw new FailedPredicateException(this, "precpred(_ctx, 20)");
setState(1391);
comparisonOperator();
setState(1392);
expression(21);
}
break;
case 8:
{
_localctx = new LazyBooleanExpressionContext(new ExpressionContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1394);
if (!(precpred(_ctx, 19))) throw new FailedPredicateException(this, "precpred(_ctx, 19)");
setState(1395);
match(ANDAND);
setState(1396);
expression(20);
}
break;
case 9:
{
_localctx = new LazyBooleanExpressionContext(new ExpressionContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1397);
if (!(precpred(_ctx, 18))) throw new FailedPredicateException(this, "precpred(_ctx, 18)");
setState(1398);
match(OROR);
setState(1399);
expression(19);
}
break;
case 10:
{
_localctx = new RangeExpressionContext(new ExpressionContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1400);
if (!(precpred(_ctx, 14))) throw new FailedPredicateException(this, "precpred(_ctx, 14)");
setState(1401);
match(DOTDOTEQ);
setState(1402);
expression(15);
}
break;
case 11:
{
_localctx = new AssignmentExpressionContext(new ExpressionContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1403);
if (!(precpred(_ctx, 13))) throw new FailedPredicateException(this, "precpred(_ctx, 13)");
setState(1404);
match(EQ);
setState(1405);
expression(14);
}
break;
case 12:
{
_localctx = new CompoundAssignmentExpressionContext(new ExpressionContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1406);
if (!(precpred(_ctx, 12))) throw new FailedPredicateException(this, "precpred(_ctx, 12)");
setState(1407);
compoundAssignOperator();
setState(1408);
expression(13);
}
break;
case 13:
{
_localctx = new MethodCallExpressionContext(new ExpressionContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1410);
if (!(precpred(_ctx, 37))) throw new FailedPredicateException(this, "precpred(_ctx, 37)");
setState(1411);
match(DOT);
setState(1412);
pathExprSegment();
setState(1413);
match(LPAREN);
setState(1415);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 522417665550785076L) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & 1523430809782507647L) != 0)) {
{
setState(1414);
callParams();
}
}
setState(1417);
match(RPAREN);
}
break;
case 14:
{
_localctx = new FieldExpressionContext(new ExpressionContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1419);
if (!(precpred(_ctx, 36))) throw new FailedPredicateException(this, "precpred(_ctx, 36)");
setState(1420);
match(DOT);
setState(1421);
identifier();
}
break;
case 15:
{
_localctx = new TupleIndexingExpressionContext(new ExpressionContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1422);
if (!(precpred(_ctx, 35))) throw new FailedPredicateException(this, "precpred(_ctx, 35)");
setState(1423);
match(DOT);
setState(1424);
tupleIndex();
}
break;
case 16:
{
_localctx = new AwaitExpressionContext(new ExpressionContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1425);
if (!(precpred(_ctx, 34))) throw new FailedPredicateException(this, "precpred(_ctx, 34)");
setState(1426);
match(DOT);
setState(1427);
match(KW_AWAIT);
}
break;
case 17:
{
_localctx = new CallExpressionContext(new ExpressionContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1428);
if (!(precpred(_ctx, 33))) throw new FailedPredicateException(this, "precpred(_ctx, 33)");
setState(1429);
match(LPAREN);
setState(1431);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 522417665550785076L) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & 1523430809782507647L) != 0)) {
{
setState(1430);
callParams();
}
}
setState(1433);
match(RPAREN);
}
break;
case 18:
{
_localctx = new IndexExpressionContext(new ExpressionContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1434);
if (!(precpred(_ctx, 32))) throw new FailedPredicateException(this, "precpred(_ctx, 32)");
setState(1435);
match(LSQUAREBRACKET);
setState(1436);
expression(0);
setState(1437);
match(RSQUAREBRACKET);
}
break;
case 19:
{
_localctx = new ErrorPropagationExpressionContext(new ExpressionContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1439);
if (!(precpred(_ctx, 31))) throw new FailedPredicateException(this, "precpred(_ctx, 31)");
setState(1440);
match(QUESTION);
}
break;
case 20:
{
_localctx = new TypeCastExpressionContext(new ExpressionContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1441);
if (!(precpred(_ctx, 27))) throw new FailedPredicateException(this, "precpred(_ctx, 27)");
setState(1442);
match(KW_AS);
setState(1443);
typeNoBounds();
}
break;
case 21:
{
_localctx = new RangeExpressionContext(new ExpressionContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1444);
if (!(precpred(_ctx, 17))) throw new FailedPredicateException(this, "precpred(_ctx, 17)");
setState(1445);
match(DOTDOT);
setState(1447);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,178,_ctx) ) {
case 1:
{
setState(1446);
expression(0);
}
break;
}
}
break;
}
}
}
setState(1453);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,180,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ComparisonOperatorContext extends ParserRuleContext {
public TerminalNode EQEQ() { return getToken(RustParser.EQEQ, 0); }
public TerminalNode NE() { return getToken(RustParser.NE, 0); }
public TerminalNode GT() { return getToken(RustParser.GT, 0); }
public TerminalNode LT() { return getToken(RustParser.LT, 0); }
public TerminalNode GE() { return getToken(RustParser.GE, 0); }
public TerminalNode LE() { return getToken(RustParser.LE, 0); }
public ComparisonOperatorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_comparisonOperator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterComparisonOperator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitComparisonOperator(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitComparisonOperator(this);
else return visitor.visitChildren(this);
}
}
public final ComparisonOperatorContext comparisonOperator() throws RecognitionException {
ComparisonOperatorContext _localctx = new ComparisonOperatorContext(_ctx, getState());
enterRule(_localctx, 156, RULE_comparisonOperator);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1454);
_la = _input.LA(1);
if ( !(((((_la - 104)) & ~0x3f) == 0 && ((1L << (_la - 104)) & 63L) != 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;
}
@SuppressWarnings("CheckReturnValue")
public static class CompoundAssignOperatorContext extends ParserRuleContext {
public TerminalNode PLUSEQ() { return getToken(RustParser.PLUSEQ, 0); }
public TerminalNode MINUSEQ() { return getToken(RustParser.MINUSEQ, 0); }
public TerminalNode STAREQ() { return getToken(RustParser.STAREQ, 0); }
public TerminalNode SLASHEQ() { return getToken(RustParser.SLASHEQ, 0); }
public TerminalNode PERCENTEQ() { return getToken(RustParser.PERCENTEQ, 0); }
public TerminalNode ANDEQ() { return getToken(RustParser.ANDEQ, 0); }
public TerminalNode OREQ() { return getToken(RustParser.OREQ, 0); }
public TerminalNode CARETEQ() { return getToken(RustParser.CARETEQ, 0); }
public TerminalNode SHLEQ() { return getToken(RustParser.SHLEQ, 0); }
public TerminalNode SHREQ() { return getToken(RustParser.SHREQ, 0); }
public CompoundAssignOperatorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_compoundAssignOperator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterCompoundAssignOperator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitCompoundAssignOperator(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitCompoundAssignOperator(this);
else return visitor.visitChildren(this);
}
}
public final CompoundAssignOperatorContext compoundAssignOperator() throws RecognitionException {
CompoundAssignOperatorContext _localctx = new CompoundAssignOperatorContext(_ctx, getState());
enterRule(_localctx, 158, RULE_compoundAssignOperator);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1456);
_la = _input.LA(1);
if ( !(((((_la - 93)) & ~0x3f) == 0 && ((1L << (_la - 93)) & 1023L) != 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;
}
@SuppressWarnings("CheckReturnValue")
public static class ExpressionWithBlockContext extends ParserRuleContext {
public ExpressionWithBlockContext expressionWithBlock() {
return getRuleContext(ExpressionWithBlockContext.class,0);
}
public List outerAttribute() {
return getRuleContexts(OuterAttributeContext.class);
}
public OuterAttributeContext outerAttribute(int i) {
return getRuleContext(OuterAttributeContext.class,i);
}
public BlockExpressionContext blockExpression() {
return getRuleContext(BlockExpressionContext.class,0);
}
public AsyncBlockExpressionContext asyncBlockExpression() {
return getRuleContext(AsyncBlockExpressionContext.class,0);
}
public UnsafeBlockExpressionContext unsafeBlockExpression() {
return getRuleContext(UnsafeBlockExpressionContext.class,0);
}
public LoopExpressionContext loopExpression() {
return getRuleContext(LoopExpressionContext.class,0);
}
public IfExpressionContext ifExpression() {
return getRuleContext(IfExpressionContext.class,0);
}
public IfLetExpressionContext ifLetExpression() {
return getRuleContext(IfLetExpressionContext.class,0);
}
public MatchExpressionContext matchExpression() {
return getRuleContext(MatchExpressionContext.class,0);
}
public ExpressionWithBlockContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expressionWithBlock; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterExpressionWithBlock(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitExpressionWithBlock(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitExpressionWithBlock(this);
else return visitor.visitChildren(this);
}
}
public final ExpressionWithBlockContext expressionWithBlock() throws RecognitionException {
ExpressionWithBlockContext _localctx = new ExpressionWithBlockContext(_ctx, getState());
enterRule(_localctx, 160, RULE_expressionWithBlock);
try {
int _alt;
setState(1472);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,182,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1459);
_errHandler.sync(this);
_alt = 1;
do {
switch (_alt) {
case 1:
{
{
setState(1458);
outerAttribute();
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(1461);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,181,_ctx);
} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
setState(1463);
expressionWithBlock();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1465);
blockExpression();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1466);
asyncBlockExpression();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(1467);
unsafeBlockExpression();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(1468);
loopExpression();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(1469);
ifExpression();
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(1470);
ifLetExpression();
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(1471);
matchExpression();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class LiteralExpressionContext extends ParserRuleContext {
public TerminalNode CHAR_LITERAL() { return getToken(RustParser.CHAR_LITERAL, 0); }
public TerminalNode STRING_LITERAL() { return getToken(RustParser.STRING_LITERAL, 0); }
public TerminalNode RAW_STRING_LITERAL() { return getToken(RustParser.RAW_STRING_LITERAL, 0); }
public TerminalNode BYTE_LITERAL() { return getToken(RustParser.BYTE_LITERAL, 0); }
public TerminalNode BYTE_STRING_LITERAL() { return getToken(RustParser.BYTE_STRING_LITERAL, 0); }
public TerminalNode RAW_BYTE_STRING_LITERAL() { return getToken(RustParser.RAW_BYTE_STRING_LITERAL, 0); }
public TerminalNode INTEGER_LITERAL() { return getToken(RustParser.INTEGER_LITERAL, 0); }
public TerminalNode FLOAT_LITERAL() { return getToken(RustParser.FLOAT_LITERAL, 0); }
public TerminalNode KW_TRUE() { return getToken(RustParser.KW_TRUE, 0); }
public TerminalNode KW_FALSE() { return getToken(RustParser.KW_FALSE, 0); }
public LiteralExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_literalExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterLiteralExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitLiteralExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitLiteralExpression(this);
else return visitor.visitChildren(this);
}
}
public final LiteralExpressionContext literalExpression() throws RecognitionException {
LiteralExpressionContext _localctx = new LiteralExpressionContext(_ctx, getState());
enterRule(_localctx, 162, RULE_literalExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1474);
_la = _input.LA(1);
if ( !(_la==KW_FALSE || _la==KW_TRUE || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & 2175L) != 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;
}
@SuppressWarnings("CheckReturnValue")
public static class PathExpressionContext extends ParserRuleContext {
public PathInExpressionContext pathInExpression() {
return getRuleContext(PathInExpressionContext.class,0);
}
public QualifiedPathInExpressionContext qualifiedPathInExpression() {
return getRuleContext(QualifiedPathInExpressionContext.class,0);
}
public PathExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_pathExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterPathExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitPathExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitPathExpression(this);
else return visitor.visitChildren(this);
}
}
public final PathExpressionContext pathExpression() throws RecognitionException {
PathExpressionContext _localctx = new PathExpressionContext(_ctx, getState());
enterRule(_localctx, 164, RULE_pathExpression);
try {
setState(1478);
_errHandler.sync(this);
switch (_input.LA(1)) {
case KW_CRATE:
case KW_SELFVALUE:
case KW_SELFTYPE:
case KW_SUPER:
case KW_MACRORULES:
case KW_DOLLARCRATE:
case NON_KEYWORD_IDENTIFIER:
case RAW_IDENTIFIER:
case PATHSEP:
enterOuterAlt(_localctx, 1);
{
setState(1476);
pathInExpression();
}
break;
case LT:
enterOuterAlt(_localctx, 2);
{
setState(1477);
qualifiedPathInExpression();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class BlockExpressionContext extends ParserRuleContext {
public TerminalNode LCURLYBRACE() { return getToken(RustParser.LCURLYBRACE, 0); }
public TerminalNode RCURLYBRACE() { return getToken(RustParser.RCURLYBRACE, 0); }
public List innerAttribute() {
return getRuleContexts(InnerAttributeContext.class);
}
public InnerAttributeContext innerAttribute(int i) {
return getRuleContext(InnerAttributeContext.class,i);
}
public StatementsContext statements() {
return getRuleContext(StatementsContext.class,0);
}
public BlockExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_blockExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterBlockExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitBlockExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitBlockExpression(this);
else return visitor.visitChildren(this);
}
}
public final BlockExpressionContext blockExpression() throws RecognitionException {
BlockExpressionContext _localctx = new BlockExpressionContext(_ctx, getState());
enterRule(_localctx, 166, RULE_blockExpression);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1480);
match(LCURLYBRACE);
setState(1484);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,184,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1481);
innerAttribute();
}
}
}
setState(1486);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,184,_ctx);
}
setState(1488);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 526921276656172988L) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & 1523712284759218303L) != 0)) {
{
setState(1487);
statements();
}
}
setState(1490);
match(RCURLYBRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class StatementsContext extends ParserRuleContext {
public List statement() {
return getRuleContexts(StatementContext.class);
}
public StatementContext statement(int i) {
return getRuleContext(StatementContext.class,i);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public StatementsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_statements; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterStatements(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitStatements(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitStatements(this);
else return visitor.visitChildren(this);
}
}
public final StatementsContext statements() throws RecognitionException {
StatementsContext _localctx = new StatementsContext(_ctx, getState());
enterRule(_localctx, 168, RULE_statements);
int _la;
try {
int _alt;
setState(1501);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,188,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1493);
_errHandler.sync(this);
_alt = 1;
do {
switch (_alt) {
case 1:
{
{
setState(1492);
statement();
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(1495);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,186,_ctx);
} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
setState(1498);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 522417665550785076L) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & 1523430809782507647L) != 0)) {
{
setState(1497);
expression(0);
}
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1500);
expression(0);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class AsyncBlockExpressionContext extends ParserRuleContext {
public TerminalNode KW_ASYNC() { return getToken(RustParser.KW_ASYNC, 0); }
public BlockExpressionContext blockExpression() {
return getRuleContext(BlockExpressionContext.class,0);
}
public TerminalNode KW_MOVE() { return getToken(RustParser.KW_MOVE, 0); }
public AsyncBlockExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_asyncBlockExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterAsyncBlockExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitAsyncBlockExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitAsyncBlockExpression(this);
else return visitor.visitChildren(this);
}
}
public final AsyncBlockExpressionContext asyncBlockExpression() throws RecognitionException {
AsyncBlockExpressionContext _localctx = new AsyncBlockExpressionContext(_ctx, getState());
enterRule(_localctx, 170, RULE_asyncBlockExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1503);
match(KW_ASYNC);
setState(1505);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==KW_MOVE) {
{
setState(1504);
match(KW_MOVE);
}
}
setState(1507);
blockExpression();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class UnsafeBlockExpressionContext extends ParserRuleContext {
public TerminalNode KW_UNSAFE() { return getToken(RustParser.KW_UNSAFE, 0); }
public BlockExpressionContext blockExpression() {
return getRuleContext(BlockExpressionContext.class,0);
}
public UnsafeBlockExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unsafeBlockExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterUnsafeBlockExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitUnsafeBlockExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitUnsafeBlockExpression(this);
else return visitor.visitChildren(this);
}
}
public final UnsafeBlockExpressionContext unsafeBlockExpression() throws RecognitionException {
UnsafeBlockExpressionContext _localctx = new UnsafeBlockExpressionContext(_ctx, getState());
enterRule(_localctx, 172, RULE_unsafeBlockExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(1509);
match(KW_UNSAFE);
setState(1510);
blockExpression();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ArrayElementsContext extends ParserRuleContext {
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public List COMMA() { return getTokens(RustParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(RustParser.COMMA, i);
}
public TerminalNode SEMI() { return getToken(RustParser.SEMI, 0); }
public ArrayElementsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_arrayElements; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterArrayElements(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitArrayElements(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitArrayElements(this);
else return visitor.visitChildren(this);
}
}
public final ArrayElementsContext arrayElements() throws RecognitionException {
ArrayElementsContext _localctx = new ArrayElementsContext(_ctx, getState());
enterRule(_localctx, 174, RULE_arrayElements);
int _la;
try {
int _alt;
setState(1527);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,192,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1512);
expression(0);
setState(1517);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,190,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1513);
match(COMMA);
setState(1514);
expression(0);
}
}
}
setState(1519);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,190,_ctx);
}
setState(1521);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(1520);
match(COMMA);
}
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1523);
expression(0);
setState(1524);
match(SEMI);
setState(1525);
expression(0);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class TupleElementsContext extends ParserRuleContext {
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public List COMMA() { return getTokens(RustParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(RustParser.COMMA, i);
}
public TupleElementsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_tupleElements; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterTupleElements(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitTupleElements(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitTupleElements(this);
else return visitor.visitChildren(this);
}
}
public final TupleElementsContext tupleElements() throws RecognitionException {
TupleElementsContext _localctx = new TupleElementsContext(_ctx, getState());
enterRule(_localctx, 176, RULE_tupleElements);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1532);
_errHandler.sync(this);
_alt = 1;
do {
switch (_alt) {
case 1:
{
{
setState(1529);
expression(0);
setState(1530);
match(COMMA);
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(1534);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,193,_ctx);
} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
setState(1537);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 522417665550785076L) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & 1523430809782507647L) != 0)) {
{
setState(1536);
expression(0);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class TupleIndexContext extends ParserRuleContext {
public TerminalNode INTEGER_LITERAL() { return getToken(RustParser.INTEGER_LITERAL, 0); }
public TupleIndexContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_tupleIndex; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterTupleIndex(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitTupleIndex(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitTupleIndex(this);
else return visitor.visitChildren(this);
}
}
public final TupleIndexContext tupleIndex() throws RecognitionException {
TupleIndexContext _localctx = new TupleIndexContext(_ctx, getState());
enterRule(_localctx, 178, RULE_tupleIndex);
try {
enterOuterAlt(_localctx, 1);
{
setState(1539);
match(INTEGER_LITERAL);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class StructExpressionContext extends ParserRuleContext {
public StructExprStructContext structExprStruct() {
return getRuleContext(StructExprStructContext.class,0);
}
public StructExprTupleContext structExprTuple() {
return getRuleContext(StructExprTupleContext.class,0);
}
public StructExprUnitContext structExprUnit() {
return getRuleContext(StructExprUnitContext.class,0);
}
public StructExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_structExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterStructExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitStructExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitStructExpression(this);
else return visitor.visitChildren(this);
}
}
public final StructExpressionContext structExpression() throws RecognitionException {
StructExpressionContext _localctx = new StructExpressionContext(_ctx, getState());
enterRule(_localctx, 180, RULE_structExpression);
try {
setState(1544);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,195,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1541);
structExprStruct();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1542);
structExprTuple();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1543);
structExprUnit();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class StructExprStructContext extends ParserRuleContext {
public PathInExpressionContext pathInExpression() {
return getRuleContext(PathInExpressionContext.class,0);
}
public TerminalNode LCURLYBRACE() { return getToken(RustParser.LCURLYBRACE, 0); }
public TerminalNode RCURLYBRACE() { return getToken(RustParser.RCURLYBRACE, 0); }
public List innerAttribute() {
return getRuleContexts(InnerAttributeContext.class);
}
public InnerAttributeContext innerAttribute(int i) {
return getRuleContext(InnerAttributeContext.class,i);
}
public StructExprFieldsContext structExprFields() {
return getRuleContext(StructExprFieldsContext.class,0);
}
public StructBaseContext structBase() {
return getRuleContext(StructBaseContext.class,0);
}
public StructExprStructContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_structExprStruct; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterStructExprStruct(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitStructExprStruct(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitStructExprStruct(this);
else return visitor.visitChildren(this);
}
}
public final StructExprStructContext structExprStruct() throws RecognitionException {
StructExprStructContext _localctx = new StructExprStructContext(_ctx, getState());
enterRule(_localctx, 182, RULE_structExprStruct);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1546);
pathInExpression();
setState(1547);
match(LCURLYBRACE);
setState(1551);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,196,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1548);
innerAttribute();
}
}
}
setState(1553);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,196,_ctx);
}
setState(1556);
_errHandler.sync(this);
switch (_input.LA(1)) {
case KW_MACRORULES:
case NON_KEYWORD_IDENTIFIER:
case RAW_IDENTIFIER:
case INTEGER_LITERAL:
case POUND:
{
setState(1554);
structExprFields();
}
break;
case DOTDOT:
{
setState(1555);
structBase();
}
break;
case RCURLYBRACE:
break;
default:
break;
}
setState(1558);
match(RCURLYBRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class StructExprFieldsContext extends ParserRuleContext {
public List structExprField() {
return getRuleContexts(StructExprFieldContext.class);
}
public StructExprFieldContext structExprField(int i) {
return getRuleContext(StructExprFieldContext.class,i);
}
public List COMMA() { return getTokens(RustParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(RustParser.COMMA, i);
}
public StructBaseContext structBase() {
return getRuleContext(StructBaseContext.class,0);
}
public StructExprFieldsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_structExprFields; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterStructExprFields(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitStructExprFields(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitStructExprFields(this);
else return visitor.visitChildren(this);
}
}
public final StructExprFieldsContext structExprFields() throws RecognitionException {
StructExprFieldsContext _localctx = new StructExprFieldsContext(_ctx, getState());
enterRule(_localctx, 184, RULE_structExprFields);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1560);
structExprField();
setState(1565);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,198,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1561);
match(COMMA);
setState(1562);
structExprField();
}
}
}
setState(1567);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,198,_ctx);
}
setState(1573);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,200,_ctx) ) {
case 1:
{
setState(1568);
match(COMMA);
setState(1569);
structBase();
}
break;
case 2:
{
setState(1571);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(1570);
match(COMMA);
}
}
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class StructExprFieldContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode COLON() { return getToken(RustParser.COLON, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public List outerAttribute() {
return getRuleContexts(OuterAttributeContext.class);
}
public OuterAttributeContext outerAttribute(int i) {
return getRuleContext(OuterAttributeContext.class,i);
}
public TupleIndexContext tupleIndex() {
return getRuleContext(TupleIndexContext.class,0);
}
public StructExprFieldContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_structExprField; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterStructExprField(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitStructExprField(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitStructExprField(this);
else return visitor.visitChildren(this);
}
}
public final StructExprFieldContext structExprField() throws RecognitionException {
StructExprFieldContext _localctx = new StructExprFieldContext(_ctx, getState());
enterRule(_localctx, 186, RULE_structExprField);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1578);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==POUND) {
{
{
setState(1575);
outerAttribute();
}
}
setState(1580);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1589);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,203,_ctx) ) {
case 1:
{
setState(1581);
identifier();
}
break;
case 2:
{
setState(1584);
_errHandler.sync(this);
switch (_input.LA(1)) {
case KW_MACRORULES:
case NON_KEYWORD_IDENTIFIER:
case RAW_IDENTIFIER:
{
setState(1582);
identifier();
}
break;
case INTEGER_LITERAL:
{
setState(1583);
tupleIndex();
}
break;
default:
throw new NoViableAltException(this);
}
setState(1586);
match(COLON);
setState(1587);
expression(0);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class StructBaseContext extends ParserRuleContext {
public TerminalNode DOTDOT() { return getToken(RustParser.DOTDOT, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public StructBaseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_structBase; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterStructBase(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitStructBase(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitStructBase(this);
else return visitor.visitChildren(this);
}
}
public final StructBaseContext structBase() throws RecognitionException {
StructBaseContext _localctx = new StructBaseContext(_ctx, getState());
enterRule(_localctx, 188, RULE_structBase);
try {
enterOuterAlt(_localctx, 1);
{
setState(1591);
match(DOTDOT);
setState(1592);
expression(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class StructExprTupleContext extends ParserRuleContext {
public PathInExpressionContext pathInExpression() {
return getRuleContext(PathInExpressionContext.class,0);
}
public TerminalNode LPAREN() { return getToken(RustParser.LPAREN, 0); }
public TerminalNode RPAREN() { return getToken(RustParser.RPAREN, 0); }
public List innerAttribute() {
return getRuleContexts(InnerAttributeContext.class);
}
public InnerAttributeContext innerAttribute(int i) {
return getRuleContext(InnerAttributeContext.class,i);
}
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public List COMMA() { return getTokens(RustParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(RustParser.COMMA, i);
}
public StructExprTupleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_structExprTuple; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterStructExprTuple(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitStructExprTuple(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitStructExprTuple(this);
else return visitor.visitChildren(this);
}
}
public final StructExprTupleContext structExprTuple() throws RecognitionException {
StructExprTupleContext _localctx = new StructExprTupleContext(_ctx, getState());
enterRule(_localctx, 190, RULE_structExprTuple);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1594);
pathInExpression();
setState(1595);
match(LPAREN);
setState(1599);
_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(1596);
innerAttribute();
}
}
}
setState(1601);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,204,_ctx);
}
setState(1613);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 522417665550785076L) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & 1523430809782507647L) != 0)) {
{
setState(1602);
expression(0);
setState(1607);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,205,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1603);
match(COMMA);
setState(1604);
expression(0);
}
}
}
setState(1609);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,205,_ctx);
}
setState(1611);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(1610);
match(COMMA);
}
}
}
}
setState(1615);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class StructExprUnitContext extends ParserRuleContext {
public PathInExpressionContext pathInExpression() {
return getRuleContext(PathInExpressionContext.class,0);
}
public StructExprUnitContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_structExprUnit; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterStructExprUnit(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitStructExprUnit(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitStructExprUnit(this);
else return visitor.visitChildren(this);
}
}
public final StructExprUnitContext structExprUnit() throws RecognitionException {
StructExprUnitContext _localctx = new StructExprUnitContext(_ctx, getState());
enterRule(_localctx, 192, RULE_structExprUnit);
try {
enterOuterAlt(_localctx, 1);
{
setState(1617);
pathInExpression();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class EnumerationVariantExpressionContext extends ParserRuleContext {
public EnumExprStructContext enumExprStruct() {
return getRuleContext(EnumExprStructContext.class,0);
}
public EnumExprTupleContext enumExprTuple() {
return getRuleContext(EnumExprTupleContext.class,0);
}
public EnumExprFieldlessContext enumExprFieldless() {
return getRuleContext(EnumExprFieldlessContext.class,0);
}
public EnumerationVariantExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_enumerationVariantExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterEnumerationVariantExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitEnumerationVariantExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitEnumerationVariantExpression(this);
else return visitor.visitChildren(this);
}
}
public final EnumerationVariantExpressionContext enumerationVariantExpression() throws RecognitionException {
EnumerationVariantExpressionContext _localctx = new EnumerationVariantExpressionContext(_ctx, getState());
enterRule(_localctx, 194, RULE_enumerationVariantExpression);
try {
setState(1622);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,208,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1619);
enumExprStruct();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1620);
enumExprTuple();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1621);
enumExprFieldless();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class EnumExprStructContext extends ParserRuleContext {
public PathInExpressionContext pathInExpression() {
return getRuleContext(PathInExpressionContext.class,0);
}
public TerminalNode LCURLYBRACE() { return getToken(RustParser.LCURLYBRACE, 0); }
public TerminalNode RCURLYBRACE() { return getToken(RustParser.RCURLYBRACE, 0); }
public EnumExprFieldsContext enumExprFields() {
return getRuleContext(EnumExprFieldsContext.class,0);
}
public EnumExprStructContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_enumExprStruct; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterEnumExprStruct(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitEnumExprStruct(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitEnumExprStruct(this);
else return visitor.visitChildren(this);
}
}
public final EnumExprStructContext enumExprStruct() throws RecognitionException {
EnumExprStructContext _localctx = new EnumExprStructContext(_ctx, getState());
enterRule(_localctx, 196, RULE_enumExprStruct);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1624);
pathInExpression();
setState(1625);
match(LCURLYBRACE);
setState(1627);
_errHandler.sync(this);
_la = _input.LA(1);
if (((((_la - 54)) & ~0x3f) == 0 && ((1L << (_la - 54)) & 2097177L) != 0)) {
{
setState(1626);
enumExprFields();
}
}
setState(1629);
match(RCURLYBRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class EnumExprFieldsContext extends ParserRuleContext {
public List enumExprField() {
return getRuleContexts(EnumExprFieldContext.class);
}
public EnumExprFieldContext enumExprField(int i) {
return getRuleContext(EnumExprFieldContext.class,i);
}
public List COMMA() { return getTokens(RustParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(RustParser.COMMA, i);
}
public EnumExprFieldsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_enumExprFields; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterEnumExprFields(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitEnumExprFields(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitEnumExprFields(this);
else return visitor.visitChildren(this);
}
}
public final EnumExprFieldsContext enumExprFields() throws RecognitionException {
EnumExprFieldsContext _localctx = new EnumExprFieldsContext(_ctx, getState());
enterRule(_localctx, 198, RULE_enumExprFields);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1631);
enumExprField();
setState(1636);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,210,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1632);
match(COMMA);
setState(1633);
enumExprField();
}
}
}
setState(1638);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,210,_ctx);
}
setState(1640);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(1639);
match(COMMA);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class EnumExprFieldContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode COLON() { return getToken(RustParser.COLON, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TupleIndexContext tupleIndex() {
return getRuleContext(TupleIndexContext.class,0);
}
public EnumExprFieldContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_enumExprField; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterEnumExprField(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitEnumExprField(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitEnumExprField(this);
else return visitor.visitChildren(this);
}
}
public final EnumExprFieldContext enumExprField() throws RecognitionException {
EnumExprFieldContext _localctx = new EnumExprFieldContext(_ctx, getState());
enterRule(_localctx, 200, RULE_enumExprField);
try {
setState(1650);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,213,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1642);
identifier();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1645);
_errHandler.sync(this);
switch (_input.LA(1)) {
case KW_MACRORULES:
case NON_KEYWORD_IDENTIFIER:
case RAW_IDENTIFIER:
{
setState(1643);
identifier();
}
break;
case INTEGER_LITERAL:
{
setState(1644);
tupleIndex();
}
break;
default:
throw new NoViableAltException(this);
}
setState(1647);
match(COLON);
setState(1648);
expression(0);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class EnumExprTupleContext extends ParserRuleContext {
public PathInExpressionContext pathInExpression() {
return getRuleContext(PathInExpressionContext.class,0);
}
public TerminalNode LPAREN() { return getToken(RustParser.LPAREN, 0); }
public TerminalNode RPAREN() { return getToken(RustParser.RPAREN, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public List COMMA() { return getTokens(RustParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(RustParser.COMMA, i);
}
public EnumExprTupleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_enumExprTuple; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterEnumExprTuple(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitEnumExprTuple(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitEnumExprTuple(this);
else return visitor.visitChildren(this);
}
}
public final EnumExprTupleContext enumExprTuple() throws RecognitionException {
EnumExprTupleContext _localctx = new EnumExprTupleContext(_ctx, getState());
enterRule(_localctx, 202, RULE_enumExprTuple);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1652);
pathInExpression();
setState(1653);
match(LPAREN);
setState(1665);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 522417665550785076L) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & 1523430809782507647L) != 0)) {
{
setState(1654);
expression(0);
setState(1659);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,214,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1655);
match(COMMA);
setState(1656);
expression(0);
}
}
}
setState(1661);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,214,_ctx);
}
setState(1663);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(1662);
match(COMMA);
}
}
}
}
setState(1667);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class EnumExprFieldlessContext extends ParserRuleContext {
public PathInExpressionContext pathInExpression() {
return getRuleContext(PathInExpressionContext.class,0);
}
public EnumExprFieldlessContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_enumExprFieldless; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterEnumExprFieldless(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitEnumExprFieldless(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitEnumExprFieldless(this);
else return visitor.visitChildren(this);
}
}
public final EnumExprFieldlessContext enumExprFieldless() throws RecognitionException {
EnumExprFieldlessContext _localctx = new EnumExprFieldlessContext(_ctx, getState());
enterRule(_localctx, 204, RULE_enumExprFieldless);
try {
enterOuterAlt(_localctx, 1);
{
setState(1669);
pathInExpression();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class CallParamsContext extends ParserRuleContext {
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public List COMMA() { return getTokens(RustParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(RustParser.COMMA, i);
}
public CallParamsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_callParams; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterCallParams(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitCallParams(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitCallParams(this);
else return visitor.visitChildren(this);
}
}
public final CallParamsContext callParams() throws RecognitionException {
CallParamsContext _localctx = new CallParamsContext(_ctx, getState());
enterRule(_localctx, 206, RULE_callParams);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1671);
expression(0);
setState(1676);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,217,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1672);
match(COMMA);
setState(1673);
expression(0);
}
}
}
setState(1678);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,217,_ctx);
}
setState(1680);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(1679);
match(COMMA);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ClosureExpressionContext extends ParserRuleContext {
public TerminalNode OROR() { return getToken(RustParser.OROR, 0); }
public List OR() { return getTokens(RustParser.OR); }
public TerminalNode OR(int i) {
return getToken(RustParser.OR, i);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode RARROW() { return getToken(RustParser.RARROW, 0); }
public TypeNoBoundsContext typeNoBounds() {
return getRuleContext(TypeNoBoundsContext.class,0);
}
public BlockExpressionContext blockExpression() {
return getRuleContext(BlockExpressionContext.class,0);
}
public TerminalNode KW_MOVE() { return getToken(RustParser.KW_MOVE, 0); }
public ClosureParametersContext closureParameters() {
return getRuleContext(ClosureParametersContext.class,0);
}
public ClosureExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_closureExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterClosureExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitClosureExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitClosureExpression(this);
else return visitor.visitChildren(this);
}
}
public final ClosureExpressionContext closureExpression() throws RecognitionException {
ClosureExpressionContext _localctx = new ClosureExpressionContext(_ctx, getState());
enterRule(_localctx, 208, RULE_closureExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1683);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==KW_MOVE) {
{
setState(1682);
match(KW_MOVE);
}
}
setState(1691);
_errHandler.sync(this);
switch (_input.LA(1)) {
case OROR:
{
setState(1685);
match(OROR);
}
break;
case OR:
{
setState(1686);
match(OR);
setState(1688);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,220,_ctx) ) {
case 1:
{
setState(1687);
closureParameters();
}
break;
}
setState(1690);
match(OR);
}
break;
default:
throw new NoViableAltException(this);
}
setState(1698);
_errHandler.sync(this);
switch (_input.LA(1)) {
case KW_BREAK:
case KW_CONTINUE:
case KW_CRATE:
case KW_FALSE:
case KW_FOR:
case KW_IF:
case KW_LOOP:
case KW_MATCH:
case KW_MOVE:
case KW_RETURN:
case KW_SELFVALUE:
case KW_SELFTYPE:
case KW_SUPER:
case KW_TRUE:
case KW_UNSAFE:
case KW_WHILE:
case KW_ASYNC:
case KW_MACRORULES:
case KW_DOLLARCRATE:
case NON_KEYWORD_IDENTIFIER:
case RAW_IDENTIFIER:
case CHAR_LITERAL:
case STRING_LITERAL:
case RAW_STRING_LITERAL:
case BYTE_LITERAL:
case BYTE_STRING_LITERAL:
case RAW_BYTE_STRING_LITERAL:
case INTEGER_LITERAL:
case FLOAT_LITERAL:
case LIFETIME_OR_LABEL:
case MINUS:
case STAR:
case NOT:
case AND:
case OR:
case ANDAND:
case OROR:
case LT:
case DOTDOT:
case DOTDOTEQ:
case PATHSEP:
case POUND:
case LCURLYBRACE:
case LSQUAREBRACKET:
case LPAREN:
{
setState(1693);
expression(0);
}
break;
case RARROW:
{
setState(1694);
match(RARROW);
setState(1695);
typeNoBounds();
setState(1696);
blockExpression();
}
break;
default:
throw new NoViableAltException(this);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ClosureParametersContext extends ParserRuleContext {
public List closureParam() {
return getRuleContexts(ClosureParamContext.class);
}
public ClosureParamContext closureParam(int i) {
return getRuleContext(ClosureParamContext.class,i);
}
public List COMMA() { return getTokens(RustParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(RustParser.COMMA, i);
}
public ClosureParametersContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_closureParameters; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterClosureParameters(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitClosureParameters(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitClosureParameters(this);
else return visitor.visitChildren(this);
}
}
public final ClosureParametersContext closureParameters() throws RecognitionException {
ClosureParametersContext _localctx = new ClosureParametersContext(_ctx, getState());
enterRule(_localctx, 210, RULE_closureParameters);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1700);
closureParam();
setState(1705);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,223,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1701);
match(COMMA);
setState(1702);
closureParam();
}
}
}
setState(1707);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,223,_ctx);
}
setState(1709);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(1708);
match(COMMA);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ClosureParamContext extends ParserRuleContext {
public PatternContext pattern() {
return getRuleContext(PatternContext.class,0);
}
public List outerAttribute() {
return getRuleContexts(OuterAttributeContext.class);
}
public OuterAttributeContext outerAttribute(int i) {
return getRuleContext(OuterAttributeContext.class,i);
}
public TerminalNode COLON() { return getToken(RustParser.COLON, 0); }
public Type_Context type_() {
return getRuleContext(Type_Context.class,0);
}
public ClosureParamContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_closureParam; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterClosureParam(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitClosureParam(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitClosureParam(this);
else return visitor.visitChildren(this);
}
}
public final ClosureParamContext closureParam() throws RecognitionException {
ClosureParamContext _localctx = new ClosureParamContext(_ctx, getState());
enterRule(_localctx, 212, RULE_closureParam);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1714);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==POUND) {
{
{
setState(1711);
outerAttribute();
}
}
setState(1716);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1717);
pattern();
setState(1720);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COLON) {
{
setState(1718);
match(COLON);
setState(1719);
type_();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class LoopExpressionContext extends ParserRuleContext {
public InfiniteLoopExpressionContext infiniteLoopExpression() {
return getRuleContext(InfiniteLoopExpressionContext.class,0);
}
public PredicateLoopExpressionContext predicateLoopExpression() {
return getRuleContext(PredicateLoopExpressionContext.class,0);
}
public PredicatePatternLoopExpressionContext predicatePatternLoopExpression() {
return getRuleContext(PredicatePatternLoopExpressionContext.class,0);
}
public IteratorLoopExpressionContext iteratorLoopExpression() {
return getRuleContext(IteratorLoopExpressionContext.class,0);
}
public LoopLabelContext loopLabel() {
return getRuleContext(LoopLabelContext.class,0);
}
public LoopExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_loopExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterLoopExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitLoopExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitLoopExpression(this);
else return visitor.visitChildren(this);
}
}
public final LoopExpressionContext loopExpression() throws RecognitionException {
LoopExpressionContext _localctx = new LoopExpressionContext(_ctx, getState());
enterRule(_localctx, 214, RULE_loopExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1723);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LIFETIME_OR_LABEL) {
{
setState(1722);
loopLabel();
}
}
setState(1729);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,228,_ctx) ) {
case 1:
{
setState(1725);
infiniteLoopExpression();
}
break;
case 2:
{
setState(1726);
predicateLoopExpression();
}
break;
case 3:
{
setState(1727);
predicatePatternLoopExpression();
}
break;
case 4:
{
setState(1728);
iteratorLoopExpression();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class InfiniteLoopExpressionContext extends ParserRuleContext {
public TerminalNode KW_LOOP() { return getToken(RustParser.KW_LOOP, 0); }
public BlockExpressionContext blockExpression() {
return getRuleContext(BlockExpressionContext.class,0);
}
public InfiniteLoopExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_infiniteLoopExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterInfiniteLoopExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitInfiniteLoopExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitInfiniteLoopExpression(this);
else return visitor.visitChildren(this);
}
}
public final InfiniteLoopExpressionContext infiniteLoopExpression() throws RecognitionException {
InfiniteLoopExpressionContext _localctx = new InfiniteLoopExpressionContext(_ctx, getState());
enterRule(_localctx, 216, RULE_infiniteLoopExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(1731);
match(KW_LOOP);
setState(1732);
blockExpression();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PredicateLoopExpressionContext extends ParserRuleContext {
public TerminalNode KW_WHILE() { return getToken(RustParser.KW_WHILE, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public BlockExpressionContext blockExpression() {
return getRuleContext(BlockExpressionContext.class,0);
}
public PredicateLoopExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_predicateLoopExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterPredicateLoopExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitPredicateLoopExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitPredicateLoopExpression(this);
else return visitor.visitChildren(this);
}
}
public final PredicateLoopExpressionContext predicateLoopExpression() throws RecognitionException {
PredicateLoopExpressionContext _localctx = new PredicateLoopExpressionContext(_ctx, getState());
enterRule(_localctx, 218, RULE_predicateLoopExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(1734);
match(KW_WHILE);
setState(1735);
expression(0);
setState(1736);
blockExpression();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PredicatePatternLoopExpressionContext extends ParserRuleContext {
public TerminalNode KW_WHILE() { return getToken(RustParser.KW_WHILE, 0); }
public TerminalNode KW_LET() { return getToken(RustParser.KW_LET, 0); }
public PatternContext pattern() {
return getRuleContext(PatternContext.class,0);
}
public TerminalNode EQ() { return getToken(RustParser.EQ, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public BlockExpressionContext blockExpression() {
return getRuleContext(BlockExpressionContext.class,0);
}
public PredicatePatternLoopExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_predicatePatternLoopExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterPredicatePatternLoopExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitPredicatePatternLoopExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitPredicatePatternLoopExpression(this);
else return visitor.visitChildren(this);
}
}
public final PredicatePatternLoopExpressionContext predicatePatternLoopExpression() throws RecognitionException {
PredicatePatternLoopExpressionContext _localctx = new PredicatePatternLoopExpressionContext(_ctx, getState());
enterRule(_localctx, 220, RULE_predicatePatternLoopExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(1738);
match(KW_WHILE);
setState(1739);
match(KW_LET);
setState(1740);
pattern();
setState(1741);
match(EQ);
setState(1742);
expression(0);
setState(1743);
blockExpression();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class IteratorLoopExpressionContext extends ParserRuleContext {
public TerminalNode KW_FOR() { return getToken(RustParser.KW_FOR, 0); }
public PatternContext pattern() {
return getRuleContext(PatternContext.class,0);
}
public TerminalNode KW_IN() { return getToken(RustParser.KW_IN, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public BlockExpressionContext blockExpression() {
return getRuleContext(BlockExpressionContext.class,0);
}
public IteratorLoopExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_iteratorLoopExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterIteratorLoopExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitIteratorLoopExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitIteratorLoopExpression(this);
else return visitor.visitChildren(this);
}
}
public final IteratorLoopExpressionContext iteratorLoopExpression() throws RecognitionException {
IteratorLoopExpressionContext _localctx = new IteratorLoopExpressionContext(_ctx, getState());
enterRule(_localctx, 222, RULE_iteratorLoopExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(1745);
match(KW_FOR);
setState(1746);
pattern();
setState(1747);
match(KW_IN);
setState(1748);
expression(0);
setState(1749);
blockExpression();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class LoopLabelContext extends ParserRuleContext {
public TerminalNode LIFETIME_OR_LABEL() { return getToken(RustParser.LIFETIME_OR_LABEL, 0); }
public TerminalNode COLON() { return getToken(RustParser.COLON, 0); }
public LoopLabelContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_loopLabel; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterLoopLabel(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitLoopLabel(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitLoopLabel(this);
else return visitor.visitChildren(this);
}
}
public final LoopLabelContext loopLabel() throws RecognitionException {
LoopLabelContext _localctx = new LoopLabelContext(_ctx, getState());
enterRule(_localctx, 224, RULE_loopLabel);
try {
enterOuterAlt(_localctx, 1);
{
setState(1751);
match(LIFETIME_OR_LABEL);
setState(1752);
match(COLON);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class IfExpressionContext extends ParserRuleContext {
public TerminalNode KW_IF() { return getToken(RustParser.KW_IF, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public List blockExpression() {
return getRuleContexts(BlockExpressionContext.class);
}
public BlockExpressionContext blockExpression(int i) {
return getRuleContext(BlockExpressionContext.class,i);
}
public TerminalNode KW_ELSE() { return getToken(RustParser.KW_ELSE, 0); }
public IfExpressionContext ifExpression() {
return getRuleContext(IfExpressionContext.class,0);
}
public IfLetExpressionContext ifLetExpression() {
return getRuleContext(IfLetExpressionContext.class,0);
}
public IfExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_ifExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterIfExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitIfExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitIfExpression(this);
else return visitor.visitChildren(this);
}
}
public final IfExpressionContext ifExpression() throws RecognitionException {
IfExpressionContext _localctx = new IfExpressionContext(_ctx, getState());
enterRule(_localctx, 226, RULE_ifExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(1754);
match(KW_IF);
setState(1755);
expression(0);
setState(1756);
blockExpression();
setState(1763);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,230,_ctx) ) {
case 1:
{
setState(1757);
match(KW_ELSE);
setState(1761);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,229,_ctx) ) {
case 1:
{
setState(1758);
blockExpression();
}
break;
case 2:
{
setState(1759);
ifExpression();
}
break;
case 3:
{
setState(1760);
ifLetExpression();
}
break;
}
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class IfLetExpressionContext extends ParserRuleContext {
public TerminalNode KW_IF() { return getToken(RustParser.KW_IF, 0); }
public TerminalNode KW_LET() { return getToken(RustParser.KW_LET, 0); }
public PatternContext pattern() {
return getRuleContext(PatternContext.class,0);
}
public TerminalNode EQ() { return getToken(RustParser.EQ, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public List blockExpression() {
return getRuleContexts(BlockExpressionContext.class);
}
public BlockExpressionContext blockExpression(int i) {
return getRuleContext(BlockExpressionContext.class,i);
}
public TerminalNode KW_ELSE() { return getToken(RustParser.KW_ELSE, 0); }
public IfExpressionContext ifExpression() {
return getRuleContext(IfExpressionContext.class,0);
}
public IfLetExpressionContext ifLetExpression() {
return getRuleContext(IfLetExpressionContext.class,0);
}
public IfLetExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_ifLetExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterIfLetExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitIfLetExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitIfLetExpression(this);
else return visitor.visitChildren(this);
}
}
public final IfLetExpressionContext ifLetExpression() throws RecognitionException {
IfLetExpressionContext _localctx = new IfLetExpressionContext(_ctx, getState());
enterRule(_localctx, 228, RULE_ifLetExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(1765);
match(KW_IF);
setState(1766);
match(KW_LET);
setState(1767);
pattern();
setState(1768);
match(EQ);
setState(1769);
expression(0);
setState(1770);
blockExpression();
setState(1777);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,232,_ctx) ) {
case 1:
{
setState(1771);
match(KW_ELSE);
setState(1775);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,231,_ctx) ) {
case 1:
{
setState(1772);
blockExpression();
}
break;
case 2:
{
setState(1773);
ifExpression();
}
break;
case 3:
{
setState(1774);
ifLetExpression();
}
break;
}
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class MatchExpressionContext extends ParserRuleContext {
public TerminalNode KW_MATCH() { return getToken(RustParser.KW_MATCH, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode LCURLYBRACE() { return getToken(RustParser.LCURLYBRACE, 0); }
public TerminalNode RCURLYBRACE() { return getToken(RustParser.RCURLYBRACE, 0); }
public List innerAttribute() {
return getRuleContexts(InnerAttributeContext.class);
}
public InnerAttributeContext innerAttribute(int i) {
return getRuleContext(InnerAttributeContext.class,i);
}
public MatchArmsContext matchArms() {
return getRuleContext(MatchArmsContext.class,0);
}
public MatchExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_matchExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterMatchExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitMatchExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitMatchExpression(this);
else return visitor.visitChildren(this);
}
}
public final MatchExpressionContext matchExpression() throws RecognitionException {
MatchExpressionContext _localctx = new MatchExpressionContext(_ctx, getState());
enterRule(_localctx, 230, RULE_matchExpression);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1779);
match(KW_MATCH);
setState(1780);
expression(0);
setState(1781);
match(LCURLYBRACE);
setState(1785);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,233,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1782);
innerAttribute();
}
}
}
setState(1787);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,233,_ctx);
}
setState(1789);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 522417558172729888L) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & 1451307245037963391L) != 0)) {
{
setState(1788);
matchArms();
}
}
setState(1791);
match(RCURLYBRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class MatchArmsContext extends ParserRuleContext {
public List matchArm() {
return getRuleContexts(MatchArmContext.class);
}
public MatchArmContext matchArm(int i) {
return getRuleContext(MatchArmContext.class,i);
}
public List FATARROW() { return getTokens(RustParser.FATARROW); }
public TerminalNode FATARROW(int i) {
return getToken(RustParser.FATARROW, i);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public List matchArmExpression() {
return getRuleContexts(MatchArmExpressionContext.class);
}
public MatchArmExpressionContext matchArmExpression(int i) {
return getRuleContext(MatchArmExpressionContext.class,i);
}
public TerminalNode COMMA() { return getToken(RustParser.COMMA, 0); }
public MatchArmsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_matchArms; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterMatchArms(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitMatchArms(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitMatchArms(this);
else return visitor.visitChildren(this);
}
}
public final MatchArmsContext matchArms() throws RecognitionException {
MatchArmsContext _localctx = new MatchArmsContext(_ctx, getState());
enterRule(_localctx, 232, RULE_matchArms);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1799);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,235,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1793);
matchArm();
setState(1794);
match(FATARROW);
setState(1795);
matchArmExpression();
}
}
}
setState(1801);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,235,_ctx);
}
setState(1802);
matchArm();
setState(1803);
match(FATARROW);
setState(1804);
expression(0);
setState(1806);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(1805);
match(COMMA);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class MatchArmExpressionContext extends ParserRuleContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode COMMA() { return getToken(RustParser.COMMA, 0); }
public ExpressionWithBlockContext expressionWithBlock() {
return getRuleContext(ExpressionWithBlockContext.class,0);
}
public MatchArmExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_matchArmExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterMatchArmExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitMatchArmExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitMatchArmExpression(this);
else return visitor.visitChildren(this);
}
}
public final MatchArmExpressionContext matchArmExpression() throws RecognitionException {
MatchArmExpressionContext _localctx = new MatchArmExpressionContext(_ctx, getState());
enterRule(_localctx, 234, RULE_matchArmExpression);
int _la;
try {
setState(1815);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,238,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1808);
expression(0);
setState(1809);
match(COMMA);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1811);
expressionWithBlock();
setState(1813);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(1812);
match(COMMA);
}
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class MatchArmContext extends ParserRuleContext {
public PatternContext pattern() {
return getRuleContext(PatternContext.class,0);
}
public List outerAttribute() {
return getRuleContexts(OuterAttributeContext.class);
}
public OuterAttributeContext outerAttribute(int i) {
return getRuleContext(OuterAttributeContext.class,i);
}
public MatchArmGuardContext matchArmGuard() {
return getRuleContext(MatchArmGuardContext.class,0);
}
public MatchArmContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_matchArm; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterMatchArm(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitMatchArm(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitMatchArm(this);
else return visitor.visitChildren(this);
}
}
public final MatchArmContext matchArm() throws RecognitionException {
MatchArmContext _localctx = new MatchArmContext(_ctx, getState());
enterRule(_localctx, 236, RULE_matchArm);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1820);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==POUND) {
{
{
setState(1817);
outerAttribute();
}
}
setState(1822);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1823);
pattern();
setState(1825);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==KW_IF) {
{
setState(1824);
matchArmGuard();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class MatchArmGuardContext extends ParserRuleContext {
public TerminalNode KW_IF() { return getToken(RustParser.KW_IF, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public MatchArmGuardContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_matchArmGuard; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterMatchArmGuard(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitMatchArmGuard(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitMatchArmGuard(this);
else return visitor.visitChildren(this);
}
}
public final MatchArmGuardContext matchArmGuard() throws RecognitionException {
MatchArmGuardContext _localctx = new MatchArmGuardContext(_ctx, getState());
enterRule(_localctx, 238, RULE_matchArmGuard);
try {
enterOuterAlt(_localctx, 1);
{
setState(1827);
match(KW_IF);
setState(1828);
expression(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PatternContext extends ParserRuleContext {
public List patternNoTopAlt() {
return getRuleContexts(PatternNoTopAltContext.class);
}
public PatternNoTopAltContext patternNoTopAlt(int i) {
return getRuleContext(PatternNoTopAltContext.class,i);
}
public List OR() { return getTokens(RustParser.OR); }
public TerminalNode OR(int i) {
return getToken(RustParser.OR, i);
}
public PatternContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_pattern; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterPattern(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitPattern(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitPattern(this);
else return visitor.visitChildren(this);
}
}
public final PatternContext pattern() throws RecognitionException {
PatternContext _localctx = new PatternContext(_ctx, getState());
enterRule(_localctx, 240, RULE_pattern);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1831);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OR) {
{
setState(1830);
match(OR);
}
}
setState(1833);
patternNoTopAlt();
setState(1838);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,242,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1834);
match(OR);
setState(1835);
patternNoTopAlt();
}
}
}
setState(1840);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,242,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PatternNoTopAltContext extends ParserRuleContext {
public PatternWithoutRangeContext patternWithoutRange() {
return getRuleContext(PatternWithoutRangeContext.class,0);
}
public RangePatternContext rangePattern() {
return getRuleContext(RangePatternContext.class,0);
}
public PatternNoTopAltContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_patternNoTopAlt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterPatternNoTopAlt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitPatternNoTopAlt(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitPatternNoTopAlt(this);
else return visitor.visitChildren(this);
}
}
public final PatternNoTopAltContext patternNoTopAlt() throws RecognitionException {
PatternNoTopAltContext _localctx = new PatternNoTopAltContext(_ctx, getState());
enterRule(_localctx, 242, RULE_patternNoTopAlt);
try {
setState(1843);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,243,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1841);
patternWithoutRange();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1842);
rangePattern();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PatternWithoutRangeContext extends ParserRuleContext {
public LiteralPatternContext literalPattern() {
return getRuleContext(LiteralPatternContext.class,0);
}
public IdentifierPatternContext identifierPattern() {
return getRuleContext(IdentifierPatternContext.class,0);
}
public WildcardPatternContext wildcardPattern() {
return getRuleContext(WildcardPatternContext.class,0);
}
public RestPatternContext restPattern() {
return getRuleContext(RestPatternContext.class,0);
}
public ReferencePatternContext referencePattern() {
return getRuleContext(ReferencePatternContext.class,0);
}
public StructPatternContext structPattern() {
return getRuleContext(StructPatternContext.class,0);
}
public TupleStructPatternContext tupleStructPattern() {
return getRuleContext(TupleStructPatternContext.class,0);
}
public TuplePatternContext tuplePattern() {
return getRuleContext(TuplePatternContext.class,0);
}
public GroupedPatternContext groupedPattern() {
return getRuleContext(GroupedPatternContext.class,0);
}
public SlicePatternContext slicePattern() {
return getRuleContext(SlicePatternContext.class,0);
}
public PathPatternContext pathPattern() {
return getRuleContext(PathPatternContext.class,0);
}
public MacroInvocationContext macroInvocation() {
return getRuleContext(MacroInvocationContext.class,0);
}
public PatternWithoutRangeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_patternWithoutRange; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterPatternWithoutRange(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitPatternWithoutRange(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitPatternWithoutRange(this);
else return visitor.visitChildren(this);
}
}
public final PatternWithoutRangeContext patternWithoutRange() throws RecognitionException {
PatternWithoutRangeContext _localctx = new PatternWithoutRangeContext(_ctx, getState());
enterRule(_localctx, 244, RULE_patternWithoutRange);
try {
setState(1857);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,244,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1845);
literalPattern();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1846);
identifierPattern();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1847);
wildcardPattern();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(1848);
restPattern();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(1849);
referencePattern();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(1850);
structPattern();
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(1851);
tupleStructPattern();
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(1852);
tuplePattern();
}
break;
case 9:
enterOuterAlt(_localctx, 9);
{
setState(1853);
groupedPattern();
}
break;
case 10:
enterOuterAlt(_localctx, 10);
{
setState(1854);
slicePattern();
}
break;
case 11:
enterOuterAlt(_localctx, 11);
{
setState(1855);
pathPattern();
}
break;
case 12:
enterOuterAlt(_localctx, 12);
{
setState(1856);
macroInvocation();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class LiteralPatternContext extends ParserRuleContext {
public TerminalNode KW_TRUE() { return getToken(RustParser.KW_TRUE, 0); }
public TerminalNode KW_FALSE() { return getToken(RustParser.KW_FALSE, 0); }
public TerminalNode CHAR_LITERAL() { return getToken(RustParser.CHAR_LITERAL, 0); }
public TerminalNode BYTE_LITERAL() { return getToken(RustParser.BYTE_LITERAL, 0); }
public TerminalNode STRING_LITERAL() { return getToken(RustParser.STRING_LITERAL, 0); }
public TerminalNode RAW_STRING_LITERAL() { return getToken(RustParser.RAW_STRING_LITERAL, 0); }
public TerminalNode BYTE_STRING_LITERAL() { return getToken(RustParser.BYTE_STRING_LITERAL, 0); }
public TerminalNode RAW_BYTE_STRING_LITERAL() { return getToken(RustParser.RAW_BYTE_STRING_LITERAL, 0); }
public TerminalNode INTEGER_LITERAL() { return getToken(RustParser.INTEGER_LITERAL, 0); }
public TerminalNode MINUS() { return getToken(RustParser.MINUS, 0); }
public TerminalNode FLOAT_LITERAL() { return getToken(RustParser.FLOAT_LITERAL, 0); }
public LiteralPatternContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_literalPattern; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterLiteralPattern(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitLiteralPattern(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitLiteralPattern(this);
else return visitor.visitChildren(this);
}
}
public final LiteralPatternContext literalPattern() throws RecognitionException {
LiteralPatternContext _localctx = new LiteralPatternContext(_ctx, getState());
enterRule(_localctx, 246, RULE_literalPattern);
int _la;
try {
setState(1875);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,247,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1859);
match(KW_TRUE);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1860);
match(KW_FALSE);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1861);
match(CHAR_LITERAL);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(1862);
match(BYTE_LITERAL);
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(1863);
match(STRING_LITERAL);
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(1864);
match(RAW_STRING_LITERAL);
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(1865);
match(BYTE_STRING_LITERAL);
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(1866);
match(RAW_BYTE_STRING_LITERAL);
}
break;
case 9:
enterOuterAlt(_localctx, 9);
{
setState(1868);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==MINUS) {
{
setState(1867);
match(MINUS);
}
}
setState(1870);
match(INTEGER_LITERAL);
}
break;
case 10:
enterOuterAlt(_localctx, 10);
{
setState(1872);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==MINUS) {
{
setState(1871);
match(MINUS);
}
}
setState(1874);
match(FLOAT_LITERAL);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class IdentifierPatternContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode KW_REF() { return getToken(RustParser.KW_REF, 0); }
public TerminalNode KW_MUT() { return getToken(RustParser.KW_MUT, 0); }
public TerminalNode AT() { return getToken(RustParser.AT, 0); }
public PatternContext pattern() {
return getRuleContext(PatternContext.class,0);
}
public IdentifierPatternContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_identifierPattern; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterIdentifierPattern(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitIdentifierPattern(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitIdentifierPattern(this);
else return visitor.visitChildren(this);
}
}
public final IdentifierPatternContext identifierPattern() throws RecognitionException {
IdentifierPatternContext _localctx = new IdentifierPatternContext(_ctx, getState());
enterRule(_localctx, 248, RULE_identifierPattern);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1878);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==KW_REF) {
{
setState(1877);
match(KW_REF);
}
}
setState(1881);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==KW_MUT) {
{
setState(1880);
match(KW_MUT);
}
}
setState(1883);
identifier();
setState(1886);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AT) {
{
setState(1884);
match(AT);
setState(1885);
pattern();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class WildcardPatternContext extends ParserRuleContext {
public TerminalNode UNDERSCORE() { return getToken(RustParser.UNDERSCORE, 0); }
public WildcardPatternContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_wildcardPattern; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterWildcardPattern(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitWildcardPattern(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitWildcardPattern(this);
else return visitor.visitChildren(this);
}
}
public final WildcardPatternContext wildcardPattern() throws RecognitionException {
WildcardPatternContext _localctx = new WildcardPatternContext(_ctx, getState());
enterRule(_localctx, 250, RULE_wildcardPattern);
try {
enterOuterAlt(_localctx, 1);
{
setState(1888);
match(UNDERSCORE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class RestPatternContext extends ParserRuleContext {
public TerminalNode DOTDOT() { return getToken(RustParser.DOTDOT, 0); }
public RestPatternContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_restPattern; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterRestPattern(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitRestPattern(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitRestPattern(this);
else return visitor.visitChildren(this);
}
}
public final RestPatternContext restPattern() throws RecognitionException {
RestPatternContext _localctx = new RestPatternContext(_ctx, getState());
enterRule(_localctx, 252, RULE_restPattern);
try {
enterOuterAlt(_localctx, 1);
{
setState(1890);
match(DOTDOT);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class RangePatternContext extends ParserRuleContext {
public RangePatternContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_rangePattern; }
public RangePatternContext() { }
public void copyFrom(RangePatternContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class InclusiveRangePatternContext extends RangePatternContext {
public List rangePatternBound() {
return getRuleContexts(RangePatternBoundContext.class);
}
public RangePatternBoundContext rangePatternBound(int i) {
return getRuleContext(RangePatternBoundContext.class,i);
}
public TerminalNode DOTDOTEQ() { return getToken(RustParser.DOTDOTEQ, 0); }
public InclusiveRangePatternContext(RangePatternContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterInclusiveRangePattern(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitInclusiveRangePattern(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof RustParserVisitor ) return ((RustParserVisitor)visitor).visitInclusiveRangePattern(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ObsoleteRangePatternContext extends RangePatternContext {
public List rangePatternBound() {
return getRuleContexts(RangePatternBoundContext.class);
}
public RangePatternBoundContext rangePatternBound(int i) {
return getRuleContext(RangePatternBoundContext.class,i);
}
public TerminalNode DOTDOTDOT() { return getToken(RustParser.DOTDOTDOT, 0); }
public ObsoleteRangePatternContext(RangePatternContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).enterObsoleteRangePattern(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof RustParserListener ) ((RustParserListener)listener).exitObsoleteRangePattern(this);
}
@Override
public