| parseUnit(enum) | |
| skipErrorTokens(enum) | |
| listener: beginCompilationUnit(enum) | |
| syntheticPreviousToken(enum) | |
| parseTopLevelDeclarationImpl(, Instance of 'DirectiveContext') | |
| parseMetadataStar() | |
| listener: beginMetadataStar(enum) | |
| listener: endMetadataStar(0) | |
| parseTopLevelKeywordDeclaration(, enum, null, Instance of 'DirectiveContext') | |
| parseEnum(enum) | |
| listener: beginUncategorizedTopLevelDeclaration(enum) | |
| ensureIdentifier(enum, enumDeclaration) | |
| listener: handleIdentifier(E, enumDeclaration) | |
| listener: beginEnum(enum) | |
| parseEnumHeaderOpt(E, enum) | |
| listener: handleNoTypeVariables(w) | |
| recoverySmallLookAheadSkipTokens(E, [{, with, implements]) | |
| reportRecoverableError(w, Message[UnexpectedToken, Unexpected token 'w'., null, {lexeme: w}]) | |
| listener: handleRecoverableError(Message[UnexpectedToken, Unexpected token 'w'., null, {lexeme: w}], w, w) | |
| parseEnumWithClauseOpt(w) | |
| listener: handleEnumNoWithClause() | |
| parseClassOrMixinOrEnumImplementsOpt(w) | |
| listener: handleImplements(null, 0) | |
| listener: handleEnumHeader(enum, {) | |
| parseEnumElement({) | |
| parseMetadataStar({) | |
| listener: beginMetadataStar(v) | |
| listener: endMetadataStar(0) | |
| ensureIdentifier({, enumValueDeclaration) | |
| listener: handleIdentifier(v, enumValueDeclaration) | |
| parseConstructorReference(v, ConstructorReferenceContext.Const, null, true) | |
| listener: handleNoTypeNameInConstructorReference(}) | |
| listener: beginConstructorReference(v) | |
| listener: handleNoTypeArguments(}) | |
| listener: handleNoConstructorReferenceContinuationAfterTypeArguments(}) | |
| listener: endConstructorReference(v, null, }, ConstructorReferenceContext.Const) | |
| listener: handleNoArguments(v) | |
| listener: handleEnumElement({) | |
| listener: handleEnumElements(}, 1) | |
| listener: endEnum(enum, {, 0) | |
| listener: endTopLevelDeclaration(enum) | |
| parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(enum) | |
| listener: endMetadataStar(0) | |
| parseTopLevelKeywordDeclaration(}, enum, null, Instance of 'DirectiveContext') | |
| parseEnum(enum) | |
| listener: beginUncategorizedTopLevelDeclaration(enum) | |
| ensureIdentifier(enum, enumDeclaration) | |
| listener: handleIdentifier(E, enumDeclaration) | |
| listener: beginEnum(enum) | |
| parseEnumHeaderOpt(E, enum) | |
| listener: handleNoTypeVariables(w) | |
| recoverySmallLookAheadSkipTokens(E, [{, with, implements]) | |
| reportRecoverableError(w, Message[UnexpectedToken, Unexpected token 'w'., null, {lexeme: w}]) | |
| listener: handleRecoverableError(Message[UnexpectedToken, Unexpected token 'w'., null, {lexeme: w}], w, w) | |
| parseEnumWithClauseOpt(w) | |
| listener: handleEnumNoWithClause() | |
| parseClassOrMixinOrEnumImplementsOpt(w) | |
| listener: handleIdentifier(Foo, typeReference) | |
| listener: handleNoTypeArguments({) | |
| listener: handleType(Foo, null) | |
| listener: handleImplements(implements, 1) | |
| listener: handleEnumHeader(enum, {) | |
| parseEnumElement({) | |
| parseMetadataStar({) | |
| listener: beginMetadataStar(v) | |
| listener: endMetadataStar(0) | |
| ensureIdentifier({, enumValueDeclaration) | |
| listener: handleIdentifier(v, enumValueDeclaration) | |
| parseConstructorReference(v, ConstructorReferenceContext.Const, null, true) | |
| listener: handleNoTypeNameInConstructorReference(}) | |
| listener: beginConstructorReference(v) | |
| listener: handleNoTypeArguments(}) | |
| listener: handleNoConstructorReferenceContinuationAfterTypeArguments(}) | |
| listener: endConstructorReference(v, null, }, ConstructorReferenceContext.Const) | |
| listener: handleNoArguments(v) | |
| listener: handleEnumElement({) | |
| listener: handleEnumElements(}, 1) | |
| listener: endEnum(enum, {, 0) | |
| listener: endTopLevelDeclaration(enum) | |
| parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(enum) | |
| listener: endMetadataStar(0) | |
| parseTopLevelKeywordDeclaration(}, enum, null, Instance of 'DirectiveContext') | |
| parseEnum(enum) | |
| listener: beginUncategorizedTopLevelDeclaration(enum) | |
| ensureIdentifier(enum, enumDeclaration) | |
| listener: handleIdentifier(E, enumDeclaration) | |
| listener: beginEnum(enum) | |
| parseEnumHeaderOpt(E, enum) | |
| listener: handleNoTypeVariables(implements) | |
| parseEnumWithClauseOpt(E) | |
| listener: handleEnumNoWithClause() | |
| parseClassOrMixinOrEnumImplementsOpt(E) | |
| listener: handleIdentifier(Foo, typeReference) | |
| listener: handleNoTypeArguments(with) | |
| listener: handleType(Foo, null) | |
| listener: handleImplements(implements, 1) | |
| recoveryEnumWith(Foo, Message[OutOfOrderClauses, The 'with' clause must come before the 'implements' clause., Try moving the 'with' clause before the 'implements' clause., {string: with, string2: implements}]) | |
| reportRecoverableError(with, Message[OutOfOrderClauses, The 'with' clause must come before the 'implements' clause., Try moving the 'with' clause before the 'implements' clause., {string: with, string2: implements}]) | |
| listener: handleRecoverableError(Message[OutOfOrderClauses, The 'with' clause must come before the 'implements' clause., Try moving the 'with' clause before the 'implements' clause., {string: with, string2: implements}], with, with) | |
| parseEnumWithClauseOpt(Foo) | |
| parseTypeList(with) | |
| listener: handleEnumHeader(enum, {) | |
| parseEnumElement({) | |
| parseMetadataStar({) | |
| listener: beginMetadataStar(v) | |
| listener: endMetadataStar(0) | |
| ensureIdentifier({, enumValueDeclaration) | |
| listener: handleIdentifier(v, enumValueDeclaration) | |
| parseConstructorReference(v, ConstructorReferenceContext.Const, null, true) | |
| listener: handleNoTypeNameInConstructorReference(}) | |
| listener: beginConstructorReference(v) | |
| listener: handleNoTypeArguments(}) | |
| listener: handleNoConstructorReferenceContinuationAfterTypeArguments(}) | |
| listener: endConstructorReference(v, null, }, ConstructorReferenceContext.Const) | |
| listener: handleNoArguments(v) | |
| listener: handleEnumElement({) | |
| listener: handleEnumElements(}, 1) | |
| listener: endEnum(enum, {, 0) | |
| listener: endTopLevelDeclaration(enum) | |
| parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(enum) | |
| listener: endMetadataStar(0) | |
| parseTopLevelKeywordDeclaration(}, enum, null, Instance of 'DirectiveContext') | |
| parseEnum(enum) | |
| listener: beginUncategorizedTopLevelDeclaration(enum) | |
| ensureIdentifier(enum, enumDeclaration) | |
| listener: handleIdentifier(E, enumDeclaration) | |
| listener: beginEnum(enum) | |
| parseEnumHeaderOpt(E, enum) | |
| listener: handleNoTypeVariables(implements) | |
| parseEnumWithClauseOpt(E) | |
| listener: handleEnumNoWithClause() | |
| parseClassOrMixinOrEnumImplementsOpt(E) | |
| listener: handleIdentifier(Foo, typeReference) | |
| listener: handleNoTypeArguments(implements) | |
| listener: handleType(Foo, null) | |
| listener: handleImplements(implements, 1) | |
| recoveryEnumWith(Foo, Message[OutOfOrderClauses, The 'with' clause must come before the 'implements' clause., Try moving the 'with' clause before the 'implements' clause., {string: with, string2: implements}]) | |
| recoveryEnumImplements(Foo, Message[MultipleClauses, Each 'enum' definition can have at most one 'implements' clause., Try combining all of the 'implements' clauses into a single clause., {string: enum, string2: implements}]) | |
| reportRecoverableError(implements, Message[MultipleClauses, Each 'enum' definition can have at most one 'implements' clause., Try combining all of the 'implements' clauses into a single clause., {string: enum, string2: implements}]) | |
| listener: handleRecoverableError(Message[MultipleClauses, Each 'enum' definition can have at most one 'implements' clause., Try combining all of the 'implements' clauses into a single clause., {string: enum, string2: implements}], implements, implements) | |
| parseClassOrMixinOrEnumImplementsOpt(Foo) | |
| recoveryEnumWith(Bar, Message[OutOfOrderClauses, The 'with' clause must come before the 'implements' clause., Try moving the 'with' clause before the 'implements' clause., {string: with, string2: implements}]) | |
| recoveryEnumImplements(Bar, Message[MultipleClauses, Each 'enum' definition can have at most one 'implements' clause., Try combining all of the 'implements' clauses into a single clause., {string: enum, string2: implements}]) | |
| reportRecoverableError(implements, Message[MultipleClauses, Each 'enum' definition can have at most one 'implements' clause., Try combining all of the 'implements' clauses into a single clause., {string: enum, string2: implements}]) | |
| listener: handleRecoverableError(Message[MultipleClauses, Each 'enum' definition can have at most one 'implements' clause., Try combining all of the 'implements' clauses into a single clause., {string: enum, string2: implements}], implements, implements) | |
| parseClassOrMixinOrEnumImplementsOpt(Bar) | |
| listener: handleEnumHeader(enum, {) | |
| parseEnumElement({) | |
| parseMetadataStar({) | |
| listener: beginMetadataStar(v) | |
| listener: endMetadataStar(0) | |
| ensureIdentifier({, enumValueDeclaration) | |
| listener: handleIdentifier(v, enumValueDeclaration) | |
| parseConstructorReference(v, ConstructorReferenceContext.Const, null, true) | |
| listener: handleNoTypeNameInConstructorReference(}) | |
| listener: beginConstructorReference(v) | |
| listener: handleNoTypeArguments(}) | |
| listener: handleNoConstructorReferenceContinuationAfterTypeArguments(}) | |
| listener: endConstructorReference(v, null, }, ConstructorReferenceContext.Const) | |
| listener: handleNoArguments(v) | |
| listener: handleEnumElement({) | |
| listener: handleEnumElements(}, 1) | |
| listener: endEnum(enum, {, 0) | |
| listener: endTopLevelDeclaration(enum) | |
| parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(enum) | |
| listener: endMetadataStar(0) | |
| parseTopLevelKeywordDeclaration(}, enum, null, Instance of 'DirectiveContext') | |
| parseEnum(enum) | |
| listener: beginUncategorizedTopLevelDeclaration(enum) | |
| ensureIdentifier(enum, enumDeclaration) | |
| listener: handleIdentifier(E, enumDeclaration) | |
| listener: beginEnum(enum) | |
| parseEnumHeaderOpt(E, enum) | |
| listener: handleNoTypeVariables(w) | |
| recoverySmallLookAheadSkipTokens(E, [{, with, implements]) | |
| reportRecoverableErrorWithEnd(w, Foo, UnexpectedTokens) | |
| listener: handleRecoverableError(UnexpectedTokens, w, Foo) | |
| parseEnumWithClauseOpt(Foo) | |
| listener: handleEnumNoWithClause() | |
| parseClassOrMixinOrEnumImplementsOpt(Foo) | |
| listener: handleImplements(null, 0) | |
| listener: handleEnumHeader(enum, {) | |
| parseEnumElement({) | |
| parseMetadataStar({) | |
| listener: beginMetadataStar(v) | |
| listener: endMetadataStar(0) | |
| ensureIdentifier({, enumValueDeclaration) | |
| listener: handleIdentifier(v, enumValueDeclaration) | |
| parseConstructorReference(v, ConstructorReferenceContext.Const, null, true) | |
| listener: handleNoTypeNameInConstructorReference(}) | |
| listener: beginConstructorReference(v) | |
| listener: handleNoTypeArguments(}) | |
| listener: handleNoConstructorReferenceContinuationAfterTypeArguments(}) | |
| listener: endConstructorReference(v, null, }, ConstructorReferenceContext.Const) | |
| listener: handleNoArguments(v) | |
| listener: handleEnumElement({) | |
| listener: handleEnumElements(}, 1) | |
| listener: endEnum(enum, {, 0) | |
| listener: endTopLevelDeclaration(enum) | |
| parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(enum) | |
| listener: endMetadataStar(0) | |
| parseTopLevelKeywordDeclaration(}, enum, null, Instance of 'DirectiveContext') | |
| parseEnum(enum) | |
| listener: beginUncategorizedTopLevelDeclaration(enum) | |
| ensureIdentifier(enum, enumDeclaration) | |
| listener: handleIdentifier(E, enumDeclaration) | |
| listener: beginEnum(enum) | |
| parseEnumHeaderOpt(E, enum) | |
| listener: handleNoTypeVariables(implemen) | |
| recoverySmallLookAheadSkipTokens(E, [{, with, implements]) | |
| reportRecoverableError(implemen, Message[UnexpectedToken, Unexpected token 'implemen'., null, {lexeme: implemen}]) | |
| listener: handleRecoverableError(Message[UnexpectedToken, Unexpected token 'implemen'., null, {lexeme: implemen}], implemen, implemen) | |
| parseEnumWithClauseOpt(implemen) | |
| listener: handleEnumNoWithClause() | |
| parseClassOrMixinOrEnumImplementsOpt(implemen) | |
| listener: handleImplements(null, 0) | |
| listener: handleEnumHeader(enum, {) | |
| parseEnumElement({) | |
| parseMetadataStar({) | |
| listener: beginMetadataStar(v) | |
| listener: endMetadataStar(0) | |
| ensureIdentifier({, enumValueDeclaration) | |
| listener: handleIdentifier(v, enumValueDeclaration) | |
| parseConstructorReference(v, ConstructorReferenceContext.Const, null, true) | |
| listener: handleNoTypeNameInConstructorReference(}) | |
| listener: beginConstructorReference(v) | |
| listener: handleNoTypeArguments(}) | |
| listener: handleNoConstructorReferenceContinuationAfterTypeArguments(}) | |
| listener: endConstructorReference(v, null, }, ConstructorReferenceContext.Const) | |
| listener: handleNoArguments(v) | |
| listener: handleEnumElement({) | |
| listener: handleEnumElements(}, 1) | |
| listener: endEnum(enum, {, 0) | |
| listener: endTopLevelDeclaration(enum) | |
| parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(enum) | |
| listener: endMetadataStar(0) | |
| parseTopLevelKeywordDeclaration(}, enum, null, Instance of 'DirectiveContext') | |
| parseEnum(enum) | |
| listener: beginUncategorizedTopLevelDeclaration(enum) | |
| ensureIdentifier(enum, enumDeclaration) | |
| listener: handleIdentifier(E, enumDeclaration) | |
| listener: beginEnum(enum) | |
| parseEnumHeaderOpt(E, enum) | |
| listener: handleNoTypeVariables(implements) | |
| parseEnumWithClauseOpt(E) | |
| listener: handleEnumNoWithClause() | |
| parseClassOrMixinOrEnumImplementsOpt(E) | |
| listener: handleIdentifier(Foo, typeReference) | |
| listener: handleNoTypeArguments(w) | |
| listener: handleType(Foo, null) | |
| listener: handleImplements(implements, 1) | |
| recoveryEnumWith(Foo, Message[OutOfOrderClauses, The 'with' clause must come before the 'implements' clause., Try moving the 'with' clause before the 'implements' clause., {string: with, string2: implements}]) | |
| recoveryEnumImplements(Foo, Message[MultipleClauses, Each 'enum' definition can have at most one 'implements' clause., Try combining all of the 'implements' clauses into a single clause., {string: enum, string2: implements}]) | |
| recoverySmallLookAheadSkipTokens(Foo, [{, with, implements]) | |
| reportRecoverableError(w, Message[UnexpectedToken, Unexpected token 'w'., null, {lexeme: w}]) | |
| listener: handleRecoverableError(Message[UnexpectedToken, Unexpected token 'w'., null, {lexeme: w}], w, w) | |
| listener: handleEnumHeader(enum, {) | |
| parseEnumElement({) | |
| parseMetadataStar({) | |
| listener: beginMetadataStar(v) | |
| listener: endMetadataStar(0) | |
| ensureIdentifier({, enumValueDeclaration) | |
| listener: handleIdentifier(v, enumValueDeclaration) | |
| parseConstructorReference(v, ConstructorReferenceContext.Const, null, true) | |
| listener: handleNoTypeNameInConstructorReference(}) | |
| listener: beginConstructorReference(v) | |
| listener: handleNoTypeArguments(}) | |
| listener: handleNoConstructorReferenceContinuationAfterTypeArguments(}) | |
| listener: endConstructorReference(v, null, }, ConstructorReferenceContext.Const) | |
| listener: handleNoArguments(v) | |
| listener: handleEnumElement({) | |
| listener: handleEnumElements(}, 1) | |
| listener: endEnum(enum, {, 0) | |
| listener: endTopLevelDeclaration(enum) | |
| parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(enum) | |
| listener: endMetadataStar(0) | |
| parseTopLevelKeywordDeclaration(}, enum, null, Instance of 'DirectiveContext') | |
| parseEnum(enum) | |
| listener: beginUncategorizedTopLevelDeclaration(enum) | |
| ensureIdentifier(enum, enumDeclaration) | |
| listener: handleIdentifier(E, enumDeclaration) | |
| listener: beginEnum(enum) | |
| parseEnumHeaderOpt(E, enum) | |
| listener: handleNoTypeVariables(with) | |
| parseEnumWithClauseOpt(E) | |
| parseTypeList(with) | |
| listener: beginTypeList({) | |
| reportRecoverableErrorWithToken({, Instance of 'Template<(Token) => Message>') | |
| listener: handleRecoverableError(Message[ExpectedType, Expected a type, but got '{'., null, {lexeme: {}], {, {) | |
| rewriter() | |
| listener: handleIdentifier(, typeReference) | |
| listener: handleNoTypeArguments({) | |
| listener: handleType(, null) | |
| listener: endTypeList(1) | |
| listener: handleEnumWithClause(with) | |
| parseClassOrMixinOrEnumImplementsOpt() | |
| listener: handleImplements(null, 0) | |
| listener: handleEnumHeader(enum, {) | |
| parseEnumElement({) | |
| parseMetadataStar({) | |
| listener: beginMetadataStar(v) | |
| listener: endMetadataStar(0) | |
| ensureIdentifier({, enumValueDeclaration) | |
| listener: handleIdentifier(v, enumValueDeclaration) | |
| parseConstructorReference(v, ConstructorReferenceContext.Const, null, true) | |
| listener: handleNoTypeNameInConstructorReference(}) | |
| listener: beginConstructorReference(v) | |
| listener: handleNoTypeArguments(}) | |
| listener: handleNoConstructorReferenceContinuationAfterTypeArguments(}) | |
| listener: endConstructorReference(v, null, }, ConstructorReferenceContext.Const) | |
| listener: handleNoArguments(v) | |
| listener: handleEnumElement({) | |
| listener: handleEnumElements(}, 1) | |
| listener: endEnum(enum, {, 0) | |
| listener: endTopLevelDeclaration(enum) | |
| parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(enum) | |
| listener: endMetadataStar(0) | |
| parseTopLevelKeywordDeclaration(}, enum, null, Instance of 'DirectiveContext') | |
| parseEnum(enum) | |
| listener: beginUncategorizedTopLevelDeclaration(enum) | |
| ensureIdentifier(enum, enumDeclaration) | |
| listener: handleIdentifier(E, enumDeclaration) | |
| listener: beginEnum(enum) | |
| parseEnumHeaderOpt(E, enum) | |
| listener: handleNoTypeVariables(impl) | |
| recoverySmallLookAheadSkipTokens(E, [{, with, implements]) | |
| reportRecoverableError(impl, Message[UnexpectedToken, Unexpected token 'impl'., null, {lexeme: impl}]) | |
| listener: handleRecoverableError(Message[UnexpectedToken, Unexpected token 'impl'., null, {lexeme: impl}], impl, impl) | |
| parseEnumWithClauseOpt(impl) | |
| listener: handleEnumNoWithClause() | |
| parseClassOrMixinOrEnumImplementsOpt(impl) | |
| listener: handleIdentifier(Foo, typeReference) | |
| listener: handleNoTypeArguments({) | |
| listener: handleType(Foo, null) | |
| listener: handleImplements(implements, 1) | |
| listener: handleEnumHeader(enum, {) | |
| parseEnumElement({) | |
| parseMetadataStar({) | |
| listener: beginMetadataStar(v) | |
| listener: endMetadataStar(0) | |
| ensureIdentifier({, enumValueDeclaration) | |
| listener: handleIdentifier(v, enumValueDeclaration) | |
| parseConstructorReference(v, ConstructorReferenceContext.Const, null, true) | |
| listener: handleNoTypeNameInConstructorReference(}) | |
| listener: beginConstructorReference(v) | |
| listener: handleNoTypeArguments(}) | |
| listener: handleNoConstructorReferenceContinuationAfterTypeArguments(}) | |
| listener: endConstructorReference(v, null, }, ConstructorReferenceContext.Const) | |
| listener: handleNoArguments(v) | |
| listener: handleEnumElement({) | |
| listener: handleEnumElements(}, 1) | |
| listener: endEnum(enum, {, 0) | |
| listener: endTopLevelDeclaration(enum) | |
| parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(enum) | |
| listener: endMetadataStar(0) | |
| parseTopLevelKeywordDeclaration(}, enum, null, Instance of 'DirectiveContext') | |
| parseEnum(enum) | |
| listener: beginUncategorizedTopLevelDeclaration(enum) | |
| ensureIdentifier(enum, enumDeclaration) | |
| listener: handleIdentifier(E, enumDeclaration) | |
| listener: beginEnum(enum) | |
| parseEnumHeaderOpt(E, enum) | |
| listener: handleNoTypeVariables(with) | |
| parseEnumWithClauseOpt(E) | |
| parseTypeList(with) | |
| listener: beginTypeList(Foo) | |
| listener: handleIdentifier(Foo, typeReference) | |
| listener: handleNoTypeArguments(implements) | |
| listener: handleType(Foo, null) | |
| listener: endTypeList(1) | |
| listener: handleEnumWithClause(with) | |
| parseClassOrMixinOrEnumImplementsOpt(Foo) | |
| listener: handleIdentifier(Bar, typeReference) | |
| listener: handleNoTypeArguments({) | |
| listener: handleType(Bar, null) | |
| listener: handleImplements(implements, 1) | |
| listener: handleEnumHeader(enum, {) | |
| parseEnumElement({) | |
| parseMetadataStar({) | |
| listener: beginMetadataStar(v) | |
| listener: endMetadataStar(0) | |
| ensureIdentifier({, enumValueDeclaration) | |
| listener: handleIdentifier(v, enumValueDeclaration) | |
| parseConstructorReference(v, ConstructorReferenceContext.Const, null, true) | |
| listener: handleNoTypeNameInConstructorReference(}) | |
| listener: beginConstructorReference(v) | |
| listener: handleNoTypeArguments(}) | |
| listener: handleNoConstructorReferenceContinuationAfterTypeArguments(}) | |
| listener: endConstructorReference(v, null, }, ConstructorReferenceContext.Const) | |
| listener: handleNoArguments(v) | |
| listener: handleEnumElement({) | |
| listener: handleEnumElements(}, 1) | |
| listener: endEnum(enum, {, 0) | |
| listener: endTopLevelDeclaration(enum) | |
| parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(enum) | |
| listener: endMetadataStar(0) | |
| parseTopLevelKeywordDeclaration(}, enum, null, Instance of 'DirectiveContext') | |
| parseEnum(enum) | |
| listener: beginUncategorizedTopLevelDeclaration(enum) | |
| ensureIdentifier(enum, enumDeclaration) | |
| listener: handleIdentifier(E, enumDeclaration) | |
| listener: beginEnum(enum) | |
| parseEnumHeaderOpt(E, enum) | |
| listener: handleNoTypeVariables(implements) | |
| parseEnumWithClauseOpt(E) | |
| listener: handleEnumNoWithClause() | |
| parseClassOrMixinOrEnumImplementsOpt(E) | |
| listener: handleIdentifier(Bar, typeReference) | |
| listener: handleNoTypeArguments(with) | |
| listener: handleType(Bar, null) | |
| listener: handleImplements(implements, 1) | |
| recoveryEnumWith(Bar, Message[OutOfOrderClauses, The 'with' clause must come before the 'implements' clause., Try moving the 'with' clause before the 'implements' clause., {string: with, string2: implements}]) | |
| reportRecoverableError(with, Message[OutOfOrderClauses, The 'with' clause must come before the 'implements' clause., Try moving the 'with' clause before the 'implements' clause., {string: with, string2: implements}]) | |
| listener: handleRecoverableError(Message[OutOfOrderClauses, The 'with' clause must come before the 'implements' clause., Try moving the 'with' clause before the 'implements' clause., {string: with, string2: implements}], with, with) | |
| parseEnumWithClauseOpt(Bar) | |
| parseTypeList(with) | |
| listener: handleEnumHeader(enum, {) | |
| parseEnumElement({) | |
| parseMetadataStar({) | |
| listener: beginMetadataStar(v) | |
| listener: endMetadataStar(0) | |
| ensureIdentifier({, enumValueDeclaration) | |
| listener: handleIdentifier(v, enumValueDeclaration) | |
| parseConstructorReference(v, ConstructorReferenceContext.Const, null, true) | |
| listener: handleNoTypeNameInConstructorReference(}) | |
| listener: beginConstructorReference(v) | |
| listener: handleNoTypeArguments(}) | |
| listener: handleNoConstructorReferenceContinuationAfterTypeArguments(}) | |
| listener: endConstructorReference(v, null, }, ConstructorReferenceContext.Const) | |
| listener: handleNoArguments(v) | |
| listener: handleEnumElement({) | |
| listener: handleEnumElements(}, 1) | |
| listener: endEnum(enum, {, 0) | |
| listener: endTopLevelDeclaration(enum) | |
| parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(enum) | |
| listener: endMetadataStar(0) | |
| parseTopLevelKeywordDeclaration(}, enum, null, Instance of 'DirectiveContext') | |
| parseEnum(enum) | |
| listener: beginUncategorizedTopLevelDeclaration(enum) | |
| ensureIdentifier(enum, enumDeclaration) | |
| listener: handleIdentifier(E, enumDeclaration) | |
| listener: beginEnum(enum) | |
| parseEnumHeaderOpt(E, enum) | |
| listener: handleNoTypeVariables(gunk1) | |
| recoverySmallLookAheadSkipTokens(E, [{, with, implements]) | |
| reportRecoverableError(gunk1, Message[UnexpectedToken, Unexpected token 'gunk1'., null, {lexeme: gunk1}]) | |
| listener: handleRecoverableError(Message[UnexpectedToken, Unexpected token 'gunk1'., null, {lexeme: gunk1}], gunk1, gunk1) | |
| parseEnumWithClauseOpt(gunk1) | |
| parseTypeList(with) | |
| listener: beginTypeList(Foo) | |
| listener: handleIdentifier(Foo, typeReference) | |
| listener: handleNoTypeArguments(gunk2) | |
| listener: handleType(Foo, null) | |
| listener: endTypeList(1) | |
| listener: handleEnumWithClause(with) | |
| recoveryEnumWith(Foo, Message[MultipleClauses, Each 'enum' definition can have at most one 'with' clause., Try combining all of the 'with' clauses into a single clause., {string: enum, string2: with}]) | |
| recoverySmallLookAheadSkipTokens(Foo, [{, with, implements]) | |
| reportRecoverableError(gunk2, Message[UnexpectedToken, Unexpected token 'gunk2'., null, {lexeme: gunk2}]) | |
| listener: handleRecoverableError(Message[UnexpectedToken, Unexpected token 'gunk2'., null, {lexeme: gunk2}], gunk2, gunk2) | |
| parseClassOrMixinOrEnumImplementsOpt(gunk2) | |
| listener: handleIdentifier(Bar, typeReference) | |
| listener: handleNoTypeArguments({) | |
| listener: handleType(Bar, null) | |
| listener: handleImplements(implements, 1) | |
| listener: handleEnumHeader(enum, {) | |
| parseEnumElement({) | |
| parseMetadataStar({) | |
| listener: beginMetadataStar(v) | |
| listener: endMetadataStar(0) | |
| ensureIdentifier({, enumValueDeclaration) | |
| listener: handleIdentifier(v, enumValueDeclaration) | |
| parseConstructorReference(v, ConstructorReferenceContext.Const, null, true) | |
| listener: handleNoTypeNameInConstructorReference(}) | |
| listener: beginConstructorReference(v) | |
| listener: handleNoTypeArguments(}) | |
| listener: handleNoConstructorReferenceContinuationAfterTypeArguments(}) | |
| listener: endConstructorReference(v, null, }, ConstructorReferenceContext.Const) | |
| listener: handleNoArguments(v) | |
| listener: handleEnumElement({) | |
| listener: handleEnumElements(}, 1) | |
| listener: endEnum(enum, {, 0) | |
| listener: endTopLevelDeclaration(enum) | |
| parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(enum) | |
| listener: endMetadataStar(0) | |
| parseTopLevelKeywordDeclaration(}, enum, null, Instance of 'DirectiveContext') | |
| parseEnum(enum) | |
| listener: beginUncategorizedTopLevelDeclaration(enum) | |
| ensureIdentifier(enum, enumDeclaration) | |
| listener: handleIdentifier(E, enumDeclaration) | |
| listener: beginEnum(enum) | |
| parseEnumHeaderOpt(E, enum) | |
| listener: handleNoTypeVariables(gunk1) | |
| recoverySmallLookAheadSkipTokens(E, [{, with, implements]) | |
| reportRecoverableError(gunk1, Message[UnexpectedToken, Unexpected token 'gunk1'., null, {lexeme: gunk1}]) | |
| listener: handleRecoverableError(Message[UnexpectedToken, Unexpected token 'gunk1'., null, {lexeme: gunk1}], gunk1, gunk1) | |
| parseEnumWithClauseOpt(gunk1) | |
| listener: handleEnumNoWithClause() | |
| parseClassOrMixinOrEnumImplementsOpt(gunk1) | |
| listener: handleIdentifier(Bar, typeReference) | |
| listener: handleNoTypeArguments(gunk2) | |
| listener: handleType(Bar, null) | |
| listener: handleImplements(implements, 1) | |
| recoveryEnumWith(Bar, Message[OutOfOrderClauses, The 'with' clause must come before the 'implements' clause., Try moving the 'with' clause before the 'implements' clause., {string: with, string2: implements}]) | |
| recoveryEnumImplements(Bar, Message[MultipleClauses, Each 'enum' definition can have at most one 'implements' clause., Try combining all of the 'implements' clauses into a single clause., {string: enum, string2: implements}]) | |
| recoverySmallLookAheadSkipTokens(Bar, [{, with, implements]) | |
| reportRecoverableError(gunk2, Message[UnexpectedToken, Unexpected token 'gunk2'., null, {lexeme: gunk2}]) | |
| listener: handleRecoverableError(Message[UnexpectedToken, Unexpected token 'gunk2'., null, {lexeme: gunk2}], gunk2, gunk2) | |
| recoveryEnumWith(gunk2, Message[OutOfOrderClauses, The 'with' clause must come before the 'implements' clause., Try moving the 'with' clause before the 'implements' clause., {string: with, string2: implements}]) | |
| reportRecoverableError(with, Message[OutOfOrderClauses, The 'with' clause must come before the 'implements' clause., Try moving the 'with' clause before the 'implements' clause., {string: with, string2: implements}]) | |
| listener: handleRecoverableError(Message[OutOfOrderClauses, The 'with' clause must come before the 'implements' clause., Try moving the 'with' clause before the 'implements' clause., {string: with, string2: implements}], with, with) | |
| parseEnumWithClauseOpt(gunk2) | |
| parseTypeList(with) | |
| listener: handleEnumHeader(enum, {) | |
| parseEnumElement({) | |
| parseMetadataStar({) | |
| listener: beginMetadataStar(v) | |
| listener: endMetadataStar(0) | |
| ensureIdentifier({, enumValueDeclaration) | |
| listener: handleIdentifier(v, enumValueDeclaration) | |
| parseConstructorReference(v, ConstructorReferenceContext.Const, null, true) | |
| listener: handleNoTypeNameInConstructorReference(}) | |
| listener: beginConstructorReference(v) | |
| listener: handleNoTypeArguments(}) | |
| listener: handleNoConstructorReferenceContinuationAfterTypeArguments(}) | |
| listener: endConstructorReference(v, null, }, ConstructorReferenceContext.Const) | |
| listener: handleNoArguments(v) | |
| listener: handleEnumElement({) | |
| listener: handleEnumElements(}, 1) | |
| listener: endEnum(enum, {, 0) | |
| listener: endTopLevelDeclaration(enum) | |
| parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(enum) | |
| listener: endMetadataStar(0) | |
| parseTopLevelKeywordDeclaration(}, enum, null, Instance of 'DirectiveContext') | |
| parseEnum(enum) | |
| listener: beginUncategorizedTopLevelDeclaration(enum) | |
| ensureIdentifier(enum, enumDeclaration) | |
| listener: handleIdentifier(E, enumDeclaration) | |
| listener: beginEnum(enum) | |
| parseEnumHeaderOpt(E, enum) | |
| listener: handleNoTypeVariables(with) | |
| parseEnumWithClauseOpt(E) | |
| parseTypeList(with) | |
| listener: beginTypeList(Foo) | |
| listener: handleIdentifier(Foo, typeReference) | |
| listener: handleNoTypeArguments(with) | |
| listener: handleType(Foo, null) | |
| listener: endTypeList(1) | |
| listener: handleEnumWithClause(with) | |
| recoveryEnumWith(Foo, Message[MultipleClauses, Each 'enum' definition can have at most one 'with' clause., Try combining all of the 'with' clauses into a single clause., {string: enum, string2: with}]) | |
| reportRecoverableError(with, Message[MultipleClauses, Each 'enum' definition can have at most one 'with' clause., Try combining all of the 'with' clauses into a single clause., {string: enum, string2: with}]) | |
| listener: handleRecoverableError(Message[MultipleClauses, Each 'enum' definition can have at most one 'with' clause., Try combining all of the 'with' clauses into a single clause., {string: enum, string2: with}], with, with) | |
| parseEnumWithClauseOpt(Foo) | |
| parseTypeList(with) | |
| parseClassOrMixinOrEnumImplementsOpt(Foo2) | |
| listener: handleIdentifier(Bar, typeReference) | |
| listener: handleNoTypeArguments(implements) | |
| listener: handleType(Bar, null) | |
| listener: handleImplements(implements, 1) | |
| recoveryEnumWith(Bar, Message[MultipleClauses, Each 'enum' definition can have at most one 'with' clause., Try combining all of the 'with' clauses into a single clause., {string: enum, string2: with}]) | |
| recoveryEnumImplements(Bar, Message[MultipleClauses, Each 'enum' definition can have at most one 'implements' clause., Try combining all of the 'implements' clauses into a single clause., {string: enum, string2: implements}]) | |
| reportRecoverableError(implements, Message[MultipleClauses, Each 'enum' definition can have at most one 'implements' clause., Try combining all of the 'implements' clauses into a single clause., {string: enum, string2: implements}]) | |
| listener: handleRecoverableError(Message[MultipleClauses, Each 'enum' definition can have at most one 'implements' clause., Try combining all of the 'implements' clauses into a single clause., {string: enum, string2: implements}], implements, implements) | |
| parseClassOrMixinOrEnumImplementsOpt(Bar) | |
| recoveryEnumWith(Bar2, Message[MultipleClauses, Each 'enum' definition can have at most one 'with' clause., Try combining all of the 'with' clauses into a single clause., {string: enum, string2: with}]) | |
| reportRecoverableError(with, Message[MultipleClauses, Each 'enum' definition can have at most one 'with' clause., Try combining all of the 'with' clauses into a single clause., {string: enum, string2: with}]) | |
| listener: handleRecoverableError(Message[MultipleClauses, Each 'enum' definition can have at most one 'with' clause., Try combining all of the 'with' clauses into a single clause., {string: enum, string2: with}], with, with) | |
| parseEnumWithClauseOpt(Bar2) | |
| parseTypeList(with) | |
| recoveryEnumWith(Foo3, Message[MultipleClauses, Each 'enum' definition can have at most one 'with' clause., Try combining all of the 'with' clauses into a single clause., {string: enum, string2: with}]) | |
| recoveryEnumImplements(Foo3, Message[MultipleClauses, Each 'enum' definition can have at most one 'implements' clause., Try combining all of the 'implements' clauses into a single clause., {string: enum, string2: implements}]) | |
| reportRecoverableError(implements, Message[MultipleClauses, Each 'enum' definition can have at most one 'implements' clause., Try combining all of the 'implements' clauses into a single clause., {string: enum, string2: implements}]) | |
| listener: handleRecoverableError(Message[MultipleClauses, Each 'enum' definition can have at most one 'implements' clause., Try combining all of the 'implements' clauses into a single clause., {string: enum, string2: implements}], implements, implements) | |
| parseClassOrMixinOrEnumImplementsOpt(Foo3) | |
| listener: handleEnumHeader(enum, {) | |
| parseEnumElement({) | |
| parseMetadataStar({) | |
| listener: beginMetadataStar(v) | |
| listener: endMetadataStar(0) | |
| ensureIdentifier({, enumValueDeclaration) | |
| listener: handleIdentifier(v, enumValueDeclaration) | |
| parseConstructorReference(v, ConstructorReferenceContext.Const, null, true) | |
| listener: handleNoTypeNameInConstructorReference(}) | |
| listener: beginConstructorReference(v) | |
| listener: handleNoTypeArguments(}) | |
| listener: handleNoConstructorReferenceContinuationAfterTypeArguments(}) | |
| listener: endConstructorReference(v, null, }, ConstructorReferenceContext.Const) | |
| listener: handleNoArguments(v) | |
| listener: handleEnumElement({) | |
| listener: handleEnumElements(}, 1) | |
| listener: endEnum(enum, {, 0) | |
| listener: endTopLevelDeclaration(enum) | |
| parseTopLevelDeclarationImpl(}, Instance of 'DirectiveContext') | |
| parseMetadataStar(}) | |
| listener: beginMetadataStar(enum) | |
| listener: endMetadataStar(0) | |
| parseTopLevelKeywordDeclaration(}, enum, null, Instance of 'DirectiveContext') | |
| parseEnum(enum) | |
| listener: beginUncategorizedTopLevelDeclaration(enum) | |
| ensureIdentifier(enum, enumDeclaration) | |
| listener: handleIdentifier(E, enumDeclaration) | |
| listener: beginEnum(enum) | |
| parseEnumHeaderOpt(E, enum) | |
| listener: handleNoTypeVariables(implements) | |
| parseEnumWithClauseOpt(E) | |
| listener: handleEnumNoWithClause() | |
| parseClassOrMixinOrEnumImplementsOpt(E) | |
| listener: handleIdentifier(Bar, typeReference) | |
| listener: handleNoTypeArguments(implements) | |
| listener: handleType(Bar, null) | |
| listener: handleImplements(implements, 1) | |
| recoveryEnumWith(Bar, Message[OutOfOrderClauses, The 'with' clause must come before the 'implements' clause., Try moving the 'with' clause before the 'implements' clause., {string: with, string2: implements}]) | |
| recoveryEnumImplements(Bar, Message[MultipleClauses, Each 'enum' definition can have at most one 'implements' clause., Try combining all of the 'implements' clauses into a single clause., {string: enum, string2: implements}]) | |
| reportRecoverableError(implements, Message[MultipleClauses, Each 'enum' definition can have at most one 'implements' clause., Try combining all of the 'implements' clauses into a single clause., {string: enum, string2: implements}]) | |
| listener: handleRecoverableError(Message[MultipleClauses, Each 'enum' definition can have at most one 'implements' clause., Try combining all of the 'implements' clauses into a single clause., {string: enum, string2: implements}], implements, implements) | |
| parseClassOrMixinOrEnumImplementsOpt(Bar) | |
| recoveryEnumWith(Bar2, Message[OutOfOrderClauses, The 'with' clause must come before the 'implements' clause., Try moving the 'with' clause before the 'implements' clause., {string: with, string2: implements}]) | |
| reportRecoverableError(with, Message[OutOfOrderClauses, The 'with' clause must come before the 'implements' clause., Try moving the 'with' clause before the 'implements' clause., {string: with, string2: implements}]) | |
| listener: handleRecoverableError(Message[OutOfOrderClauses, The 'with' clause must come before the 'implements' clause., Try moving the 'with' clause before the 'implements' clause., {string: with, string2: implements}], with, with) | |
| parseEnumWithClauseOpt(Bar2) | |
| parseTypeList(with) | |
| recoveryEnumWith(Foo, Message[MultipleClauses, Each 'enum' definition can have at most one 'with' clause., Try combining all of the 'with' clauses into a single clause., {string: enum, string2: with}]) | |
| reportRecoverableError(with, Message[MultipleClauses, Each 'enum' definition can have at most one 'with' clause., Try combining all of the 'with' clauses into a single clause., {string: enum, string2: with}]) | |
| listener: handleRecoverableError(Message[MultipleClauses, Each 'enum' definition can have at most one 'with' clause., Try combining all of the 'with' clauses into a single clause., {string: enum, string2: with}], with, with) | |
| parseEnumWithClauseOpt(Foo) | |
| parseTypeList(with) | |
| recoveryEnumWith(Foo2, Message[MultipleClauses, Each 'enum' definition can have at most one 'with' clause., Try combining all of the 'with' clauses into a single clause., {string: enum, string2: with}]) | |
| recoveryEnumImplements(Foo2, Message[MultipleClauses, Each 'enum' definition can have at most one 'implements' clause., Try combining all of the 'implements' clauses into a single clause., {string: enum, string2: implements}]) | |
| reportRecoverableError(implements, Message[MultipleClauses, Each 'enum' definition can have at most one 'implements' clause., Try combining all of the 'implements' clauses into a single clause., {string: enum, string2: implements}]) | |
| listener: handleRecoverableError(Message[MultipleClauses, Each 'enum' definition can have at most one 'implements' clause., Try combining all of the 'implements' clauses into a single clause., {string: enum, string2: implements}], implements, implements) | |
| parseClassOrMixinOrEnumImplementsOpt(Foo2) | |
| recoveryEnumWith(Bar3, Message[MultipleClauses, Each 'enum' definition can have at most one 'with' clause., Try combining all of the 'with' clauses into a single clause., {string: enum, string2: with}]) | |
| reportRecoverableError(with, Message[MultipleClauses, Each 'enum' definition can have at most one 'with' clause., Try combining all of the 'with' clauses into a single clause., {string: enum, string2: with}]) | |
| listener: handleRecoverableError(Message[MultipleClauses, Each 'enum' definition can have at most one 'with' clause., Try combining all of the 'with' clauses into a single clause., {string: enum, string2: with}], with, with) | |
| parseEnumWithClauseOpt(Bar3) | |
| parseTypeList(with) | |
| listener: handleEnumHeader(enum, {) | |
| parseEnumElement({) | |
| parseMetadataStar({) | |
| listener: beginMetadataStar(v) | |
| listener: endMetadataStar(0) | |
| ensureIdentifier({, enumValueDeclaration) | |
| listener: handleIdentifier(v, enumValueDeclaration) | |
| parseConstructorReference(v, ConstructorReferenceContext.Const, null, true) | |
| listener: handleNoTypeNameInConstructorReference(}) | |
| listener: beginConstructorReference(v) | |
| listener: handleNoTypeArguments(}) | |
| listener: handleNoConstructorReferenceContinuationAfterTypeArguments(}) | |
| listener: endConstructorReference(v, null, }, ConstructorReferenceContext.Const) | |
| listener: handleNoArguments(v) | |
| listener: handleEnumElement({) | |
| listener: handleEnumElements(}, 1) | |
| listener: endEnum(enum, {, 0) | |
| listener: endTopLevelDeclaration() | |
| reportAllErrorTokens(enum) | |
| listener: endCompilationUnit(15, ) |