blob: 60507f09121b700a9805e96a5a84e821cfbe4c71 [file] [log] [blame]
parseUnit(abstract)
skipErrorTokens(abstract)
listener: beginCompilationUnit(abstract)
syntheticPreviousToken(abstract)
parseTopLevelDeclarationImpl(, Instance of 'DirectiveContext')
parseMetadataStar()
listener: beginMetadataStar(abstract)
listener: endMetadataStar(0)
parseTopLevelKeywordDeclaration(, class, Instance of 'DirectiveContext')
parseClassDeclarationModifiers(, class)
parseTopLevelKeywordModifiers(abstract, class)
parseClassOrNamedMixinApplication(abstract, class)
listener: beginClassOrNamedMixinApplicationPrelude(abstract)
ensureIdentifier(class, classOrMixinDeclaration)
listener: handleIdentifier(Key, classOrMixinDeclaration)
listener: handleNoTypeVariables({)
listener: beginClassDeclaration(abstract, abstract, Key)
parseClass(Key, abstract, class, Key)
parseClassHeaderOpt(Key, abstract, class)
parseClassExtendsOpt(Key)
listener: handleNoType(Key)
listener: handleClassExtends(null, 1)
parseWithClauseOpt(Key)
listener: handleClassNoWithClause()
parseClassOrMixinImplementsOpt(Key)
listener: handleClassOrMixinImplements(null, 0)
listener: handleClassHeader(abstract, class, null)
parseClassOrMixinOrExtensionBody(Key, DeclarationKind.Class, Key)
listener: beginClassOrMixinBody(DeclarationKind.Class, {)
notEofOrValue(}, int)
parseClassOrMixinOrExtensionMemberImpl({, DeclarationKind.Class, Key)
parseMetadataStar({)
listener: beginMetadataStar(int)
listener: endMetadataStar(0)
listener: beginMember()
parseMethod({, null, null, null, null, null, null, {, Instance of 'SimpleType', get, a, DeclarationKind.Class, Key, false)
listener: beginMethod(null, null, null, null, get, a)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(get)
listener: handleType(int, null)
ensureIdentifierPotentiallyRecovered(get, methodDeclaration, false)
listener: handleIdentifier(a, methodDeclaration)
parseQualifiedRestOpt(a, methodDeclarationContinuation)
listener: handleNoTypeVariables(=>)
parseGetterOrFormalParameters(a, a, true, MemberKind.NonStaticMethod)
listener: handleNoFormalParameters(=>, MemberKind.NonStaticMethod)
parseInitializersOpt(a)
listener: handleNoInitializers()
parseAsyncModifierOpt(a)
listener: handleAsyncModifier(null, null)
inPlainSync()
inPlainSync()
inPlainSync()
parseFunctionBody(a, false, true)
parseExpressionFunctionBody(=>, false)
parseExpression(=>)
parsePrecedenceExpression(=>, 1, true)
parseUnaryExpression(=>, true)
parsePrimary(=>, expression)
parseSendOrFunctionLiteral(=>, expression)
parseSend(=>, expression)
ensureIdentifier(=>, expression)
listener: handleIdentifier(runtimeType, expression)
listener: handleNoTypeArguments(.)
parseArgumentsOpt(runtimeType)
listener: handleNoArguments(.)
listener: handleSend(runtimeType, .)
parsePrimary(., expressionContinuation)
parseSendOrFunctionLiteral(., expressionContinuation)
parseSend(., expressionContinuation)
ensureIdentifier(., expressionContinuation)
listener: handleIdentifier(hashCode, expressionContinuation)
listener: handleNoTypeArguments(or)
parseArgumentsOpt(hashCode)
listener: handleNoArguments(or)
listener: handleSend(hashCode, or)
listener: handleEndingBinaryExpression(.)
rewriter()
parsePrecedenceExpression(|, 10, true)
parseUnaryExpression(|, true)
parsePrimary(|, expression)
parseLiteralNull(|)
parsePrimary(., expressionContinuation)
parseSendOrFunctionLiteral(., expressionContinuation)
parseSend(., expressionContinuation)
ensureIdentifier(., expressionContinuation)
parseArgumentsOpt(hashCode)
reportRecoverableError(or, Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}])
listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}], or, or)
rewriter()
listener: beginBinaryExpression(|)
parsePrecedenceExpression(|, 10, true)
parseUnaryExpression(|, true)
parsePrimary(|, expression)
parseLiteralNull(|)
listener: handleLiteralNull(null)
parsePrimary(., expressionContinuation)
parseSendOrFunctionLiteral(., expressionContinuation)
parseSend(., expressionContinuation)
ensureIdentifier(., expressionContinuation)
listener: handleIdentifier(hashCode, expressionContinuation)
listener: handleNoTypeArguments(;)
parseArgumentsOpt(hashCode)
listener: handleNoArguments(;)
listener: handleSend(hashCode, ;)
listener: handleEndingBinaryExpression(.)
listener: endBinaryExpression(|)
ensureSemicolon(hashCode)
listener: handleExpressionFunctionBody(=>, ;)
inGenerator()
listener: endClassMethod(get, int, =>, null, ;)
listener: endMember()
notEofOrValue(}, int)
parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Key)
parseMetadataStar(;)
listener: beginMetadataStar(int)
listener: endMetadataStar(0)
listener: beginMember()
parseMethod(;, null, null, null, null, null, null, ;, Instance of 'SimpleType', get, b, DeclarationKind.Class, Key, false)
listener: beginMethod(null, null, null, null, get, b)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(get)
listener: handleType(int, null)
ensureIdentifierPotentiallyRecovered(get, methodDeclaration, false)
listener: handleIdentifier(b, methodDeclaration)
parseQualifiedRestOpt(b, methodDeclarationContinuation)
listener: handleNoTypeVariables(=>)
parseGetterOrFormalParameters(b, b, true, MemberKind.NonStaticMethod)
listener: handleNoFormalParameters(=>, MemberKind.NonStaticMethod)
parseInitializersOpt(b)
listener: handleNoInitializers()
parseAsyncModifierOpt(b)
listener: handleAsyncModifier(null, null)
inPlainSync()
inPlainSync()
inPlainSync()
parseFunctionBody(b, false, true)
parseExpressionFunctionBody(=>, false)
parseExpression(=>)
parsePrecedenceExpression(=>, 1, true)
parseUnaryExpression(=>, true)
parsePrimary(=>, expression)
parseSendOrFunctionLiteral(=>, expression)
parseSend(=>, expression)
ensureIdentifier(=>, expression)
listener: handleIdentifier(runtimeType, expression)
listener: handleNoTypeArguments(.)
parseArgumentsOpt(runtimeType)
listener: handleNoArguments(.)
listener: handleSend(runtimeType, .)
parsePrimary(., expressionContinuation)
parseSendOrFunctionLiteral(., expressionContinuation)
parseSend(., expressionContinuation)
ensureIdentifier(., expressionContinuation)
listener: handleIdentifier(hashCode, expressionContinuation)
listener: handleNoTypeArguments(|)
parseArgumentsOpt(hashCode)
listener: handleNoArguments(|)
listener: handleSend(hashCode, |)
listener: handleEndingBinaryExpression(.)
listener: beginBinaryExpression(|)
parsePrecedenceExpression(|, 10, true)
parseUnaryExpression(|, true)
parsePrimary(|, expression)
parseLiteralNull(|)
listener: handleLiteralNull(null)
parsePrimary(., expressionContinuation)
parseSendOrFunctionLiteral(., expressionContinuation)
parseSend(., expressionContinuation)
ensureIdentifier(., expressionContinuation)
listener: handleIdentifier(hashCode, expressionContinuation)
listener: handleNoTypeArguments(;)
parseArgumentsOpt(hashCode)
listener: handleNoArguments(;)
listener: handleSend(hashCode, ;)
listener: handleEndingBinaryExpression(.)
listener: endBinaryExpression(|)
ensureSemicolon(hashCode)
listener: handleExpressionFunctionBody(=>, ;)
inGenerator()
listener: endClassMethod(get, int, =>, null, ;)
listener: endMember()
notEofOrValue(}, int)
parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Key)
parseMetadataStar(;)
listener: beginMetadataStar(int)
listener: endMetadataStar(0)
listener: beginMember()
parseMethod(;, null, null, null, null, null, null, ;, Instance of 'SimpleType', get, c, DeclarationKind.Class, Key, false)
listener: beginMethod(null, null, null, null, get, c)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(get)
listener: handleType(int, null)
ensureIdentifierPotentiallyRecovered(get, methodDeclaration, false)
listener: handleIdentifier(c, methodDeclaration)
parseQualifiedRestOpt(c, methodDeclarationContinuation)
listener: handleNoTypeVariables({)
parseGetterOrFormalParameters(c, c, true, MemberKind.NonStaticMethod)
listener: handleNoFormalParameters({, MemberKind.NonStaticMethod)
parseInitializersOpt(c)
listener: handleNoInitializers()
parseAsyncModifierOpt(c)
listener: handleAsyncModifier(null, null)
inPlainSync()
inPlainSync()
inPlainSync()
parseFunctionBody(c, false, true)
listener: beginBlockFunctionBody({)
notEofOrValue(}, return)
parseStatement({)
parseStatementX({)
parseReturnStatement({)
listener: beginReturnStatement(return)
parseExpression(return)
parsePrecedenceExpression(return, 1, true)
parseUnaryExpression(return, true)
parsePrimary(return, expression)
parseSendOrFunctionLiteral(return, expression)
parseSend(return, expression)
ensureIdentifier(return, expression)
listener: handleIdentifier(runtimeType, expression)
listener: handleNoTypeArguments(.)
parseArgumentsOpt(runtimeType)
listener: handleNoArguments(.)
listener: handleSend(runtimeType, .)
parsePrimary(., expressionContinuation)
parseSendOrFunctionLiteral(., expressionContinuation)
parseSend(., expressionContinuation)
ensureIdentifier(., expressionContinuation)
listener: handleIdentifier(hashCode, expressionContinuation)
listener: handleNoTypeArguments(or)
parseArgumentsOpt(hashCode)
listener: handleNoArguments(or)
listener: handleSend(hashCode, or)
listener: handleEndingBinaryExpression(.)
rewriter()
parsePrecedenceExpression(|, 10, true)
parseUnaryExpression(|, true)
parsePrimary(|, expression)
parseLiteralNull(|)
parsePrimary(., expressionContinuation)
parseSendOrFunctionLiteral(., expressionContinuation)
parseSend(., expressionContinuation)
ensureIdentifier(., expressionContinuation)
parseArgumentsOpt(hashCode)
reportRecoverableError(or, Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}])
listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}], or, or)
rewriter()
listener: beginBinaryExpression(|)
parsePrecedenceExpression(|, 10, true)
parseUnaryExpression(|, true)
parsePrimary(|, expression)
parseLiteralNull(|)
listener: handleLiteralNull(null)
parsePrimary(., expressionContinuation)
parseSendOrFunctionLiteral(., expressionContinuation)
parseSend(., expressionContinuation)
ensureIdentifier(., expressionContinuation)
listener: handleIdentifier(hashCode, expressionContinuation)
listener: handleNoTypeArguments(;)
parseArgumentsOpt(hashCode)
listener: handleNoArguments(;)
listener: handleSend(hashCode, ;)
listener: handleEndingBinaryExpression(.)
listener: endBinaryExpression(|)
ensureSemicolon(hashCode)
listener: endReturnStatement(true, return, ;)
inGenerator()
notEofOrValue(}, })
listener: endBlockFunctionBody(1, {, })
listener: endClassMethod(get, int, {, null, })
listener: endMember()
notEofOrValue(}, int)
parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
parseMetadataStar(})
listener: beginMetadataStar(int)
listener: endMetadataStar(0)
listener: beginMember()
parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', get, d, DeclarationKind.Class, Key, false)
listener: beginMethod(null, null, null, null, get, d)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(get)
listener: handleType(int, null)
ensureIdentifierPotentiallyRecovered(get, methodDeclaration, false)
listener: handleIdentifier(d, methodDeclaration)
parseQualifiedRestOpt(d, methodDeclarationContinuation)
listener: handleNoTypeVariables({)
parseGetterOrFormalParameters(d, d, true, MemberKind.NonStaticMethod)
listener: handleNoFormalParameters({, MemberKind.NonStaticMethod)
parseInitializersOpt(d)
listener: handleNoInitializers()
parseAsyncModifierOpt(d)
listener: handleAsyncModifier(null, null)
inPlainSync()
inPlainSync()
inPlainSync()
parseFunctionBody(d, false, true)
listener: beginBlockFunctionBody({)
notEofOrValue(}, return)
parseStatement({)
parseStatementX({)
parseReturnStatement({)
listener: beginReturnStatement(return)
parseExpression(return)
parsePrecedenceExpression(return, 1, true)
parseUnaryExpression(return, true)
parsePrimary(return, expression)
parseSendOrFunctionLiteral(return, expression)
parseSend(return, expression)
ensureIdentifier(return, expression)
listener: handleIdentifier(runtimeType, expression)
listener: handleNoTypeArguments(.)
parseArgumentsOpt(runtimeType)
listener: handleNoArguments(.)
listener: handleSend(runtimeType, .)
parsePrimary(., expressionContinuation)
parseSendOrFunctionLiteral(., expressionContinuation)
parseSend(., expressionContinuation)
ensureIdentifier(., expressionContinuation)
listener: handleIdentifier(hashCode, expressionContinuation)
listener: handleNoTypeArguments(|)
parseArgumentsOpt(hashCode)
listener: handleNoArguments(|)
listener: handleSend(hashCode, |)
listener: handleEndingBinaryExpression(.)
listener: beginBinaryExpression(|)
parsePrecedenceExpression(|, 10, true)
parseUnaryExpression(|, true)
parsePrimary(|, expression)
parseLiteralNull(|)
listener: handleLiteralNull(null)
parsePrimary(., expressionContinuation)
parseSendOrFunctionLiteral(., expressionContinuation)
parseSend(., expressionContinuation)
ensureIdentifier(., expressionContinuation)
listener: handleIdentifier(hashCode, expressionContinuation)
listener: handleNoTypeArguments(;)
parseArgumentsOpt(hashCode)
listener: handleNoArguments(;)
listener: handleSend(hashCode, ;)
listener: handleEndingBinaryExpression(.)
listener: endBinaryExpression(|)
ensureSemicolon(hashCode)
listener: endReturnStatement(true, return, ;)
inGenerator()
notEofOrValue(}, })
listener: endBlockFunctionBody(1, {, })
listener: endClassMethod(get, int, {, null, })
listener: endMember()
notEofOrValue(}, int)
parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
parseMetadataStar(})
listener: beginMetadataStar(int)
listener: endMetadataStar(0)
listener: beginMember()
parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', get, e, DeclarationKind.Class, Key, false)
listener: beginMethod(null, null, null, null, get, e)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(get)
listener: handleType(int, null)
ensureIdentifierPotentiallyRecovered(get, methodDeclaration, false)
listener: handleIdentifier(e, methodDeclaration)
parseQualifiedRestOpt(e, methodDeclarationContinuation)
listener: handleNoTypeVariables(=>)
parseGetterOrFormalParameters(e, e, true, MemberKind.NonStaticMethod)
listener: handleNoFormalParameters(=>, MemberKind.NonStaticMethod)
parseInitializersOpt(e)
listener: handleNoInitializers()
parseAsyncModifierOpt(e)
listener: handleAsyncModifier(null, null)
inPlainSync()
inPlainSync()
inPlainSync()
parseFunctionBody(e, false, true)
parseExpressionFunctionBody(=>, false)
parseExpression(=>)
parsePrecedenceExpression(=>, 1, true)
parseUnaryExpression(=>, true)
parsePrimary(=>, expression)
parseLiteralInt(=>)
listener: handleLiteralInt(1)
listener: beginBinaryExpression(+)
parsePrecedenceExpression(+, 14, true)
parseUnaryExpression(+, true)
parsePrimary(+, expression)
parseSendOrFunctionLiteral(+, expression)
parseSend(+, expression)
ensureIdentifier(+, expression)
listener: handleIdentifier(runtimeType, expression)
listener: handleNoTypeArguments(.)
parseArgumentsOpt(runtimeType)
listener: handleNoArguments(.)
listener: handleSend(runtimeType, .)
parsePrimary(., expressionContinuation)
parseSendOrFunctionLiteral(., expressionContinuation)
parseSend(., expressionContinuation)
ensureIdentifier(., expressionContinuation)
listener: handleIdentifier(hashCode, expressionContinuation)
listener: handleNoTypeArguments(or)
parseArgumentsOpt(hashCode)
listener: handleNoArguments(or)
listener: handleSend(hashCode, or)
listener: handleEndingBinaryExpression(.)
rewriter()
listener: endBinaryExpression(+)
rewriter()
parsePrecedenceExpression(|, 10, true)
parseUnaryExpression(|, true)
parsePrimary(|, expression)
parseLiteralNull(|)
parsePrimary(., expressionContinuation)
parseSendOrFunctionLiteral(., expressionContinuation)
parseSend(., expressionContinuation)
ensureIdentifier(., expressionContinuation)
parseArgumentsOpt(hashCode)
parsePrecedenceExpression(+, 14, true)
parseUnaryExpression(+, true)
parsePrimary(+, expression)
parseLiteralInt(+)
reportRecoverableError(or, Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}])
listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}], or, or)
rewriter()
listener: beginBinaryExpression(|)
parsePrecedenceExpression(|, 10, true)
parseUnaryExpression(|, true)
parsePrimary(|, expression)
parseLiteralNull(|)
listener: handleLiteralNull(null)
parsePrimary(., expressionContinuation)
parseSendOrFunctionLiteral(., expressionContinuation)
parseSend(., expressionContinuation)
ensureIdentifier(., expressionContinuation)
listener: handleIdentifier(hashCode, expressionContinuation)
listener: handleNoTypeArguments(+)
parseArgumentsOpt(hashCode)
listener: handleNoArguments(+)
listener: handleSend(hashCode, +)
listener: handleEndingBinaryExpression(.)
listener: beginBinaryExpression(+)
parsePrecedenceExpression(+, 14, true)
parseUnaryExpression(+, true)
parsePrimary(+, expression)
parseLiteralInt(+)
listener: handleLiteralInt(3)
listener: endBinaryExpression(+)
listener: endBinaryExpression(|)
ensureSemicolon(3)
listener: handleExpressionFunctionBody(=>, ;)
inGenerator()
listener: endClassMethod(get, int, =>, null, ;)
listener: endMember()
notEofOrValue(}, int)
parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Key)
parseMetadataStar(;)
listener: beginMetadataStar(int)
listener: endMetadataStar(0)
listener: beginMember()
parseMethod(;, null, null, null, null, null, null, ;, Instance of 'SimpleType', get, f, DeclarationKind.Class, Key, false)
listener: beginMethod(null, null, null, null, get, f)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(get)
listener: handleType(int, null)
ensureIdentifierPotentiallyRecovered(get, methodDeclaration, false)
listener: handleIdentifier(f, methodDeclaration)
parseQualifiedRestOpt(f, methodDeclarationContinuation)
listener: handleNoTypeVariables(=>)
parseGetterOrFormalParameters(f, f, true, MemberKind.NonStaticMethod)
listener: handleNoFormalParameters(=>, MemberKind.NonStaticMethod)
parseInitializersOpt(f)
listener: handleNoInitializers()
parseAsyncModifierOpt(f)
listener: handleAsyncModifier(null, null)
inPlainSync()
inPlainSync()
inPlainSync()
parseFunctionBody(f, false, true)
parseExpressionFunctionBody(=>, false)
parseExpression(=>)
parsePrecedenceExpression(=>, 1, true)
parseUnaryExpression(=>, true)
parsePrimary(=>, expression)
parseLiteralInt(=>)
listener: handleLiteralInt(1)
listener: beginBinaryExpression(+)
parsePrecedenceExpression(+, 14, true)
parseUnaryExpression(+, true)
parsePrimary(+, expression)
parseSendOrFunctionLiteral(+, expression)
parseSend(+, expression)
ensureIdentifier(+, expression)
listener: handleIdentifier(runtimeType, expression)
listener: handleNoTypeArguments(.)
parseArgumentsOpt(runtimeType)
listener: handleNoArguments(.)
listener: handleSend(runtimeType, .)
parsePrimary(., expressionContinuation)
parseSendOrFunctionLiteral(., expressionContinuation)
parseSend(., expressionContinuation)
ensureIdentifier(., expressionContinuation)
listener: handleIdentifier(hashCode, expressionContinuation)
listener: handleNoTypeArguments(|)
parseArgumentsOpt(hashCode)
listener: handleNoArguments(|)
listener: handleSend(hashCode, |)
listener: handleEndingBinaryExpression(.)
listener: endBinaryExpression(+)
listener: beginBinaryExpression(|)
parsePrecedenceExpression(|, 10, true)
parseUnaryExpression(|, true)
parsePrimary(|, expression)
parseLiteralNull(|)
listener: handleLiteralNull(null)
parsePrimary(., expressionContinuation)
parseSendOrFunctionLiteral(., expressionContinuation)
parseSend(., expressionContinuation)
ensureIdentifier(., expressionContinuation)
listener: handleIdentifier(hashCode, expressionContinuation)
listener: handleNoTypeArguments(+)
parseArgumentsOpt(hashCode)
listener: handleNoArguments(+)
listener: handleSend(hashCode, +)
listener: handleEndingBinaryExpression(.)
listener: beginBinaryExpression(+)
parsePrecedenceExpression(+, 14, true)
parseUnaryExpression(+, true)
parsePrimary(+, expression)
parseLiteralInt(+)
listener: handleLiteralInt(3)
listener: endBinaryExpression(+)
listener: endBinaryExpression(|)
ensureSemicolon(3)
listener: handleExpressionFunctionBody(=>, ;)
inGenerator()
listener: endClassMethod(get, int, =>, null, ;)
listener: endMember()
notEofOrValue(}, int)
parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Key)
parseMetadataStar(;)
listener: beginMetadataStar(int)
listener: endMetadataStar(0)
listener: beginMember()
parseMethod(;, null, null, null, null, null, null, ;, Instance of 'SimpleType', get, g, DeclarationKind.Class, Key, false)
listener: beginMethod(null, null, null, null, get, g)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(get)
listener: handleType(int, null)
ensureIdentifierPotentiallyRecovered(get, methodDeclaration, false)
listener: handleIdentifier(g, methodDeclaration)
parseQualifiedRestOpt(g, methodDeclarationContinuation)
listener: handleNoTypeVariables({)
parseGetterOrFormalParameters(g, g, true, MemberKind.NonStaticMethod)
listener: handleNoFormalParameters({, MemberKind.NonStaticMethod)
parseInitializersOpt(g)
listener: handleNoInitializers()
parseAsyncModifierOpt(g)
listener: handleAsyncModifier(null, null)
inPlainSync()
inPlainSync()
inPlainSync()
parseFunctionBody(g, false, true)
listener: beginBlockFunctionBody({)
notEofOrValue(}, return)
parseStatement({)
parseStatementX({)
parseReturnStatement({)
listener: beginReturnStatement(return)
parseExpression(return)
parsePrecedenceExpression(return, 1, true)
parseUnaryExpression(return, true)
parsePrimary(return, expression)
parseLiteralInt(return)
listener: handleLiteralInt(1)
listener: beginBinaryExpression(+)
parsePrecedenceExpression(+, 14, true)
parseUnaryExpression(+, true)
parsePrimary(+, expression)
parseSendOrFunctionLiteral(+, expression)
parseSend(+, expression)
ensureIdentifier(+, expression)
listener: handleIdentifier(runtimeType, expression)
listener: handleNoTypeArguments(.)
parseArgumentsOpt(runtimeType)
listener: handleNoArguments(.)
listener: handleSend(runtimeType, .)
parsePrimary(., expressionContinuation)
parseSendOrFunctionLiteral(., expressionContinuation)
parseSend(., expressionContinuation)
ensureIdentifier(., expressionContinuation)
listener: handleIdentifier(hashCode, expressionContinuation)
listener: handleNoTypeArguments(or)
parseArgumentsOpt(hashCode)
listener: handleNoArguments(or)
listener: handleSend(hashCode, or)
listener: handleEndingBinaryExpression(.)
rewriter()
listener: endBinaryExpression(+)
rewriter()
parsePrecedenceExpression(|, 10, true)
parseUnaryExpression(|, true)
parsePrimary(|, expression)
parseLiteralNull(|)
parsePrimary(., expressionContinuation)
parseSendOrFunctionLiteral(., expressionContinuation)
parseSend(., expressionContinuation)
ensureIdentifier(., expressionContinuation)
parseArgumentsOpt(hashCode)
parsePrecedenceExpression(+, 14, true)
parseUnaryExpression(+, true)
parsePrimary(+, expression)
parseLiteralInt(+)
reportRecoverableError(or, Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}])
listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}], or, or)
rewriter()
listener: beginBinaryExpression(|)
parsePrecedenceExpression(|, 10, true)
parseUnaryExpression(|, true)
parsePrimary(|, expression)
parseLiteralNull(|)
listener: handleLiteralNull(null)
parsePrimary(., expressionContinuation)
parseSendOrFunctionLiteral(., expressionContinuation)
parseSend(., expressionContinuation)
ensureIdentifier(., expressionContinuation)
listener: handleIdentifier(hashCode, expressionContinuation)
listener: handleNoTypeArguments(+)
parseArgumentsOpt(hashCode)
listener: handleNoArguments(+)
listener: handleSend(hashCode, +)
listener: handleEndingBinaryExpression(.)
listener: beginBinaryExpression(+)
parsePrecedenceExpression(+, 14, true)
parseUnaryExpression(+, true)
parsePrimary(+, expression)
parseLiteralInt(+)
listener: handleLiteralInt(3)
listener: endBinaryExpression(+)
listener: endBinaryExpression(|)
ensureSemicolon(3)
listener: endReturnStatement(true, return, ;)
inGenerator()
notEofOrValue(}, })
listener: endBlockFunctionBody(1, {, })
listener: endClassMethod(get, int, {, null, })
listener: endMember()
notEofOrValue(}, int)
parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
parseMetadataStar(})
listener: beginMetadataStar(int)
listener: endMetadataStar(0)
listener: beginMember()
parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', get, h, DeclarationKind.Class, Key, false)
listener: beginMethod(null, null, null, null, get, h)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(get)
listener: handleType(int, null)
ensureIdentifierPotentiallyRecovered(get, methodDeclaration, false)
listener: handleIdentifier(h, methodDeclaration)
parseQualifiedRestOpt(h, methodDeclarationContinuation)
listener: handleNoTypeVariables({)
parseGetterOrFormalParameters(h, h, true, MemberKind.NonStaticMethod)
listener: handleNoFormalParameters({, MemberKind.NonStaticMethod)
parseInitializersOpt(h)
listener: handleNoInitializers()
parseAsyncModifierOpt(h)
listener: handleAsyncModifier(null, null)
inPlainSync()
inPlainSync()
inPlainSync()
parseFunctionBody(h, false, true)
listener: beginBlockFunctionBody({)
notEofOrValue(}, return)
parseStatement({)
parseStatementX({)
parseReturnStatement({)
listener: beginReturnStatement(return)
parseExpression(return)
parsePrecedenceExpression(return, 1, true)
parseUnaryExpression(return, true)
parsePrimary(return, expression)
parseLiteralInt(return)
listener: handleLiteralInt(1)
listener: beginBinaryExpression(+)
parsePrecedenceExpression(+, 14, true)
parseUnaryExpression(+, true)
parsePrimary(+, expression)
parseSendOrFunctionLiteral(+, expression)
parseSend(+, expression)
ensureIdentifier(+, expression)
listener: handleIdentifier(runtimeType, expression)
listener: handleNoTypeArguments(.)
parseArgumentsOpt(runtimeType)
listener: handleNoArguments(.)
listener: handleSend(runtimeType, .)
parsePrimary(., expressionContinuation)
parseSendOrFunctionLiteral(., expressionContinuation)
parseSend(., expressionContinuation)
ensureIdentifier(., expressionContinuation)
listener: handleIdentifier(hashCode, expressionContinuation)
listener: handleNoTypeArguments(|)
parseArgumentsOpt(hashCode)
listener: handleNoArguments(|)
listener: handleSend(hashCode, |)
listener: handleEndingBinaryExpression(.)
listener: endBinaryExpression(+)
listener: beginBinaryExpression(|)
parsePrecedenceExpression(|, 10, true)
parseUnaryExpression(|, true)
parsePrimary(|, expression)
parseLiteralNull(|)
listener: handleLiteralNull(null)
parsePrimary(., expressionContinuation)
parseSendOrFunctionLiteral(., expressionContinuation)
parseSend(., expressionContinuation)
ensureIdentifier(., expressionContinuation)
listener: handleIdentifier(hashCode, expressionContinuation)
listener: handleNoTypeArguments(+)
parseArgumentsOpt(hashCode)
listener: handleNoArguments(+)
listener: handleSend(hashCode, +)
listener: handleEndingBinaryExpression(.)
listener: beginBinaryExpression(+)
parsePrecedenceExpression(+, 14, true)
parseUnaryExpression(+, true)
parsePrimary(+, expression)
parseLiteralInt(+)
listener: handleLiteralInt(3)
listener: endBinaryExpression(+)
listener: endBinaryExpression(|)
ensureSemicolon(3)
listener: endReturnStatement(true, return, ;)
inGenerator()
notEofOrValue(}, })
listener: endBlockFunctionBody(1, {, })
listener: endClassMethod(get, int, {, null, })
listener: endMember()
notEofOrValue(}, int)
parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
parseMetadataStar(})
listener: beginMetadataStar(int)
listener: endMetadataStar(0)
listener: beginMember()
parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, i, DeclarationKind.Class, Key, false)
listener: beginMethod(null, null, null, null, null, i)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(i)
listener: handleType(int, null)
ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
listener: handleIdentifier(i, methodDeclaration)
parseQualifiedRestOpt(i, methodDeclarationContinuation)
parseMethodTypeVar(i)
listener: handleNoTypeVariables(()
parseGetterOrFormalParameters(i, i, false, MemberKind.NonStaticMethod)
parseFormalParameters(i, MemberKind.NonStaticMethod)
parseFormalParametersRest((, MemberKind.NonStaticMethod)
listener: beginFormalParameters((, MemberKind.NonStaticMethod)
parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
parseMetadataStar(()
listener: beginMetadataStar(int)
listener: endMetadataStar(0)
listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(x)
listener: handleType(int, null)
ensureIdentifier(int, formalParameterDeclaration)
listener: handleIdentifier(x, formalParameterDeclaration)
listener: handleFormalParameterWithoutValue(,)
listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
parseMetadataStar(,)
listener: beginMetadataStar(int)
listener: endMetadataStar(0)
listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(y)
listener: handleType(int, null)
ensureIdentifier(int, formalParameterDeclaration)
listener: handleIdentifier(y, formalParameterDeclaration)
listener: handleFormalParameterWithoutValue())
listener: endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
parseInitializersOpt())
listener: handleNoInitializers()
parseAsyncModifierOpt())
listener: handleAsyncModifier(null, null)
inPlainSync()
inPlainSync()
parseFunctionBody(), false, true)
parseExpressionFunctionBody(=>, false)
parseExpression(=>)
parsePrecedenceExpression(=>, 1, true)
parseUnaryExpression(=>, true)
parsePrimary(=>, expression)
parseSendOrFunctionLiteral(=>, expression)
parseSend(=>, expression)
ensureIdentifier(=>, expression)
listener: handleIdentifier(x, expression)
listener: handleNoTypeArguments(or)
parseArgumentsOpt(x)
listener: handleNoArguments(or)
listener: handleSend(x, or)
rewriter()
parsePrecedenceExpression(|, 10, true)
parseUnaryExpression(|, true)
parsePrimary(|, expression)
parseSendOrFunctionLiteral(|, expression)
parseSend(|, expression)
ensureIdentifier(|, expression)
parseArgumentsOpt(y)
reportRecoverableError(or, Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}])
listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}], or, or)
rewriter()
listener: beginBinaryExpression(|)
parsePrecedenceExpression(|, 10, true)
parseUnaryExpression(|, true)
parsePrimary(|, expression)
parseSendOrFunctionLiteral(|, expression)
parseSend(|, expression)
ensureIdentifier(|, expression)
listener: handleIdentifier(y, expression)
listener: handleNoTypeArguments(;)
parseArgumentsOpt(y)
listener: handleNoArguments(;)
listener: handleSend(y, ;)
listener: endBinaryExpression(|)
ensureSemicolon(y)
listener: handleExpressionFunctionBody(=>, ;)
inGenerator()
listener: endClassMethod(null, int, (, null, ;)
listener: endMember()
notEofOrValue(}, int)
parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Key)
parseMetadataStar(;)
listener: beginMetadataStar(int)
listener: endMetadataStar(0)
listener: beginMember()
parseMethod(;, null, null, null, null, null, null, ;, Instance of 'SimpleType', null, j, DeclarationKind.Class, Key, false)
listener: beginMethod(null, null, null, null, null, j)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(j)
listener: handleType(int, null)
ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
listener: handleIdentifier(j, methodDeclaration)
parseQualifiedRestOpt(j, methodDeclarationContinuation)
parseMethodTypeVar(j)
listener: handleNoTypeVariables(()
parseGetterOrFormalParameters(j, j, false, MemberKind.NonStaticMethod)
parseFormalParameters(j, MemberKind.NonStaticMethod)
parseFormalParametersRest((, MemberKind.NonStaticMethod)
listener: beginFormalParameters((, MemberKind.NonStaticMethod)
parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
parseMetadataStar(()
listener: beginMetadataStar(int)
listener: endMetadataStar(0)
listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(x)
listener: handleType(int, null)
ensureIdentifier(int, formalParameterDeclaration)
listener: handleIdentifier(x, formalParameterDeclaration)
listener: handleFormalParameterWithoutValue(,)
listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
parseMetadataStar(,)
listener: beginMetadataStar(int)
listener: endMetadataStar(0)
listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(y)
listener: handleType(int, null)
ensureIdentifier(int, formalParameterDeclaration)
listener: handleIdentifier(y, formalParameterDeclaration)
listener: handleFormalParameterWithoutValue())
listener: endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
parseInitializersOpt())
listener: handleNoInitializers()
parseAsyncModifierOpt())
listener: handleAsyncModifier(null, null)
inPlainSync()
inPlainSync()
parseFunctionBody(), false, true)
parseExpressionFunctionBody(=>, false)
parseExpression(=>)
parsePrecedenceExpression(=>, 1, true)
parseUnaryExpression(=>, true)
parsePrimary(=>, expression)
parseSendOrFunctionLiteral(=>, expression)
parseSend(=>, expression)
ensureIdentifier(=>, expression)
listener: handleIdentifier(x, expression)
listener: handleNoTypeArguments(|)
parseArgumentsOpt(x)
listener: handleNoArguments(|)
listener: handleSend(x, |)
listener: beginBinaryExpression(|)
parsePrecedenceExpression(|, 10, true)
parseUnaryExpression(|, true)
parsePrimary(|, expression)
parseSendOrFunctionLiteral(|, expression)
parseSend(|, expression)
ensureIdentifier(|, expression)
listener: handleIdentifier(y, expression)
listener: handleNoTypeArguments(;)
parseArgumentsOpt(y)
listener: handleNoArguments(;)
listener: handleSend(y, ;)
listener: endBinaryExpression(|)
ensureSemicolon(y)
listener: handleExpressionFunctionBody(=>, ;)
inGenerator()
listener: endClassMethod(null, int, (, null, ;)
listener: endMember()
notEofOrValue(}, int)
parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Key)
parseMetadataStar(;)
listener: beginMetadataStar(int)
listener: endMetadataStar(0)
listener: beginMember()
parseMethod(;, null, null, null, null, null, null, ;, Instance of 'SimpleType', null, k, DeclarationKind.Class, Key, false)
listener: beginMethod(null, null, null, null, null, k)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(k)
listener: handleType(int, null)
ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
listener: handleIdentifier(k, methodDeclaration)
parseQualifiedRestOpt(k, methodDeclarationContinuation)
parseMethodTypeVar(k)
listener: handleNoTypeVariables(()
parseGetterOrFormalParameters(k, k, false, MemberKind.NonStaticMethod)
parseFormalParameters(k, MemberKind.NonStaticMethod)
parseFormalParametersRest((, MemberKind.NonStaticMethod)
listener: beginFormalParameters((, MemberKind.NonStaticMethod)
parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
parseMetadataStar(()
listener: beginMetadataStar(int)
listener: endMetadataStar(0)
listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(x)
listener: handleType(int, null)
ensureIdentifier(int, formalParameterDeclaration)
listener: handleIdentifier(x, formalParameterDeclaration)
listener: handleFormalParameterWithoutValue(,)
listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
parseMetadataStar(,)
listener: beginMetadataStar(int)
listener: endMetadataStar(0)
listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(y)
listener: handleType(int, null)
ensureIdentifier(int, formalParameterDeclaration)
listener: handleIdentifier(y, formalParameterDeclaration)
listener: handleFormalParameterWithoutValue())
listener: endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
parseInitializersOpt())
listener: handleNoInitializers()
parseAsyncModifierOpt())
listener: handleAsyncModifier(null, null)
inPlainSync()
inPlainSync()
parseFunctionBody(), false, true)
listener: beginBlockFunctionBody({)
notEofOrValue(}, return)
parseStatement({)
parseStatementX({)
parseReturnStatement({)
listener: beginReturnStatement(return)
parseExpression(return)
parsePrecedenceExpression(return, 1, true)
parseUnaryExpression(return, true)
parsePrimary(return, expression)
parseSendOrFunctionLiteral(return, expression)
parseSend(return, expression)
ensureIdentifier(return, expression)
listener: handleIdentifier(x, expression)
listener: handleNoTypeArguments(or)
parseArgumentsOpt(x)
listener: handleNoArguments(or)
listener: handleSend(x, or)
rewriter()
parsePrecedenceExpression(|, 10, true)
parseUnaryExpression(|, true)
parsePrimary(|, expression)
parseSendOrFunctionLiteral(|, expression)
parseSend(|, expression)
ensureIdentifier(|, expression)
parseArgumentsOpt(y)
reportRecoverableError(or, Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}])
listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}], or, or)
rewriter()
listener: beginBinaryExpression(|)
parsePrecedenceExpression(|, 10, true)
parseUnaryExpression(|, true)
parsePrimary(|, expression)
parseSendOrFunctionLiteral(|, expression)
parseSend(|, expression)
ensureIdentifier(|, expression)
listener: handleIdentifier(y, expression)
listener: handleNoTypeArguments(;)
parseArgumentsOpt(y)
listener: handleNoArguments(;)
listener: handleSend(y, ;)
listener: endBinaryExpression(|)
ensureSemicolon(y)
listener: endReturnStatement(true, return, ;)
inGenerator()
notEofOrValue(}, })
listener: endBlockFunctionBody(1, {, })
listener: endClassMethod(null, int, (, null, })
listener: endMember()
notEofOrValue(}, int)
parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
parseMetadataStar(})
listener: beginMetadataStar(int)
listener: endMetadataStar(0)
listener: beginMember()
parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, l, DeclarationKind.Class, Key, false)
listener: beginMethod(null, null, null, null, null, l)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(l)
listener: handleType(int, null)
ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
listener: handleIdentifier(l, methodDeclaration)
parseQualifiedRestOpt(l, methodDeclarationContinuation)
parseMethodTypeVar(l)
listener: handleNoTypeVariables(()
parseGetterOrFormalParameters(l, l, false, MemberKind.NonStaticMethod)
parseFormalParameters(l, MemberKind.NonStaticMethod)
parseFormalParametersRest((, MemberKind.NonStaticMethod)
listener: beginFormalParameters((, MemberKind.NonStaticMethod)
parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
parseMetadataStar(()
listener: beginMetadataStar(int)
listener: endMetadataStar(0)
listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(x)
listener: handleType(int, null)
ensureIdentifier(int, formalParameterDeclaration)
listener: handleIdentifier(x, formalParameterDeclaration)
listener: handleFormalParameterWithoutValue(,)
listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
parseMetadataStar(,)
listener: beginMetadataStar(int)
listener: endMetadataStar(0)
listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(y)
listener: handleType(int, null)
ensureIdentifier(int, formalParameterDeclaration)
listener: handleIdentifier(y, formalParameterDeclaration)
listener: handleFormalParameterWithoutValue())
listener: endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
parseInitializersOpt())
listener: handleNoInitializers()
parseAsyncModifierOpt())
listener: handleAsyncModifier(null, null)
inPlainSync()
inPlainSync()
parseFunctionBody(), false, true)
listener: beginBlockFunctionBody({)
notEofOrValue(}, return)
parseStatement({)
parseStatementX({)
parseReturnStatement({)
listener: beginReturnStatement(return)
parseExpression(return)
parsePrecedenceExpression(return, 1, true)
parseUnaryExpression(return, true)
parsePrimary(return, expression)
parseSendOrFunctionLiteral(return, expression)
parseSend(return, expression)
ensureIdentifier(return, expression)
listener: handleIdentifier(x, expression)
listener: handleNoTypeArguments(|)
parseArgumentsOpt(x)
listener: handleNoArguments(|)
listener: handleSend(x, |)
listener: beginBinaryExpression(|)
parsePrecedenceExpression(|, 10, true)
parseUnaryExpression(|, true)
parsePrimary(|, expression)
parseSendOrFunctionLiteral(|, expression)
parseSend(|, expression)
ensureIdentifier(|, expression)
listener: handleIdentifier(y, expression)
listener: handleNoTypeArguments(;)
parseArgumentsOpt(y)
listener: handleNoArguments(;)
listener: handleSend(y, ;)
listener: endBinaryExpression(|)
ensureSemicolon(y)
listener: endReturnStatement(true, return, ;)
inGenerator()
notEofOrValue(}, })
listener: endBlockFunctionBody(1, {, })
listener: endClassMethod(null, int, (, null, })
listener: endMember()
notEofOrValue(}, int)
parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
parseMetadataStar(})
listener: beginMetadataStar(int)
listener: endMetadataStar(0)
listener: beginMember()
parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, m, DeclarationKind.Class, Key, false)
listener: beginMethod(null, null, null, null, null, m)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(m)
listener: handleType(int, null)
ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
listener: handleIdentifier(m, methodDeclaration)
parseQualifiedRestOpt(m, methodDeclarationContinuation)
parseMethodTypeVar(m)
listener: handleNoTypeVariables(()
parseGetterOrFormalParameters(m, m, false, MemberKind.NonStaticMethod)
parseFormalParameters(m, MemberKind.NonStaticMethod)
parseFormalParametersRest((, MemberKind.NonStaticMethod)
listener: beginFormalParameters((, MemberKind.NonStaticMethod)
parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
parseMetadataStar(()
listener: beginMetadataStar(int)
listener: endMetadataStar(0)
listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(x)
listener: handleType(int, null)
ensureIdentifier(int, formalParameterDeclaration)
listener: handleIdentifier(x, formalParameterDeclaration)
listener: handleFormalParameterWithoutValue(,)
listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
parseMetadataStar(,)
listener: beginMetadataStar(int)
listener: endMetadataStar(0)
listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(y)
listener: handleType(int, null)
ensureIdentifier(int, formalParameterDeclaration)
listener: handleIdentifier(y, formalParameterDeclaration)
listener: handleFormalParameterWithoutValue())
listener: endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
parseInitializersOpt())
listener: handleNoInitializers()
parseAsyncModifierOpt())
listener: handleAsyncModifier(null, null)
inPlainSync()
inPlainSync()
parseFunctionBody(), false, true)
listener: beginBlockFunctionBody({)
notEofOrValue(}, int)
parseStatement({)
parseStatementX({)
parseExpressionStatementOrDeclarationAfterModifiers({, {, null, null, null, false)
looksLikeLocalFunction(z)
listener: beginMetadataStar(int)
listener: endMetadataStar(0)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(z)
listener: handleType(int, null)
listener: beginVariablesDeclaration(z, null, null)
parseVariablesDeclarationRest(int, true)
parseOptionallyInitializedIdentifier(int)
ensureIdentifier(int, localVariableDeclaration)
listener: handleIdentifier(z, localVariableDeclaration)
listener: beginInitializedIdentifier(z)
parseVariableInitializerOpt(z)
listener: beginVariableInitializer(=)
parseExpression(=)
parsePrecedenceExpression(=, 1, true)
parseUnaryExpression(=, true)
parsePrimary(=, expression)
parseSendOrFunctionLiteral(=, expression)
parseSend(=, expression)
ensureIdentifier(=, expression)
listener: handleIdentifier(x, expression)
listener: handleNoTypeArguments(or)
parseArgumentsOpt(x)
listener: handleNoArguments(or)
listener: handleSend(x, or)
rewriter()
parsePrecedenceExpression(|, 10, true)
parseUnaryExpression(|, true)
parsePrimary(|, expression)
parseSendOrFunctionLiteral(|, expression)
parseSend(|, expression)
ensureIdentifier(|, expression)
parseArgumentsOpt(y)
reportRecoverableError(or, Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}])
listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}], or, or)
rewriter()
listener: beginBinaryExpression(|)
parsePrecedenceExpression(|, 10, true)
parseUnaryExpression(|, true)
parsePrimary(|, expression)
parseSendOrFunctionLiteral(|, expression)
parseSend(|, expression)
ensureIdentifier(|, expression)
listener: handleIdentifier(y, expression)
listener: handleNoTypeArguments(;)
parseArgumentsOpt(y)
listener: handleNoArguments(;)
listener: handleSend(y, ;)
listener: endBinaryExpression(|)
listener: endVariableInitializer(=)
listener: endInitializedIdentifier(z)
ensureSemicolon(y)
listener: endVariablesDeclaration(1, ;)
notEofOrValue(}, return)
parseStatement(;)
parseStatementX(;)
parseReturnStatement(;)
listener: beginReturnStatement(return)
parseExpression(return)
parsePrecedenceExpression(return, 1, true)
parseUnaryExpression(return, true)
parsePrimary(return, expression)
parseSendOrFunctionLiteral(return, expression)
parseSend(return, expression)
ensureIdentifier(return, expression)
listener: handleIdentifier(z, expression)
listener: handleNoTypeArguments(;)
parseArgumentsOpt(z)
listener: handleNoArguments(;)
listener: handleSend(z, ;)
ensureSemicolon(z)
listener: endReturnStatement(true, return, ;)
inGenerator()
notEofOrValue(}, })
listener: endBlockFunctionBody(2, {, })
listener: endClassMethod(null, int, (, null, })
listener: endMember()
notEofOrValue(}, int)
parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
parseMetadataStar(})
listener: beginMetadataStar(int)
listener: endMetadataStar(0)
listener: beginMember()
parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, n, DeclarationKind.Class, Key, false)
listener: beginMethod(null, null, null, null, null, n)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(n)
listener: handleType(int, null)
ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
listener: handleIdentifier(n, methodDeclaration)
parseQualifiedRestOpt(n, methodDeclarationContinuation)
parseMethodTypeVar(n)
listener: handleNoTypeVariables(()
parseGetterOrFormalParameters(n, n, false, MemberKind.NonStaticMethod)
parseFormalParameters(n, MemberKind.NonStaticMethod)
parseFormalParametersRest((, MemberKind.NonStaticMethod)
listener: beginFormalParameters((, MemberKind.NonStaticMethod)
parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
parseMetadataStar(()
listener: beginMetadataStar(int)
listener: endMetadataStar(0)
listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(x)
listener: handleType(int, null)
ensureIdentifier(int, formalParameterDeclaration)
listener: handleIdentifier(x, formalParameterDeclaration)
listener: handleFormalParameterWithoutValue(,)
listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
parseMetadataStar(,)
listener: beginMetadataStar(int)
listener: endMetadataStar(0)
listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(y)
listener: handleType(int, null)
ensureIdentifier(int, formalParameterDeclaration)
listener: handleIdentifier(y, formalParameterDeclaration)
listener: handleFormalParameterWithoutValue())
listener: endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
parseInitializersOpt())
listener: handleNoInitializers()
parseAsyncModifierOpt())
listener: handleAsyncModifier(null, null)
inPlainSync()
inPlainSync()
parseFunctionBody(), false, true)
listener: beginBlockFunctionBody({)
notEofOrValue(}, int)
parseStatement({)
parseStatementX({)
parseExpressionStatementOrDeclarationAfterModifiers({, {, null, null, null, false)
looksLikeLocalFunction(z)
listener: beginMetadataStar(int)
listener: endMetadataStar(0)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(z)
listener: handleType(int, null)
listener: beginVariablesDeclaration(z, null, null)
parseVariablesDeclarationRest(int, true)
parseOptionallyInitializedIdentifier(int)
ensureIdentifier(int, localVariableDeclaration)
listener: handleIdentifier(z, localVariableDeclaration)
listener: beginInitializedIdentifier(z)
parseVariableInitializerOpt(z)
listener: beginVariableInitializer(=)
parseExpression(=)
parsePrecedenceExpression(=, 1, true)
parseUnaryExpression(=, true)
parsePrimary(=, expression)
parseSendOrFunctionLiteral(=, expression)
parseSend(=, expression)
ensureIdentifier(=, expression)
listener: handleIdentifier(x, expression)
listener: handleNoTypeArguments(|)
parseArgumentsOpt(x)
listener: handleNoArguments(|)
listener: handleSend(x, |)
listener: beginBinaryExpression(|)
parsePrecedenceExpression(|, 10, true)
parseUnaryExpression(|, true)
parsePrimary(|, expression)
parseSendOrFunctionLiteral(|, expression)
parseSend(|, expression)
ensureIdentifier(|, expression)
listener: handleIdentifier(y, expression)
listener: handleNoTypeArguments(;)
parseArgumentsOpt(y)
listener: handleNoArguments(;)
listener: handleSend(y, ;)
listener: endBinaryExpression(|)
listener: endVariableInitializer(=)
listener: endInitializedIdentifier(z)
ensureSemicolon(y)
listener: endVariablesDeclaration(1, ;)
notEofOrValue(}, return)
parseStatement(;)
parseStatementX(;)
parseReturnStatement(;)
listener: beginReturnStatement(return)
parseExpression(return)
parsePrecedenceExpression(return, 1, true)
parseUnaryExpression(return, true)
parsePrimary(return, expression)
parseSendOrFunctionLiteral(return, expression)
parseSend(return, expression)
ensureIdentifier(return, expression)
listener: handleIdentifier(z, expression)
listener: handleNoTypeArguments(;)
parseArgumentsOpt(z)
listener: handleNoArguments(;)
listener: handleSend(z, ;)
ensureSemicolon(z)
listener: endReturnStatement(true, return, ;)
inGenerator()
notEofOrValue(}, })
listener: endBlockFunctionBody(2, {, })
listener: endClassMethod(null, int, (, null, })
listener: endMember()
notEofOrValue(}, int)
parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
parseMetadataStar(})
listener: beginMetadataStar(int)
listener: endMetadataStar(0)
listener: beginMember()
parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, o, DeclarationKind.Class, Key, false)
listener: beginMethod(null, null, null, null, null, o)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(o)
listener: handleType(int, null)
ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
listener: handleIdentifier(o, methodDeclaration)
parseQualifiedRestOpt(o, methodDeclarationContinuation)
parseMethodTypeVar(o)
listener: handleNoTypeVariables(()
parseGetterOrFormalParameters(o, o, false, MemberKind.NonStaticMethod)
parseFormalParameters(o, MemberKind.NonStaticMethod)
parseFormalParametersRest((, MemberKind.NonStaticMethod)
listener: beginFormalParameters((, MemberKind.NonStaticMethod)
parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
parseMetadataStar(()
listener: beginMetadataStar(int)
listener: endMetadataStar(0)
listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(x)
listener: handleType(int, null)
ensureIdentifier(int, formalParameterDeclaration)
listener: handleIdentifier(x, formalParameterDeclaration)
listener: handleFormalParameterWithoutValue(,)
listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
parseMetadataStar(,)
listener: beginMetadataStar(int)
listener: endMetadataStar(0)
listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(y)
listener: handleType(int, null)
ensureIdentifier(int, formalParameterDeclaration)
listener: handleIdentifier(y, formalParameterDeclaration)
listener: handleFormalParameterWithoutValue())
listener: endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
parseInitializersOpt())
listener: handleNoInitializers()
parseAsyncModifierOpt())
listener: handleAsyncModifier(null, null)
inPlainSync()
inPlainSync()
parseFunctionBody(), false, true)
parseExpressionFunctionBody(=>, false)
parseExpression(=>)
parsePrecedenceExpression(=>, 1, true)
parseUnaryExpression(=>, true)
parsePrimary(=>, expression)
parseLiteralInt(=>)
listener: handleLiteralInt(1)
listener: beginBinaryExpression(+)
parsePrecedenceExpression(+, 14, true)
parseUnaryExpression(+, true)
parsePrimary(+, expression)
parseSendOrFunctionLiteral(+, expression)
parseSend(+, expression)
ensureIdentifier(+, expression)
listener: handleIdentifier(x, expression)
listener: handleNoTypeArguments(or)
parseArgumentsOpt(x)
listener: handleNoArguments(or)
listener: handleSend(x, or)
rewriter()
listener: endBinaryExpression(+)
rewriter()
parsePrecedenceExpression(|, 10, true)
parseUnaryExpression(|, true)
parsePrimary(|, expression)
parseSendOrFunctionLiteral(|, expression)
parseSend(|, expression)
ensureIdentifier(|, expression)
parseArgumentsOpt(y)
parsePrecedenceExpression(+, 14, true)
parseUnaryExpression(+, true)
parsePrimary(+, expression)
parseLiteralInt(+)
reportRecoverableError(or, Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}])
listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}], or, or)
rewriter()
listener: beginBinaryExpression(|)
parsePrecedenceExpression(|, 10, true)
parseUnaryExpression(|, true)
parsePrimary(|, expression)
parseSendOrFunctionLiteral(|, expression)
parseSend(|, expression)
ensureIdentifier(|, expression)
listener: handleIdentifier(y, expression)
listener: handleNoTypeArguments(+)
parseArgumentsOpt(y)
listener: handleNoArguments(+)
listener: handleSend(y, +)
listener: beginBinaryExpression(+)
parsePrecedenceExpression(+, 14, true)
parseUnaryExpression(+, true)
parsePrimary(+, expression)
parseLiteralInt(+)
listener: handleLiteralInt(3)
listener: endBinaryExpression(+)
listener: endBinaryExpression(|)
ensureSemicolon(3)
listener: handleExpressionFunctionBody(=>, ;)
inGenerator()
listener: endClassMethod(null, int, (, null, ;)
listener: endMember()
notEofOrValue(}, int)
parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Key)
parseMetadataStar(;)
listener: beginMetadataStar(int)
listener: endMetadataStar(0)
listener: beginMember()
parseMethod(;, null, null, null, null, null, null, ;, Instance of 'SimpleType', null, p, DeclarationKind.Class, Key, false)
listener: beginMethod(null, null, null, null, null, p)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(p)
listener: handleType(int, null)
ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
listener: handleIdentifier(p, methodDeclaration)
parseQualifiedRestOpt(p, methodDeclarationContinuation)
parseMethodTypeVar(p)
listener: handleNoTypeVariables(()
parseGetterOrFormalParameters(p, p, false, MemberKind.NonStaticMethod)
parseFormalParameters(p, MemberKind.NonStaticMethod)
parseFormalParametersRest((, MemberKind.NonStaticMethod)
listener: beginFormalParameters((, MemberKind.NonStaticMethod)
parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
parseMetadataStar(()
listener: beginMetadataStar(int)
listener: endMetadataStar(0)
listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(x)
listener: handleType(int, null)
ensureIdentifier(int, formalParameterDeclaration)
listener: handleIdentifier(x, formalParameterDeclaration)
listener: handleFormalParameterWithoutValue(,)
listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
parseMetadataStar(,)
listener: beginMetadataStar(int)
listener: endMetadataStar(0)
listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(y)
listener: handleType(int, null)
ensureIdentifier(int, formalParameterDeclaration)
listener: handleIdentifier(y, formalParameterDeclaration)
listener: handleFormalParameterWithoutValue())
listener: endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
parseInitializersOpt())
listener: handleNoInitializers()
parseAsyncModifierOpt())
listener: handleAsyncModifier(null, null)
inPlainSync()
inPlainSync()
parseFunctionBody(), false, true)
parseExpressionFunctionBody(=>, false)
parseExpression(=>)
parsePrecedenceExpression(=>, 1, true)
parseUnaryExpression(=>, true)
parsePrimary(=>, expression)
parseLiteralInt(=>)
listener: handleLiteralInt(1)
listener: beginBinaryExpression(+)
parsePrecedenceExpression(+, 14, true)
parseUnaryExpression(+, true)
parsePrimary(+, expression)
parseSendOrFunctionLiteral(+, expression)
parseSend(+, expression)
ensureIdentifier(+, expression)
listener: handleIdentifier(x, expression)
listener: handleNoTypeArguments(|)
parseArgumentsOpt(x)
listener: handleNoArguments(|)
listener: handleSend(x, |)
listener: endBinaryExpression(+)
listener: beginBinaryExpression(|)
parsePrecedenceExpression(|, 10, true)
parseUnaryExpression(|, true)
parsePrimary(|, expression)
parseSendOrFunctionLiteral(|, expression)
parseSend(|, expression)
ensureIdentifier(|, expression)
listener: handleIdentifier(y, expression)
listener: handleNoTypeArguments(+)
parseArgumentsOpt(y)
listener: handleNoArguments(+)
listener: handleSend(y, +)
listener: beginBinaryExpression(+)
parsePrecedenceExpression(+, 14, true)
parseUnaryExpression(+, true)
parsePrimary(+, expression)
parseLiteralInt(+)
listener: handleLiteralInt(3)
listener: endBinaryExpression(+)
listener: endBinaryExpression(|)
ensureSemicolon(3)
listener: handleExpressionFunctionBody(=>, ;)
inGenerator()
listener: endClassMethod(null, int, (, null, ;)
listener: endMember()
notEofOrValue(}, int)
parseClassOrMixinOrExtensionMemberImpl(;, DeclarationKind.Class, Key)
parseMetadataStar(;)
listener: beginMetadataStar(int)
listener: endMetadataStar(0)
listener: beginMember()
parseMethod(;, null, null, null, null, null, null, ;, Instance of 'SimpleType', null, q, DeclarationKind.Class, Key, false)
listener: beginMethod(null, null, null, null, null, q)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(q)
listener: handleType(int, null)
ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
listener: handleIdentifier(q, methodDeclaration)
parseQualifiedRestOpt(q, methodDeclarationContinuation)
parseMethodTypeVar(q)
listener: handleNoTypeVariables(()
parseGetterOrFormalParameters(q, q, false, MemberKind.NonStaticMethod)
parseFormalParameters(q, MemberKind.NonStaticMethod)
parseFormalParametersRest((, MemberKind.NonStaticMethod)
listener: beginFormalParameters((, MemberKind.NonStaticMethod)
parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
parseMetadataStar(()
listener: beginMetadataStar(int)
listener: endMetadataStar(0)
listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(x)
listener: handleType(int, null)
ensureIdentifier(int, formalParameterDeclaration)
listener: handleIdentifier(x, formalParameterDeclaration)
listener: handleFormalParameterWithoutValue(,)
listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
parseMetadataStar(,)
listener: beginMetadataStar(int)
listener: endMetadataStar(0)
listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(y)
listener: handleType(int, null)
ensureIdentifier(int, formalParameterDeclaration)
listener: handleIdentifier(y, formalParameterDeclaration)
listener: handleFormalParameterWithoutValue())
listener: endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
parseInitializersOpt())
listener: handleNoInitializers()
parseAsyncModifierOpt())
listener: handleAsyncModifier(null, null)
inPlainSync()
inPlainSync()
parseFunctionBody(), false, true)
listener: beginBlockFunctionBody({)
notEofOrValue(}, return)
parseStatement({)
parseStatementX({)
parseReturnStatement({)
listener: beginReturnStatement(return)
parseExpression(return)
parsePrecedenceExpression(return, 1, true)
parseUnaryExpression(return, true)
parsePrimary(return, expression)
parseLiteralInt(return)
listener: handleLiteralInt(1)
listener: beginBinaryExpression(+)
parsePrecedenceExpression(+, 14, true)
parseUnaryExpression(+, true)
parsePrimary(+, expression)
parseSendOrFunctionLiteral(+, expression)
parseSend(+, expression)
ensureIdentifier(+, expression)
listener: handleIdentifier(x, expression)
listener: handleNoTypeArguments(or)
parseArgumentsOpt(x)
listener: handleNoArguments(or)
listener: handleSend(x, or)
rewriter()
listener: endBinaryExpression(+)
rewriter()
parsePrecedenceExpression(|, 10, true)
parseUnaryExpression(|, true)
parsePrimary(|, expression)
parseSendOrFunctionLiteral(|, expression)
parseSend(|, expression)
ensureIdentifier(|, expression)
parseArgumentsOpt(y)
parsePrecedenceExpression(+, 14, true)
parseUnaryExpression(+, true)
parsePrimary(+, expression)
parseLiteralInt(+)
reportRecoverableError(or, Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}])
listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}], or, or)
rewriter()
listener: beginBinaryExpression(|)
parsePrecedenceExpression(|, 10, true)
parseUnaryExpression(|, true)
parsePrimary(|, expression)
parseSendOrFunctionLiteral(|, expression)
parseSend(|, expression)
ensureIdentifier(|, expression)
listener: handleIdentifier(y, expression)
listener: handleNoTypeArguments(+)
parseArgumentsOpt(y)
listener: handleNoArguments(+)
listener: handleSend(y, +)
listener: beginBinaryExpression(+)
parsePrecedenceExpression(+, 14, true)
parseUnaryExpression(+, true)
parsePrimary(+, expression)
parseLiteralInt(+)
listener: handleLiteralInt(3)
listener: endBinaryExpression(+)
listener: endBinaryExpression(|)
ensureSemicolon(3)
listener: endReturnStatement(true, return, ;)
inGenerator()
notEofOrValue(}, })
listener: endBlockFunctionBody(1, {, })
listener: endClassMethod(null, int, (, null, })
listener: endMember()
notEofOrValue(}, int)
parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
parseMetadataStar(})
listener: beginMetadataStar(int)
listener: endMetadataStar(0)
listener: beginMember()
parseMethod(}, null, null, null, null, null, null, }, Instance of 'SimpleType', null, r, DeclarationKind.Class, Key, false)
listener: beginMethod(null, null, null, null, null, r)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(r)
listener: handleType(int, null)
ensureIdentifierPotentiallyRecovered(int, methodDeclaration, false)
listener: handleIdentifier(r, methodDeclaration)
parseQualifiedRestOpt(r, methodDeclarationContinuation)
parseMethodTypeVar(r)
listener: handleNoTypeVariables(()
parseGetterOrFormalParameters(r, r, false, MemberKind.NonStaticMethod)
parseFormalParameters(r, MemberKind.NonStaticMethod)
parseFormalParametersRest((, MemberKind.NonStaticMethod)
listener: beginFormalParameters((, MemberKind.NonStaticMethod)
parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
parseMetadataStar(()
listener: beginMetadataStar(int)
listener: endMetadataStar(0)
listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(x)
listener: handleType(int, null)
ensureIdentifier(int, formalParameterDeclaration)
listener: handleIdentifier(x, formalParameterDeclaration)
listener: handleFormalParameterWithoutValue(,)
listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
parseMetadataStar(,)
listener: beginMetadataStar(int)
listener: endMetadataStar(0)
listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(y)
listener: handleType(int, null)
ensureIdentifier(int, formalParameterDeclaration)
listener: handleIdentifier(y, formalParameterDeclaration)
listener: handleFormalParameterWithoutValue())
listener: endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
parseInitializersOpt())
listener: handleNoInitializers()
parseAsyncModifierOpt())
listener: handleAsyncModifier(null, null)
inPlainSync()
inPlainSync()
parseFunctionBody(), false, true)
listener: beginBlockFunctionBody({)
notEofOrValue(}, return)
parseStatement({)
parseStatementX({)
parseReturnStatement({)
listener: beginReturnStatement(return)
parseExpression(return)
parsePrecedenceExpression(return, 1, true)
parseUnaryExpression(return, true)
parsePrimary(return, expression)
parseLiteralInt(return)
listener: handleLiteralInt(1)
listener: beginBinaryExpression(+)
parsePrecedenceExpression(+, 14, true)
parseUnaryExpression(+, true)
parsePrimary(+, expression)
parseSendOrFunctionLiteral(+, expression)
parseSend(+, expression)
ensureIdentifier(+, expression)
listener: handleIdentifier(x, expression)
listener: handleNoTypeArguments(|)
parseArgumentsOpt(x)
listener: handleNoArguments(|)
listener: handleSend(x, |)
listener: endBinaryExpression(+)
listener: beginBinaryExpression(|)
parsePrecedenceExpression(|, 10, true)
parseUnaryExpression(|, true)
parsePrimary(|, expression)
parseSendOrFunctionLiteral(|, expression)
parseSend(|, expression)
ensureIdentifier(|, expression)
listener: handleIdentifier(y, expression)
listener: handleNoTypeArguments(+)
parseArgumentsOpt(y)
listener: handleNoArguments(+)
listener: handleSend(y, +)
listener: beginBinaryExpression(+)
parsePrecedenceExpression(+, 14, true)
parseUnaryExpression(+, true)
parsePrimary(+, expression)
parseLiteralInt(+)
listener: handleLiteralInt(3)
listener: endBinaryExpression(+)
listener: endBinaryExpression(|)
ensureSemicolon(3)
listener: endReturnStatement(true, return, ;)
inGenerator()
notEofOrValue(}, })
listener: endBlockFunctionBody(1, {, })
listener: endClassMethod(null, int, (, null, })
listener: endMember()
notEofOrValue(}, s)
parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
parseMetadataStar(})
listener: beginMetadataStar(s)
listener: endMetadataStar(0)
listener: beginMember()
isReservedKeyword(()
parseMethod(}, null, null, null, null, null, null, }, Instance of 'NoType', null, s, DeclarationKind.Class, Key, false)
listener: beginMethod(null, null, null, null, null, s)
listener: handleNoType(})
ensureIdentifierPotentiallyRecovered(}, methodDeclaration, false)
listener: handleIdentifier(s, methodDeclaration)
parseQualifiedRestOpt(s, methodDeclarationContinuation)
parseMethodTypeVar(s)
listener: handleNoTypeVariables(()
parseGetterOrFormalParameters(s, s, false, MemberKind.NonStaticMethod)
parseFormalParameters(s, MemberKind.NonStaticMethod)
parseFormalParametersRest((, MemberKind.NonStaticMethod)
listener: beginFormalParameters((, MemberKind.NonStaticMethod)
parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
parseMetadataStar(()
listener: beginMetadataStar(int)
listener: endMetadataStar(0)
listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(x)
listener: handleType(int, null)
ensureIdentifier(int, formalParameterDeclaration)
listener: handleIdentifier(x, formalParameterDeclaration)
listener: handleFormalParameterWithoutValue(,)
listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
parseMetadataStar(,)
listener: beginMetadataStar(int)
listener: endMetadataStar(0)
listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(y)
listener: handleType(int, null)
ensureIdentifier(int, formalParameterDeclaration)
listener: handleIdentifier(y, formalParameterDeclaration)
listener: handleFormalParameterWithoutValue())
listener: endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
parseInitializersOpt())
listener: handleNoInitializers()
parseAsyncModifierOpt())
listener: handleAsyncModifier(null, null)
inPlainSync()
inPlainSync()
parseFunctionBody(), false, true)
listener: beginBlockFunctionBody({)
notEofOrValue(}, s)
parseStatement({)
parseStatementX({)
parseExpressionStatementOrDeclarationAfterModifiers({, {, null, null, null, false)
looksLikeLocalFunction(s)
parseExpressionStatement({)
parseExpression({)
parsePrecedenceExpression({, 1, true)
parseUnaryExpression({, true)
parsePrimary({, expression)
parseSendOrFunctionLiteral({, expression)
looksLikeFunctionBody(;)
parseSend({, expression)
ensureIdentifier({, expression)
listener: handleIdentifier(s, expression)
listener: handleNoTypeArguments(()
parseArgumentsOpt(s)
parseArguments(s)
parseArgumentsRest(()
listener: beginArguments(()
parseExpression(()
parsePrecedenceExpression((, 1, true)
parseUnaryExpression((, true)
parsePrimary((, expression)
parseSendOrFunctionLiteral((, expression)
parseSend((, expression)
ensureIdentifier((, expression)
listener: handleIdentifier(x, expression)
listener: handleNoTypeArguments(or)
parseArgumentsOpt(x)
listener: handleNoArguments(or)
listener: handleSend(x, or)
rewriter()
parsePrecedenceExpression(|, 10, true)
parseUnaryExpression(|, true)
parsePrimary(|, expression)
parseSendOrFunctionLiteral(|, expression)
parseSend(|, expression)
ensureIdentifier(|, expression)
parseArgumentsOpt(y)
reportRecoverableError(or, Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}])
listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}], or, or)
rewriter()
listener: beginBinaryExpression(|)
parsePrecedenceExpression(|, 10, true)
parseUnaryExpression(|, true)
parsePrimary(|, expression)
parseSendOrFunctionLiteral(|, expression)
parseSend(|, expression)
ensureIdentifier(|, expression)
listener: handleIdentifier(y, expression)
listener: handleNoTypeArguments(,)
parseArgumentsOpt(y)
listener: handleNoArguments(,)
listener: handleSend(y, ,)
listener: endBinaryExpression(|)
parseExpression(,)
parsePrecedenceExpression(,, 1, true)
parseUnaryExpression(,, true)
parsePrimary(,, expression)
parseSendOrFunctionLiteral(,, expression)
parseSend(,, expression)
ensureIdentifier(,, expression)
listener: handleIdentifier(x, expression)
listener: handleNoTypeArguments(or)
parseArgumentsOpt(x)
listener: handleNoArguments(or)
listener: handleSend(x, or)
rewriter()
parsePrecedenceExpression(|, 10, true)
parseUnaryExpression(|, true)
parsePrimary(|, expression)
parseSendOrFunctionLiteral(|, expression)
parseSend(|, expression)
ensureIdentifier(|, expression)
parseArgumentsOpt(y)
reportRecoverableError(or, Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}])
listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}], or, or)
rewriter()
listener: beginBinaryExpression(|)
parsePrecedenceExpression(|, 10, true)
parseUnaryExpression(|, true)
parsePrimary(|, expression)
parseSendOrFunctionLiteral(|, expression)
parseSend(|, expression)
ensureIdentifier(|, expression)
listener: handleIdentifier(y, expression)
listener: handleNoTypeArguments())
parseArgumentsOpt(y)
listener: handleNoArguments())
listener: handleSend(y, ))
listener: endBinaryExpression(|)
listener: endArguments(2, (, ))
listener: handleSend(s, ;)
ensureSemicolon())
listener: handleExpressionStatement(;)
notEofOrValue(}, s)
parseStatement(;)
parseStatementX(;)
parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
looksLikeLocalFunction(s)
parseExpressionStatement(;)
parseExpression(;)
parsePrecedenceExpression(;, 1, true)
parseUnaryExpression(;, true)
parsePrimary(;, expression)
parseSendOrFunctionLiteral(;, expression)
looksLikeFunctionBody(;)
parseSend(;, expression)
ensureIdentifier(;, expression)
listener: handleIdentifier(s, expression)
listener: handleNoTypeArguments(()
parseArgumentsOpt(s)
parseArguments(s)
parseArgumentsRest(()
listener: beginArguments(()
parseExpression(()
parsePrecedenceExpression((, 1, true)
parseUnaryExpression((, true)
parsePrimary((, expression)
parseSendOrFunctionLiteral((, expression)
parseSend((, expression)
ensureIdentifier((, expression)
listener: handleIdentifier(x, expression)
listener: handleNoTypeArguments(|)
parseArgumentsOpt(x)
listener: handleNoArguments(|)
listener: handleSend(x, |)
listener: beginBinaryExpression(|)
parsePrecedenceExpression(|, 10, true)
parseUnaryExpression(|, true)
parsePrimary(|, expression)
parseSendOrFunctionLiteral(|, expression)
parseSend(|, expression)
ensureIdentifier(|, expression)
listener: handleIdentifier(y, expression)
listener: handleNoTypeArguments(,)
parseArgumentsOpt(y)
listener: handleNoArguments(,)
listener: handleSend(y, ,)
listener: endBinaryExpression(|)
parseExpression(,)
parsePrecedenceExpression(,, 1, true)
parseUnaryExpression(,, true)
parsePrimary(,, expression)
parseSendOrFunctionLiteral(,, expression)
parseSend(,, expression)
ensureIdentifier(,, expression)
listener: handleIdentifier(x, expression)
listener: handleNoTypeArguments(|)
parseArgumentsOpt(x)
listener: handleNoArguments(|)
listener: handleSend(x, |)
listener: beginBinaryExpression(|)
parsePrecedenceExpression(|, 10, true)
parseUnaryExpression(|, true)
parsePrimary(|, expression)
parseSendOrFunctionLiteral(|, expression)
parseSend(|, expression)
ensureIdentifier(|, expression)
listener: handleIdentifier(y, expression)
listener: handleNoTypeArguments())
parseArgumentsOpt(y)
listener: handleNoArguments())
listener: handleSend(y, ))
listener: endBinaryExpression(|)
listener: endArguments(2, (, ))
listener: handleSend(s, ;)
ensureSemicolon())
listener: handleExpressionStatement(;)
notEofOrValue(}, })
listener: endBlockFunctionBody(2, {, })
listener: endClassMethod(null, s, (, null, })
listener: endMember()
notEofOrValue(}, Key)
parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
parseMetadataStar(})
listener: beginMetadataStar(Key)
listener: endMetadataStar(0)
listener: beginMember()
isReservedKeyword(()
parseMethod(}, null, null, null, null, null, null, }, Instance of 'NoType', null, Key, DeclarationKind.Class, Key, false)
listener: beginMethod(null, null, null, null, null, Key)
listener: handleNoType(})
ensureIdentifierPotentiallyRecovered(}, methodDeclaration, false)
listener: handleIdentifier(Key, methodDeclaration)
parseQualifiedRestOpt(Key, methodDeclarationContinuation)
parseMethodTypeVar(Key)
listener: handleNoTypeVariables(()
parseGetterOrFormalParameters(Key, Key, false, MemberKind.NonStaticMethod)
parseFormalParameters(Key, MemberKind.NonStaticMethod)
parseFormalParametersRest((, MemberKind.NonStaticMethod)
listener: beginFormalParameters((, MemberKind.NonStaticMethod)
parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
parseMetadataStar(()
listener: beginMetadataStar(int)
listener: endMetadataStar(0)
listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(x)
listener: handleType(int, null)
ensureIdentifier(int, formalParameterDeclaration)
listener: handleIdentifier(x, formalParameterDeclaration)
listener: handleFormalParameterWithoutValue(,)
listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
parseMetadataStar(,)
listener: beginMetadataStar(int)
listener: endMetadataStar(0)
listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(y)
listener: handleType(int, null)
ensureIdentifier(int, formalParameterDeclaration)
listener: handleIdentifier(y, formalParameterDeclaration)
listener: handleFormalParameterWithoutValue())
listener: endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
parseInitializersOpt())
parseInitializers(:)
listener: beginInitializers(:)
parseInitializer(:)
listener: beginInitializer(foo)
parseInitializerExpressionRest(:)
parseExpression(:)
parsePrecedenceExpression(:, 1, true)
parseUnaryExpression(:, true)
parsePrimary(:, expression)
parseSendOrFunctionLiteral(:, expression)
parseSend(:, expression)
ensureIdentifier(:, expression)
listener: handleIdentifier(foo, expression)
listener: handleNoTypeArguments(=)
parseArgumentsOpt(foo)
listener: handleNoArguments(=)
listener: handleSend(foo, =)
parsePrecedenceExpression(=, 1, true)
parseUnaryExpression(=, true)
parsePrimary(=, expression)
parseSendOrFunctionLiteral(=, expression)
parseSend(=, expression)
ensureIdentifier(=, expression)
listener: handleIdentifier(x, expression)
listener: handleNoTypeArguments(or)
parseArgumentsOpt(x)
listener: handleNoArguments(or)
listener: handleSend(x, or)
rewriter()
parsePrecedenceExpression(|, 10, true)
parseUnaryExpression(|, true)
parsePrimary(|, expression)
parseSendOrFunctionLiteral(|, expression)
parseSend(|, expression)
ensureIdentifier(|, expression)
parseArgumentsOpt(y)
reportRecoverableError(or, Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}])
listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}], or, or)
rewriter()
listener: beginBinaryExpression(|)
parsePrecedenceExpression(|, 10, true)
parseUnaryExpression(|, true)
parsePrimary(|, expression)
parseSendOrFunctionLiteral(|, expression)
parseSend(|, expression)
ensureIdentifier(|, expression)
listener: handleIdentifier(y, expression)
listener: handleNoTypeArguments(,)
parseArgumentsOpt(y)
listener: handleNoArguments(,)
listener: handleSend(y, ,)
listener: endBinaryExpression(|)
listener: handleAssignmentExpression(=)
listener: endInitializer(,)
parseInitializer(,)
listener: beginInitializer(bar)
parseInitializerExpressionRest(,)
parseExpression(,)
parsePrecedenceExpression(,, 1, true)
parseUnaryExpression(,, true)
parsePrimary(,, expression)
parseSendOrFunctionLiteral(,, expression)
parseSend(,, expression)
ensureIdentifier(,, expression)
listener: handleIdentifier(bar, expression)
listener: handleNoTypeArguments(=)
parseArgumentsOpt(bar)
listener: handleNoArguments(=)
listener: handleSend(bar, =)
parsePrecedenceExpression(=, 1, true)
parseUnaryExpression(=, true)
parsePrimary(=, expression)
parseSendOrFunctionLiteral(=, expression)
parseSend(=, expression)
ensureIdentifier(=, expression)
listener: handleIdentifier(x, expression)
listener: handleNoTypeArguments(or)
parseArgumentsOpt(x)
listener: handleNoArguments(or)
listener: handleSend(x, or)
rewriter()
parsePrecedenceExpression(|, 10, true)
parseUnaryExpression(|, true)
parsePrimary(|, expression)
parseSendOrFunctionLiteral(|, expression)
parseSend(|, expression)
ensureIdentifier(|, expression)
parseArgumentsOpt(y)
reportRecoverableError(or, Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}])
listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}], or, or)
rewriter()
listener: beginBinaryExpression(|)
parsePrecedenceExpression(|, 10, true)
parseUnaryExpression(|, true)
parsePrimary(|, expression)
parseSendOrFunctionLiteral(|, expression)
parseSend(|, expression)
ensureIdentifier(|, expression)
listener: handleIdentifier(y, expression)
listener: handleNoTypeArguments({)
parseArgumentsOpt(y)
listener: handleNoArguments({)
listener: handleSend(y, {)
listener: endBinaryExpression(|)
listener: handleAssignmentExpression(=)
listener: endInitializer({)
listener: endInitializers(2, :, {)
parseAsyncModifierOpt(y)
listener: handleAsyncModifier(null, null)
inPlainSync()
inPlainSync()
parseFunctionBody(y, false, true)
listener: beginBlockFunctionBody({)
notEofOrValue(}, print)
parseStatement({)
parseStatementX({)
parseExpressionStatementOrDeclarationAfterModifiers({, {, null, null, null, false)
looksLikeLocalFunction(print)
parseExpressionStatement({)
parseExpression({)
parsePrecedenceExpression({, 1, true)
parseUnaryExpression({, true)
parsePrimary({, expression)
parseSendOrFunctionLiteral({, expression)
looksLikeFunctionBody(;)
parseSend({, expression)
ensureIdentifier({, expression)
listener: handleIdentifier(print, expression)
listener: handleNoTypeArguments(()
parseArgumentsOpt(print)
parseArguments(print)
parseArgumentsRest(()
listener: beginArguments(()
parseExpression(()
parsePrecedenceExpression((, 1, true)
parseUnaryExpression((, true)
parsePrimary((, expression)
parseLiteralString(()
parseSingleLiteralString(()
listener: beginLiteralString("hello )
parseExpression(${)
parsePrecedenceExpression(${, 1, true)
parseUnaryExpression(${, true)
parsePrimary(${, expression)
parseSendOrFunctionLiteral(${, expression)
parseSend(${, expression)
ensureIdentifier(${, expression)
listener: handleIdentifier(x, expression)
listener: handleNoTypeArguments(or)
parseArgumentsOpt(x)
listener: handleNoArguments(or)
listener: handleSend(x, or)
rewriter()
parsePrecedenceExpression(|, 10, true)
parseUnaryExpression(|, true)
parsePrimary(|, expression)
parseSendOrFunctionLiteral(|, expression)
parseSend(|, expression)
ensureIdentifier(|, expression)
parseArgumentsOpt(y)
reportRecoverableError(or, Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}])
listener: handleRecoverableError(Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}], or, or)
rewriter()
listener: beginBinaryExpression(|)
parsePrecedenceExpression(|, 10, true)
parseUnaryExpression(|, true)
parsePrimary(|, expression)
parseSendOrFunctionLiteral(|, expression)
parseSend(|, expression)
ensureIdentifier(|, expression)
listener: handleIdentifier(y, expression)
listener: handleNoTypeArguments(})
parseArgumentsOpt(y)
listener: handleNoArguments(})
listener: handleSend(y, })
listener: endBinaryExpression(|)
listener: handleInterpolationExpression(${, })
parseStringPart(})
listener: handleStringPart(")
listener: endLiteralString(1, ))
listener: endArguments(1, (, ))
listener: handleSend(print, ;)
ensureSemicolon())
listener: handleExpressionStatement(;)
notEofOrValue(}, })
listener: endBlockFunctionBody(1, {, })
listener: endClassConstructor(null, Key, (, :, })
listener: endMember()
notEofOrValue(}, Key)
parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
parseMetadataStar(})
listener: beginMetadataStar(Key)
listener: endMetadataStar(0)
listener: beginMember()
isReservedKeyword(()
parseMethod(}, null, null, null, null, null, null, }, Instance of 'NoType', null, Key, DeclarationKind.Class, Key, false)
listener: beginMethod(null, null, null, null, null, Key)
listener: handleNoType(})
ensureIdentifierPotentiallyRecovered(}, methodDeclaration, false)
listener: handleIdentifier(Key, methodDeclaration)
parseQualifiedRestOpt(Key, methodDeclarationContinuation)
parseMethodTypeVar(Key)
listener: handleNoTypeVariables(()
parseGetterOrFormalParameters(Key, Key, false, MemberKind.NonStaticMethod)
parseFormalParameters(Key, MemberKind.NonStaticMethod)
parseFormalParametersRest((, MemberKind.NonStaticMethod)
listener: beginFormalParameters((, MemberKind.NonStaticMethod)
parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
parseMetadataStar(()
listener: beginMetadataStar(int)
listener: endMetadataStar(0)
listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(x)
listener: handleType(int, null)
ensureIdentifier(int, formalParameterDeclaration)
listener: handleIdentifier(x, formalParameterDeclaration)
listener: handleFormalParameterWithoutValue(,)
listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
parseMetadataStar(,)
listener: beginMetadataStar(int)
listener: endMetadataStar(0)
listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(y)
listener: handleType(int, null)
ensureIdentifier(int, formalParameterDeclaration)
listener: handleIdentifier(y, formalParameterDeclaration)
listener: handleFormalParameterWithoutValue())
listener: endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
parseInitializersOpt())
parseInitializers(:)
listener: beginInitializers(:)
parseInitializer(:)
listener: beginInitializer(foo)
parseInitializerExpressionRest(:)
parseExpression(:)
parsePrecedenceExpression(:, 1, true)
parseUnaryExpression(:, true)
parsePrimary(:, expression)
parseSendOrFunctionLiteral(:, expression)
parseSend(:, expression)
ensureIdentifier(:, expression)
listener: handleIdentifier(foo, expression)
listener: handleNoTypeArguments(=)
parseArgumentsOpt(foo)
listener: handleNoArguments(=)
listener: handleSend(foo, =)
parsePrecedenceExpression(=, 1, true)
parseUnaryExpression(=, true)
parsePrimary(=, expression)
parseSendOrFunctionLiteral(=, expression)
parseSend(=, expression)
ensureIdentifier(=, expression)
listener: handleIdentifier(x, expression)
listener: handleNoTypeArguments(|)
parseArgumentsOpt(x)
listener: handleNoArguments(|)
listener: handleSend(x, |)
listener: beginBinaryExpression(|)
parsePrecedenceExpression(|, 10, true)
parseUnaryExpression(|, true)
parsePrimary(|, expression)
parseSendOrFunctionLiteral(|, expression)
parseSend(|, expression)
ensureIdentifier(|, expression)
listener: handleIdentifier(y, expression)
listener: handleNoTypeArguments(,)
parseArgumentsOpt(y)
listener: handleNoArguments(,)
listener: handleSend(y, ,)
listener: endBinaryExpression(|)
listener: handleAssignmentExpression(=)
listener: endInitializer(,)
parseInitializer(,)
listener: beginInitializer(bar)
parseInitializerExpressionRest(,)
parseExpression(,)
parsePrecedenceExpression(,, 1, true)
parseUnaryExpression(,, true)
parsePrimary(,, expression)
parseSendOrFunctionLiteral(,, expression)
parseSend(,, expression)
ensureIdentifier(,, expression)
listener: handleIdentifier(bar, expression)
listener: handleNoTypeArguments(=)
parseArgumentsOpt(bar)
listener: handleNoArguments(=)
listener: handleSend(bar, =)
parsePrecedenceExpression(=, 1, true)
parseUnaryExpression(=, true)
parsePrimary(=, expression)
parseSendOrFunctionLiteral(=, expression)
parseSend(=, expression)
ensureIdentifier(=, expression)
listener: handleIdentifier(x, expression)
listener: handleNoTypeArguments(|)
parseArgumentsOpt(x)
listener: handleNoArguments(|)
listener: handleSend(x, |)
listener: beginBinaryExpression(|)
parsePrecedenceExpression(|, 10, true)
parseUnaryExpression(|, true)
parsePrimary(|, expression)
parseSendOrFunctionLiteral(|, expression)
parseSend(|, expression)
ensureIdentifier(|, expression)
listener: handleIdentifier(y, expression)
listener: handleNoTypeArguments({)
parseArgumentsOpt(y)
listener: handleNoArguments({)
listener: handleSend(y, {)
listener: endBinaryExpression(|)
listener: handleAssignmentExpression(=)
listener: endInitializer({)
listener: endInitializers(2, :, {)
parseAsyncModifierOpt(y)
listener: handleAsyncModifier(null, null)
inPlainSync()
inPlainSync()
parseFunctionBody(y, false, true)
listener: beginBlockFunctionBody({)
notEofOrValue(}, print)
parseStatement({)
parseStatementX({)
parseExpressionStatementOrDeclarationAfterModifiers({, {, null, null, null, false)
looksLikeLocalFunction(print)
parseExpressionStatement({)
parseExpression({)
parsePrecedenceExpression({, 1, true)
parseUnaryExpression({, true)
parsePrimary({, expression)
parseSendOrFunctionLiteral({, expression)
looksLikeFunctionBody(;)
parseSend({, expression)
ensureIdentifier({, expression)
listener: handleIdentifier(print, expression)
listener: handleNoTypeArguments(()
parseArgumentsOpt(print)
parseArguments(print)
parseArgumentsRest(()
listener: beginArguments(()
parseExpression(()
parsePrecedenceExpression((, 1, true)
parseUnaryExpression((, true)
parsePrimary((, expression)
parseLiteralString(()
parseSingleLiteralString(()
listener: beginLiteralString("hello )
parseExpression(${)
parsePrecedenceExpression(${, 1, true)
parseUnaryExpression(${, true)
parsePrimary(${, expression)
parseSendOrFunctionLiteral(${, expression)
parseSend(${, expression)
ensureIdentifier(${, expression)
listener: handleIdentifier(x, expression)
listener: handleNoTypeArguments(|)
parseArgumentsOpt(x)
listener: handleNoArguments(|)
listener: handleSend(x, |)
listener: beginBinaryExpression(|)
parsePrecedenceExpression(|, 10, true)
parseUnaryExpression(|, true)
parsePrimary(|, expression)
parseSendOrFunctionLiteral(|, expression)
parseSend(|, expression)
ensureIdentifier(|, expression)
listener: handleIdentifier(y, expression)
listener: handleNoTypeArguments(})
parseArgumentsOpt(y)
listener: handleNoArguments(})
listener: handleSend(y, })
listener: endBinaryExpression(|)
listener: handleInterpolationExpression(${, })
parseStringPart(})
listener: handleStringPart(")
listener: endLiteralString(1, ))
listener: endArguments(1, (, ))
listener: handleSend(print, ;)
ensureSemicolon())
listener: handleExpressionStatement(;)
notEofOrValue(}, })
listener: endBlockFunctionBody(1, {, })
listener: endClassConstructor(null, Key, (, :, })
listener: endMember()
notEofOrValue(}, not_currently_working)
parseClassOrMixinOrExtensionMemberImpl(}, DeclarationKind.Class, Key)
parseMetadataStar(})
listener: beginMetadataStar(not_currently_working)
listener: endMetadataStar(0)
listener: beginMember()
isReservedKeyword(()
parseMethod(}, null, null, null, null, null, null, }, Instance of 'NoType', null, not_currently_working, DeclarationKind.Class, Key, false)
listener: beginMethod(null, null, null, null, null, not_currently_working)
listener: handleNoType(})
ensureIdentifierPotentiallyRecovered(}, methodDeclaration, false)
listener: handleIdentifier(not_currently_working, methodDeclaration)
parseQualifiedRestOpt(not_currently_working, methodDeclarationContinuation)
parseMethodTypeVar(not_currently_working)
listener: handleNoTypeVariables(()
parseGetterOrFormalParameters(not_currently_working, not_currently_working, false, MemberKind.NonStaticMethod)
parseFormalParameters(not_currently_working, MemberKind.NonStaticMethod)
parseFormalParametersRest((, MemberKind.NonStaticMethod)
listener: beginFormalParameters((, MemberKind.NonStaticMethod)
parseFormalParameter((, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
parseMetadataStar(()
listener: beginMetadataStar(int)
listener: endMetadataStar(0)
listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(x)
listener: handleType(int, null)
ensureIdentifier(int, formalParameterDeclaration)
listener: handleIdentifier(x, formalParameterDeclaration)
listener: handleFormalParameterWithoutValue(,)
listener: endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
parseFormalParameter(,, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
parseMetadataStar(,)
listener: beginMetadataStar(int)
listener: endMetadataStar(0)
listener: beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null)
listener: handleIdentifier(int, typeReference)
listener: handleNoTypeArguments(y)
listener: handleType(int, null)
ensureIdentifier(int, formalParameterDeclaration)
listener: handleIdentifier(y, formalParameterDeclaration)
listener: handleFormalParameterWithoutValue())
listener: endFormalParameter(null, null, y, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod)
listener: endFormalParameters(2, (, ), MemberKind.NonStaticMethod)
parseInitializersOpt())
listener: handleNoInitializers()
parseAsyncModifierOpt())
listener: handleAsyncModifier(null, null)
inPlainSync()
inPlainSync()
parseFunctionBody(), false, true)
listener: beginBlockFunctionBody({)
notEofOrValue(}, x)
parseStatement({)
parseStatementX({)
parseExpressionStatementOrDeclarationAfterModifiers({, {, null, null, null, false)
looksLikeLocalFunction(or)
listener: beginMetadataStar(x)
listener: endMetadataStar(0)
listener: handleIdentifier(x, typeReference)
listener: handleNoTypeArguments(or)
listener: handleType(x, null)
listener: beginVariablesDeclaration(or, null, null)
parseVariablesDeclarationRest(x, true)
parseOptionallyInitializedIdentifier(x)
ensureIdentifier(x, localVariableDeclaration)
listener: handleIdentifier(or, localVariableDeclaration)
listener: beginInitializedIdentifier(or)
parseVariableInitializerOpt(or)
listener: handleNoVariableInitializer(or)
listener: endInitializedIdentifier(or)
ensureSemicolon(or)
reportRecoverableError(or, Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}])
listener: handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], or, or)
rewriter()
listener: endVariablesDeclaration(1, ;)
notEofOrValue(}, y)
parseStatement(;)
parseStatementX(;)
parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
looksLikeLocalFunction(y)
parseExpressionStatement(;)
parseExpression(;)
parsePrecedenceExpression(;, 1, true)
parseUnaryExpression(;, true)
parsePrimary(;, expression)
parseSendOrFunctionLiteral(;, expression)
parseSend(;, expression)
ensureIdentifier(;, expression)
listener: handleIdentifier(y, expression)
listener: handleNoTypeArguments(;)
parseArgumentsOpt(y)
listener: handleNoArguments(;)
listener: handleSend(y, ;)
ensureSemicolon(y)
listener: handleExpressionStatement(;)
notEofOrValue(}, x)
parseStatement(;)
parseStatementX(;)
parseExpressionStatementOrDeclarationAfterModifiers(;, ;, null, null, null, false)
looksLikeLocalFunction(x)
parseExpressionStatement(;)
parseExpression(;)
parsePrecedenceExpression(;, 1, true)
parseUnaryExpression(;, true)
parsePrimary(;, expression)
parseSendOrFunctionLiteral(;, expression)
parseSend(;, expression)
ensureIdentifier(;, expression)
listener: handleIdentifier(x, expression)
listener: handleNoTypeArguments(|)
parseArgumentsOpt(x)
listener: handleNoArguments(|)
listener: handleSend(x, |)
listener: beginBinaryExpression(|)
parsePrecedenceExpression(|, 10, true)
parseUnaryExpression(|, true)
parsePrimary(|, expression)
parseSendOrFunctionLiteral(|, expression)
parseSend(|, expression)
ensureIdentifier(|, expression)
listener: handleIdentifier(y, expression)
listener: handleNoTypeArguments(;)
parseArgumentsOpt(y)
listener: handleNoArguments(;)
listener: handleSend(y, ;)
listener: endBinaryExpression(|)
ensureSemicolon(y)
listener: handleExpressionStatement(;)
notEofOrValue(}, })
listener: endBlockFunctionBody(3, {, })
listener: endClassMethod(null, not_currently_working, (, null, })
listener: endMember()
notEofOrValue(}, })
listener: endClassOrMixinBody(DeclarationKind.Class, 22, {, })
listener: endClassDeclaration(abstract, })
listener: endTopLevelDeclaration()
reportAllErrorTokens(abstract)
listener: endCompilationUnit(1, )