| Problems reported: |
| |
| parser/error_recovery/keyword_named_class_methods:12:7: 'assert' can't be used as an identifier because it's a keyword. |
| int assert(int x) { |
| ^^^^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:14:12: `assert` can't be used as an expression. |
| return assert(x-1) + 1; |
| ^^^^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:27:7: 'break' can't be used as an identifier because it's a keyword. |
| int break(int x) { |
| ^^^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:29:12: Expected an identifier, but got 'break'. |
| return break(x-1) + 1; |
| ^^^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:29:12: Expected ';' after this. |
| return break(x-1) + 1; |
| ^^^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:29:12: A break statement can't be used outside of a loop or switch statement. |
| return break(x-1) + 1; |
| ^^^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:29:12: Expected ';' after this. |
| return break(x-1) + 1; |
| ^^^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:32:7: 'case' can't be used as an identifier because it's a keyword. |
| int case(int x) { |
| ^^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:34:12: 'case' can't be used as an identifier because it's a keyword. |
| return case(x-1) + 1; |
| ^^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:37:7: 'catch' can't be used as an identifier because it's a keyword. |
| int catch(int x) { |
| ^^^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:39:12: 'catch' can't be used as an identifier because it's a keyword. |
| return catch(x-1) + 1; |
| ^^^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:42:7: 'class' can't be used as an identifier because it's a keyword. |
| int class(int x) { |
| ^^^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:44:12: 'class' can't be used as an identifier because it's a keyword. |
| return class(x-1) + 1; |
| ^^^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:47:7: 'const' can't be used as an identifier because it's a keyword. |
| int const(int x) { |
| ^^^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:49:17: Expected an identifier, but got '('. |
| return const(x-1) + 1; |
| ^ |
| |
| parser/error_recovery/keyword_named_class_methods:52:7: 'continue' can't be used as an identifier because it's a keyword. |
| int continue(int x) { |
| ^^^^^^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:54:12: Expected an identifier, but got 'continue'. |
| return continue(x-1) + 1; |
| ^^^^^^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:54:12: Expected ';' after this. |
| return continue(x-1) + 1; |
| ^^^^^^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:54:12: A continue statement can't be used outside of a loop or switch statement. |
| return continue(x-1) + 1; |
| ^^^^^^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:54:12: Expected ';' after this. |
| return continue(x-1) + 1; |
| ^^^^^^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:62:7: 'default' can't be used as an identifier because it's a keyword. |
| int default(int x) { |
| ^^^^^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:64:12: 'default' can't be used as an identifier because it's a keyword. |
| return default(x-1) + 1; |
| ^^^^^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:72:7: 'do' can't be used as an identifier because it's a keyword. |
| int do(int x) { |
| ^^ |
| |
| parser/error_recovery/keyword_named_class_methods:74:12: Expected an identifier, but got 'do'. |
| return do(x-1) + 1; |
| ^^ |
| |
| parser/error_recovery/keyword_named_class_methods:74:12: Expected ';' after this. |
| return do(x-1) + 1; |
| ^^ |
| |
| parser/error_recovery/keyword_named_class_methods:75:3: Expected 'while' before this. |
| } |
| ^ |
| |
| parser/error_recovery/keyword_named_class_methods:75:3: Expected to find '('. |
| } |
| ^ |
| |
| parser/error_recovery/keyword_named_class_methods:75:3: Expected an identifier, but got '}'. |
| } |
| ^ |
| |
| parser/error_recovery/keyword_named_class_methods:75:3: Expected ';' after this. |
| } |
| ^ |
| |
| parser/error_recovery/keyword_named_class_methods:82:7: 'else' can't be used as an identifier because it's a keyword. |
| int else(int x) { |
| ^^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:84:12: Expected an identifier, but got 'else'. |
| return else(x-1) + 1; |
| ^^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:84:12: Expected ';' after this. |
| return else(x-1) + 1; |
| ^^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:84:12: Expected an identifier, but got 'else'. |
| return else(x-1) + 1; |
| ^^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:84:12: Expected ';' after this. |
| return else(x-1) + 1; |
| ^^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:84:12: Unexpected token ';'. |
| return else(x-1) + 1; |
| ^^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:87:7: 'enum' can't be used as an identifier because it's a keyword. |
| int enum(int x) { |
| ^^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:89:12: 'enum' can't be used as an identifier because it's a keyword. |
| return enum(x-1) + 1; |
| ^^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:97:7: 'extends' can't be used as an identifier because it's a keyword. |
| int extends(int x) { |
| ^^^^^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:99:12: 'extends' can't be used as an identifier because it's a keyword. |
| return extends(x-1) + 1; |
| ^^^^^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:117:7: 'false' can't be used as an identifier because it's a keyword. |
| int false(int x) { |
| ^^^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:122:7: 'final' can't be used as an identifier because it's a keyword. |
| int final(int x) { |
| ^^^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:124:12: Expected an identifier, but got 'final'. |
| return final(x-1) + 1; |
| ^^^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:124:12: Expected ';' after this. |
| return final(x-1) + 1; |
| ^^^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:124:17: Expected an identifier, but got '('. |
| return final(x-1) + 1; |
| ^ |
| |
| parser/error_recovery/keyword_named_class_methods:124:18: Expected ';' after this. |
| return final(x-1) + 1; |
| ^ |
| |
| parser/error_recovery/keyword_named_class_methods:124:20: Expected ';' after this. |
| return final(x-1) + 1; |
| ^ |
| |
| parser/error_recovery/keyword_named_class_methods:124:21: Expected an identifier, but got ')'. |
| return final(x-1) + 1; |
| ^ |
| |
| parser/error_recovery/keyword_named_class_methods:124:21: Expected ';' after this. |
| return final(x-1) + 1; |
| ^ |
| |
| parser/error_recovery/keyword_named_class_methods:124:21: Unexpected token ';'. |
| return final(x-1) + 1; |
| ^ |
| |
| parser/error_recovery/keyword_named_class_methods:124:23: '+' is not a prefix operator. |
| return final(x-1) + 1; |
| ^ |
| |
| parser/error_recovery/keyword_named_class_methods:127:7: 'finally' can't be used as an identifier because it's a keyword. |
| int finally(int x) { |
| ^^^^^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:129:12: 'finally' can't be used as an identifier because it's a keyword. |
| return finally(x-1) + 1; |
| ^^^^^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:132:7: 'for' can't be used as an identifier because it's a keyword. |
| int for(int x) { |
| ^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:134:12: Expected an identifier, but got 'for'. |
| return for(x-1) + 1; |
| ^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:134:12: Expected ';' after this. |
| return for(x-1) + 1; |
| ^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:134:18: Expected ';' after this. |
| return for(x-1) + 1; |
| ^ |
| |
| parser/error_recovery/keyword_named_class_methods:134:19: Expected an identifier, but got ')'. |
| return for(x-1) + 1; |
| ^ |
| |
| parser/error_recovery/keyword_named_class_methods:134:19: Expected ';' after this. |
| return for(x-1) + 1; |
| ^ |
| |
| parser/error_recovery/keyword_named_class_methods:134:21: '+' is not a prefix operator. |
| return for(x-1) + 1; |
| ^ |
| |
| parser/error_recovery/keyword_named_class_methods:152:7: 'if' can't be used as an identifier because it's a keyword. |
| int if(int x) { |
| ^^ |
| |
| parser/error_recovery/keyword_named_class_methods:154:12: Expected an identifier, but got 'if'. |
| return if(x-1) + 1; |
| ^^ |
| |
| parser/error_recovery/keyword_named_class_methods:154:12: Expected ';' after this. |
| return if(x-1) + 1; |
| ^^ |
| |
| parser/error_recovery/keyword_named_class_methods:154:20: '+' is not a prefix operator. |
| return if(x-1) + 1; |
| ^ |
| |
| parser/error_recovery/keyword_named_class_methods:167:7: 'in' can't be used as an identifier because it's a keyword. |
| int in(int x) { |
| ^^ |
| |
| parser/error_recovery/keyword_named_class_methods:169:12: 'in' can't be used as an identifier because it's a keyword. |
| return in(x-1) + 1; |
| ^^ |
| |
| parser/error_recovery/keyword_named_class_methods:182:7: 'is' can't be used as an identifier because it's a keyword. |
| int is(int x) { |
| ^^ |
| |
| parser/error_recovery/keyword_named_class_methods:184:12: Expected an identifier, but got 'is'. |
| return is(x-1) + 1; |
| ^^ |
| |
| parser/error_recovery/keyword_named_class_methods:184:14: Expected a type, but got '('. |
| return is(x-1) + 1; |
| ^ |
| |
| parser/error_recovery/keyword_named_class_methods:184:14: Expected ';' after this. |
| return is(x-1) + 1; |
| ^ |
| |
| parser/error_recovery/keyword_named_class_methods:207:7: 'new' can't be used as an identifier because it's a keyword. |
| int new(int x) { |
| ^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:209:15: Expected an identifier, but got '('. |
| return new(x-1) + 1; |
| ^ |
| |
| parser/error_recovery/keyword_named_class_methods:212:7: 'null' can't be used as an identifier because it's a keyword. |
| int null(int x) { |
| ^^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:252:7: 'rethrow' can't be used as an identifier because it's a keyword. |
| int rethrow(int x) { |
| ^^^^^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:254:12: 'rethrow' can't be used as an identifier because it's a keyword. |
| return rethrow(x-1) + 1; |
| ^^^^^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:257:7: 'return' can't be used as an identifier because it's a keyword. |
| int return(int x) { |
| ^^^^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:259:12: Unexpected token 'return'. |
| return return(x-1) + 1; |
| ^^^^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:282:7: 'super' can't be used as an identifier because it's a keyword. |
| int super(int x) { |
| ^^^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:287:7: 'switch' can't be used as an identifier because it's a keyword. |
| int switch(int x) { |
| ^^^^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:289:12: Expected an identifier, but got 'switch'. |
| return switch(x-1) + 1; |
| ^^^^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:289:12: Expected ';' after this. |
| return switch(x-1) + 1; |
| ^^^^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:289:22: A switch statement must have a body, even if it is empty. |
| return switch(x-1) + 1; |
| ^ |
| |
| parser/error_recovery/keyword_named_class_methods:289:24: '+' is not a prefix operator. |
| return switch(x-1) + 1; |
| ^ |
| |
| parser/error_recovery/keyword_named_class_methods:297:7: 'this' can't be used as an identifier because it's a keyword. |
| int this(int x) { |
| ^^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:297:7: Expected ';' after this. |
| int this(int x) { |
| ^^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:297:11: Expected an identifier, but got '('. |
| int this(int x) { |
| ^ |
| |
| parser/error_recovery/keyword_named_class_methods:302:7: 'throw' can't be used as an identifier because it's a keyword. |
| int throw(int x) { |
| ^^^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:307:7: 'true' can't be used as an identifier because it's a keyword. |
| int true(int x) { |
| ^^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:312:7: 'try' can't be used as an identifier because it's a keyword. |
| int try(int x) { |
| ^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:314:12: Expected an identifier, but got 'try'. |
| return try(x-1) + 1; |
| ^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:314:12: Expected ';' after this. |
| return try(x-1) + 1; |
| ^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:314:12: A try statement must have a body, even if it is empty. |
| return try(x-1) + 1; |
| ^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:314:12: A try block must be followed by an 'on', 'catch', or 'finally' clause. |
| return try(x-1) + 1; |
| ^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:322:7: 'var' can't be used as an identifier because it's a keyword. |
| int var(int x) { |
| ^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:324:12: Expected an identifier, but got 'var'. |
| return var(x-1) + 1; |
| ^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:324:12: Expected ';' after this. |
| return var(x-1) + 1; |
| ^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:324:15: Expected an identifier, but got '('. |
| return var(x-1) + 1; |
| ^ |
| |
| parser/error_recovery/keyword_named_class_methods:324:16: Expected ';' after this. |
| return var(x-1) + 1; |
| ^ |
| |
| parser/error_recovery/keyword_named_class_methods:324:18: Expected ';' after this. |
| return var(x-1) + 1; |
| ^ |
| |
| parser/error_recovery/keyword_named_class_methods:324:19: Expected an identifier, but got ')'. |
| return var(x-1) + 1; |
| ^ |
| |
| parser/error_recovery/keyword_named_class_methods:324:19: Expected ';' after this. |
| return var(x-1) + 1; |
| ^ |
| |
| parser/error_recovery/keyword_named_class_methods:324:19: Unexpected token ';'. |
| return var(x-1) + 1; |
| ^ |
| |
| parser/error_recovery/keyword_named_class_methods:324:21: '+' is not a prefix operator. |
| return var(x-1) + 1; |
| ^ |
| |
| parser/error_recovery/keyword_named_class_methods:327:7: 'void' can't be used as an identifier because it's a keyword. |
| int void(int x) { |
| ^^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:329:12: Expected an identifier, but got 'void'. |
| return void(x-1) + 1; |
| ^^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:329:12: Expected ';' after this. |
| return void(x-1) + 1; |
| ^^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:329:16: Expected an identifier, but got '('. |
| return void(x-1) + 1; |
| ^ |
| |
| parser/error_recovery/keyword_named_class_methods:329:17: Expected ';' after this. |
| return void(x-1) + 1; |
| ^ |
| |
| parser/error_recovery/keyword_named_class_methods:329:19: Expected ';' after this. |
| return void(x-1) + 1; |
| ^ |
| |
| parser/error_recovery/keyword_named_class_methods:329:20: Expected an identifier, but got ')'. |
| return void(x-1) + 1; |
| ^ |
| |
| parser/error_recovery/keyword_named_class_methods:329:20: Expected ';' after this. |
| return void(x-1) + 1; |
| ^ |
| |
| parser/error_recovery/keyword_named_class_methods:329:20: Unexpected token ';'. |
| return void(x-1) + 1; |
| ^ |
| |
| parser/error_recovery/keyword_named_class_methods:329:22: '+' is not a prefix operator. |
| return void(x-1) + 1; |
| ^ |
| |
| parser/error_recovery/keyword_named_class_methods:332:7: 'while' can't be used as an identifier because it's a keyword. |
| int while(int x) { |
| ^^^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:334:12: Expected an identifier, but got 'while'. |
| return while(x-1) + 1; |
| ^^^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:334:12: Expected ';' after this. |
| return while(x-1) + 1; |
| ^^^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:334:23: '+' is not a prefix operator. |
| return while(x-1) + 1; |
| ^ |
| |
| parser/error_recovery/keyword_named_class_methods:337:7: 'with' can't be used as an identifier because it's a keyword. |
| int with(int x) { |
| ^^^^ |
| |
| parser/error_recovery/keyword_named_class_methods:339:12: 'with' can't be used as an identifier because it's a keyword. |
| return with(x-1) + 1; |
| ^^^^ |
| |
| beginCompilationUnit(class) |
| beginMetadataStar(class) |
| endMetadataStar(0) |
| beginClassOrNamedMixinApplicationPrelude(class) |
| handleIdentifier(WrapperClass, classOrMixinDeclaration) |
| handleNoTypeVariables({) |
| beginClassDeclaration(class, null, WrapperClass) |
| handleNoType(WrapperClass) |
| handleClassExtends(null, 1) |
| handleClassNoWithClause() |
| handleClassOrMixinImplements(null, 0) |
| handleClassHeader(class, class, null) |
| beginClassOrMixinBody(DeclarationKind.Class, {) |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginMember() |
| beginMethod(null, null, null, null, null, abstract) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(abstract) |
| handleType(int, null) |
| handleIdentifier(abstract, methodDeclaration) |
| handleNoTypeVariables(() |
| beginFormalParameters((, MemberKind.NonStaticMethod) |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(x) |
| handleType(int, null) |
| handleIdentifier(x, formalParameterDeclaration) |
| handleFormalParameterWithoutValue()) |
| endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) |
| endFormalParameters(1, (, ), MemberKind.NonStaticMethod) |
| handleNoInitializers() |
| handleAsyncModifier(null, null) |
| beginBlockFunctionBody({) |
| beginIfStatement(if) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(==) |
| handleNoArguments(==) |
| handleSend(x, ==) |
| beginBinaryExpression(==) |
| handleLiteralInt(0) |
| endBinaryExpression(==) |
| handleParenthesizedCondition(() |
| beginThenStatement(return) |
| beginReturnStatement(return) |
| handleLiteralInt(42) |
| endReturnStatement(true, return, ;) |
| endThenStatement(;) |
| endIfStatement(if, null) |
| beginReturnStatement(return) |
| handleIdentifier(abstract, expression) |
| handleNoTypeArguments(() |
| beginArguments(() |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(-) |
| handleNoArguments(-) |
| handleSend(x, -) |
| beginBinaryExpression(-) |
| handleLiteralInt(1) |
| endBinaryExpression(-) |
| endArguments(1, (, )) |
| handleSend(abstract, +) |
| beginBinaryExpression(+) |
| handleLiteralInt(1) |
| endBinaryExpression(+) |
| endReturnStatement(true, return, ;) |
| endBlockFunctionBody(2, {, }) |
| endClassMethod(null, int, (, null, }) |
| endMember() |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginMember() |
| beginMethod(null, null, null, null, null, as) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(as) |
| handleType(int, null) |
| handleIdentifier(as, methodDeclaration) |
| handleNoTypeVariables(() |
| beginFormalParameters((, MemberKind.NonStaticMethod) |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(x) |
| handleType(int, null) |
| handleIdentifier(x, formalParameterDeclaration) |
| handleFormalParameterWithoutValue()) |
| endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) |
| endFormalParameters(1, (, ), MemberKind.NonStaticMethod) |
| handleNoInitializers() |
| handleAsyncModifier(null, null) |
| beginBlockFunctionBody({) |
| beginIfStatement(if) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(==) |
| handleNoArguments(==) |
| handleSend(x, ==) |
| beginBinaryExpression(==) |
| handleLiteralInt(0) |
| endBinaryExpression(==) |
| handleParenthesizedCondition(() |
| beginThenStatement(return) |
| beginReturnStatement(return) |
| handleLiteralInt(42) |
| endReturnStatement(true, return, ;) |
| endThenStatement(;) |
| endIfStatement(if, null) |
| beginReturnStatement(return) |
| handleIdentifier(as, expression) |
| handleNoTypeArguments(() |
| beginArguments(() |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(-) |
| handleNoArguments(-) |
| handleSend(x, -) |
| beginBinaryExpression(-) |
| handleLiteralInt(1) |
| endBinaryExpression(-) |
| endArguments(1, (, )) |
| handleSend(as, +) |
| beginBinaryExpression(+) |
| handleLiteralInt(1) |
| endBinaryExpression(+) |
| endReturnStatement(true, return, ;) |
| endBlockFunctionBody(2, {, }) |
| endClassMethod(null, int, (, null, }) |
| endMember() |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginMember() |
| beginMethod(null, null, null, null, null, assert) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(assert) |
| handleType(int, null) |
| handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'assert' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: assert}], assert, assert) |
| handleIdentifier(assert, methodDeclaration) |
| handleNoTypeVariables(() |
| beginFormalParameters((, MemberKind.NonStaticMethod) |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(x) |
| handleType(int, null) |
| handleIdentifier(x, formalParameterDeclaration) |
| handleFormalParameterWithoutValue()) |
| endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) |
| endFormalParameters(1, (, ), MemberKind.NonStaticMethod) |
| handleNoInitializers() |
| handleAsyncModifier(null, null) |
| beginBlockFunctionBody({) |
| beginIfStatement(if) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(==) |
| handleNoArguments(==) |
| handleSend(x, ==) |
| beginBinaryExpression(==) |
| handleLiteralInt(0) |
| endBinaryExpression(==) |
| handleParenthesizedCondition(() |
| beginThenStatement(return) |
| beginReturnStatement(return) |
| handleLiteralInt(42) |
| endReturnStatement(true, return, ;) |
| endThenStatement(;) |
| endIfStatement(if, null) |
| beginReturnStatement(return) |
| beginAssert(assert, Assert.Expression) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(-) |
| handleNoArguments(-) |
| handleSend(x, -) |
| beginBinaryExpression(-) |
| handleLiteralInt(1) |
| endBinaryExpression(-) |
| handleRecoverableError(AssertAsExpression, assert, assert) |
| endAssert(assert, Assert.Expression, (, null, +) |
| beginBinaryExpression(+) |
| handleLiteralInt(1) |
| endBinaryExpression(+) |
| endReturnStatement(true, return, ;) |
| endBlockFunctionBody(2, {, }) |
| endClassMethod(null, int, (, null, }) |
| endMember() |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginMember() |
| beginMethod(null, null, null, null, null, async) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(async) |
| handleType(int, null) |
| handleIdentifier(async, methodDeclaration) |
| handleNoTypeVariables(() |
| beginFormalParameters((, MemberKind.NonStaticMethod) |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(x) |
| handleType(int, null) |
| handleIdentifier(x, formalParameterDeclaration) |
| handleFormalParameterWithoutValue()) |
| endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) |
| endFormalParameters(1, (, ), MemberKind.NonStaticMethod) |
| handleNoInitializers() |
| handleAsyncModifier(null, null) |
| beginBlockFunctionBody({) |
| beginIfStatement(if) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(==) |
| handleNoArguments(==) |
| handleSend(x, ==) |
| beginBinaryExpression(==) |
| handleLiteralInt(0) |
| endBinaryExpression(==) |
| handleParenthesizedCondition(() |
| beginThenStatement(return) |
| beginReturnStatement(return) |
| handleLiteralInt(42) |
| endReturnStatement(true, return, ;) |
| endThenStatement(;) |
| endIfStatement(if, null) |
| beginReturnStatement(return) |
| handleIdentifier(async, expression) |
| handleNoTypeArguments(() |
| beginArguments(() |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(-) |
| handleNoArguments(-) |
| handleSend(x, -) |
| beginBinaryExpression(-) |
| handleLiteralInt(1) |
| endBinaryExpression(-) |
| endArguments(1, (, )) |
| handleSend(async, +) |
| beginBinaryExpression(+) |
| handleLiteralInt(1) |
| endBinaryExpression(+) |
| endReturnStatement(true, return, ;) |
| endBlockFunctionBody(2, {, }) |
| endClassMethod(null, int, (, null, }) |
| endMember() |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginMember() |
| beginMethod(null, null, null, null, null, await) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(await) |
| handleType(int, null) |
| handleIdentifier(await, methodDeclaration) |
| handleNoTypeVariables(() |
| beginFormalParameters((, MemberKind.NonStaticMethod) |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(x) |
| handleType(int, null) |
| handleIdentifier(x, formalParameterDeclaration) |
| handleFormalParameterWithoutValue()) |
| endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) |
| endFormalParameters(1, (, ), MemberKind.NonStaticMethod) |
| handleNoInitializers() |
| handleAsyncModifier(null, null) |
| beginBlockFunctionBody({) |
| beginIfStatement(if) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(==) |
| handleNoArguments(==) |
| handleSend(x, ==) |
| beginBinaryExpression(==) |
| handleLiteralInt(0) |
| endBinaryExpression(==) |
| handleParenthesizedCondition(() |
| beginThenStatement(return) |
| beginReturnStatement(return) |
| handleLiteralInt(42) |
| endReturnStatement(true, return, ;) |
| endThenStatement(;) |
| endIfStatement(if, null) |
| beginReturnStatement(return) |
| handleIdentifier(await, expression) |
| handleNoTypeArguments(() |
| beginArguments(() |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(-) |
| handleNoArguments(-) |
| handleSend(x, -) |
| beginBinaryExpression(-) |
| handleLiteralInt(1) |
| endBinaryExpression(-) |
| endArguments(1, (, )) |
| handleSend(await, +) |
| beginBinaryExpression(+) |
| handleLiteralInt(1) |
| endBinaryExpression(+) |
| endReturnStatement(true, return, ;) |
| endBlockFunctionBody(2, {, }) |
| endClassMethod(null, int, (, null, }) |
| endMember() |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginMember() |
| beginMethod(null, null, null, null, null, break) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(break) |
| handleType(int, null) |
| handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'break' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: break}], break, break) |
| handleIdentifier(break, methodDeclaration) |
| handleNoTypeVariables(() |
| beginFormalParameters((, MemberKind.NonStaticMethod) |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(x) |
| handleType(int, null) |
| handleIdentifier(x, formalParameterDeclaration) |
| handleFormalParameterWithoutValue()) |
| endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) |
| endFormalParameters(1, (, ), MemberKind.NonStaticMethod) |
| handleNoInitializers() |
| handleAsyncModifier(null, null) |
| beginBlockFunctionBody({) |
| beginIfStatement(if) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(==) |
| handleNoArguments(==) |
| handleSend(x, ==) |
| beginBinaryExpression(==) |
| handleLiteralInt(0) |
| endBinaryExpression(==) |
| handleParenthesizedCondition(() |
| beginThenStatement(return) |
| beginReturnStatement(return) |
| handleLiteralInt(42) |
| endReturnStatement(true, return, ;) |
| endThenStatement(;) |
| endIfStatement(if, null) |
| beginReturnStatement(return) |
| handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'break'., Try inserting an identifier before 'break'., {lexeme: break}], break, break) |
| handleIdentifier(, expression) |
| handleNoTypeArguments(break) |
| handleNoArguments(break) |
| handleSend(, break) |
| handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], break, break) |
| endReturnStatement(true, return, ;) |
| handleRecoverableError(BreakOutsideOfLoop, break, break) |
| handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], break, break) |
| handleBreakStatement(false, break, ;) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(-) |
| handleNoArguments(-) |
| handleSend(x, -) |
| beginBinaryExpression(-) |
| handleLiteralInt(1) |
| endBinaryExpression(-) |
| handleParenthesizedExpression(() |
| beginBinaryExpression(+) |
| handleLiteralInt(1) |
| endBinaryExpression(+) |
| handleExpressionStatement(;) |
| endBlockFunctionBody(4, {, }) |
| endClassMethod(null, int, (, null, }) |
| endMember() |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginMember() |
| beginMethod(null, null, null, null, null, case) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(case) |
| handleType(int, null) |
| handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'case' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: case}], case, case) |
| handleIdentifier(case, methodDeclaration) |
| handleNoTypeVariables(() |
| beginFormalParameters((, MemberKind.NonStaticMethod) |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(x) |
| handleType(int, null) |
| handleIdentifier(x, formalParameterDeclaration) |
| handleFormalParameterWithoutValue()) |
| endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) |
| endFormalParameters(1, (, ), MemberKind.NonStaticMethod) |
| handleNoInitializers() |
| handleAsyncModifier(null, null) |
| beginBlockFunctionBody({) |
| beginIfStatement(if) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(==) |
| handleNoArguments(==) |
| handleSend(x, ==) |
| beginBinaryExpression(==) |
| handleLiteralInt(0) |
| endBinaryExpression(==) |
| handleParenthesizedCondition(() |
| beginThenStatement(return) |
| beginReturnStatement(return) |
| handleLiteralInt(42) |
| endReturnStatement(true, return, ;) |
| endThenStatement(;) |
| endIfStatement(if, null) |
| beginReturnStatement(return) |
| handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'case' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: case}], case, case) |
| handleIdentifier(case, expression) |
| handleNoTypeArguments(() |
| beginArguments(() |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(-) |
| handleNoArguments(-) |
| handleSend(x, -) |
| beginBinaryExpression(-) |
| handleLiteralInt(1) |
| endBinaryExpression(-) |
| endArguments(1, (, )) |
| handleSend(case, +) |
| beginBinaryExpression(+) |
| handleLiteralInt(1) |
| endBinaryExpression(+) |
| endReturnStatement(true, return, ;) |
| endBlockFunctionBody(2, {, }) |
| endClassMethod(null, int, (, null, }) |
| endMember() |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginMember() |
| beginMethod(null, null, null, null, null, catch) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(catch) |
| handleType(int, null) |
| handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'catch' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: catch}], catch, catch) |
| handleIdentifier(catch, methodDeclaration) |
| handleNoTypeVariables(() |
| beginFormalParameters((, MemberKind.NonStaticMethod) |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(x) |
| handleType(int, null) |
| handleIdentifier(x, formalParameterDeclaration) |
| handleFormalParameterWithoutValue()) |
| endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) |
| endFormalParameters(1, (, ), MemberKind.NonStaticMethod) |
| handleNoInitializers() |
| handleAsyncModifier(null, null) |
| beginBlockFunctionBody({) |
| beginIfStatement(if) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(==) |
| handleNoArguments(==) |
| handleSend(x, ==) |
| beginBinaryExpression(==) |
| handleLiteralInt(0) |
| endBinaryExpression(==) |
| handleParenthesizedCondition(() |
| beginThenStatement(return) |
| beginReturnStatement(return) |
| handleLiteralInt(42) |
| endReturnStatement(true, return, ;) |
| endThenStatement(;) |
| endIfStatement(if, null) |
| beginReturnStatement(return) |
| handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'catch' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: catch}], catch, catch) |
| handleIdentifier(catch, expression) |
| handleNoTypeArguments(() |
| beginArguments(() |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(-) |
| handleNoArguments(-) |
| handleSend(x, -) |
| beginBinaryExpression(-) |
| handleLiteralInt(1) |
| endBinaryExpression(-) |
| endArguments(1, (, )) |
| handleSend(catch, +) |
| beginBinaryExpression(+) |
| handleLiteralInt(1) |
| endBinaryExpression(+) |
| endReturnStatement(true, return, ;) |
| endBlockFunctionBody(2, {, }) |
| endClassMethod(null, int, (, null, }) |
| endMember() |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginMember() |
| beginMethod(null, null, null, null, null, class) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(class) |
| handleType(int, null) |
| handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'class' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: class}], class, class) |
| handleIdentifier(class, methodDeclaration) |
| handleNoTypeVariables(() |
| beginFormalParameters((, MemberKind.NonStaticMethod) |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(x) |
| handleType(int, null) |
| handleIdentifier(x, formalParameterDeclaration) |
| handleFormalParameterWithoutValue()) |
| endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) |
| endFormalParameters(1, (, ), MemberKind.NonStaticMethod) |
| handleNoInitializers() |
| handleAsyncModifier(null, null) |
| beginBlockFunctionBody({) |
| beginIfStatement(if) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(==) |
| handleNoArguments(==) |
| handleSend(x, ==) |
| beginBinaryExpression(==) |
| handleLiteralInt(0) |
| endBinaryExpression(==) |
| handleParenthesizedCondition(() |
| beginThenStatement(return) |
| beginReturnStatement(return) |
| handleLiteralInt(42) |
| endReturnStatement(true, return, ;) |
| endThenStatement(;) |
| endIfStatement(if, null) |
| beginReturnStatement(return) |
| handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'class' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: class}], class, class) |
| handleIdentifier(class, expression) |
| handleNoTypeArguments(() |
| beginArguments(() |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(-) |
| handleNoArguments(-) |
| handleSend(x, -) |
| beginBinaryExpression(-) |
| handleLiteralInt(1) |
| endBinaryExpression(-) |
| endArguments(1, (, )) |
| handleSend(class, +) |
| beginBinaryExpression(+) |
| handleLiteralInt(1) |
| endBinaryExpression(+) |
| endReturnStatement(true, return, ;) |
| endBlockFunctionBody(2, {, }) |
| endClassMethod(null, int, (, null, }) |
| endMember() |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginMember() |
| beginMethod(null, null, null, null, null, const) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(const) |
| handleType(int, null) |
| handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'const' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: const}], const, const) |
| handleIdentifier(const, methodDeclaration) |
| handleNoTypeVariables(() |
| beginFormalParameters((, MemberKind.NonStaticMethod) |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(x) |
| handleType(int, null) |
| handleIdentifier(x, formalParameterDeclaration) |
| handleFormalParameterWithoutValue()) |
| endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) |
| endFormalParameters(1, (, ), MemberKind.NonStaticMethod) |
| handleNoInitializers() |
| handleAsyncModifier(null, null) |
| beginBlockFunctionBody({) |
| beginIfStatement(if) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(==) |
| handleNoArguments(==) |
| handleSend(x, ==) |
| beginBinaryExpression(==) |
| handleLiteralInt(0) |
| endBinaryExpression(==) |
| handleParenthesizedCondition(() |
| beginThenStatement(return) |
| beginReturnStatement(return) |
| handleLiteralInt(42) |
| endReturnStatement(true, return, ;) |
| endThenStatement(;) |
| endIfStatement(if, null) |
| beginReturnStatement(return) |
| beginConstExpression(const) |
| handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., Try inserting an identifier before '('., {lexeme: (}], (, () |
| handleIdentifier(, constructorReference) |
| beginConstructorReference() |
| handleNoTypeArguments(() |
| handleNoConstructorReferenceContinuationAfterTypeArguments(() |
| endConstructorReference(, null, () |
| beginArguments(() |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(-) |
| handleNoArguments(-) |
| handleSend(x, -) |
| beginBinaryExpression(-) |
| handleLiteralInt(1) |
| endBinaryExpression(-) |
| endArguments(1, (, )) |
| endConstExpression(const) |
| beginBinaryExpression(+) |
| handleLiteralInt(1) |
| endBinaryExpression(+) |
| endReturnStatement(true, return, ;) |
| endBlockFunctionBody(2, {, }) |
| endClassMethod(null, int, (, null, }) |
| endMember() |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginMember() |
| beginMethod(null, null, null, null, null, continue) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(continue) |
| handleType(int, null) |
| handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'continue' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: continue}], continue, continue) |
| handleIdentifier(continue, methodDeclaration) |
| handleNoTypeVariables(() |
| beginFormalParameters((, MemberKind.NonStaticMethod) |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(x) |
| handleType(int, null) |
| handleIdentifier(x, formalParameterDeclaration) |
| handleFormalParameterWithoutValue()) |
| endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) |
| endFormalParameters(1, (, ), MemberKind.NonStaticMethod) |
| handleNoInitializers() |
| handleAsyncModifier(null, null) |
| beginBlockFunctionBody({) |
| beginIfStatement(if) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(==) |
| handleNoArguments(==) |
| handleSend(x, ==) |
| beginBinaryExpression(==) |
| handleLiteralInt(0) |
| endBinaryExpression(==) |
| handleParenthesizedCondition(() |
| beginThenStatement(return) |
| beginReturnStatement(return) |
| handleLiteralInt(42) |
| endReturnStatement(true, return, ;) |
| endThenStatement(;) |
| endIfStatement(if, null) |
| beginReturnStatement(return) |
| handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'continue'., Try inserting an identifier before 'continue'., {lexeme: continue}], continue, continue) |
| handleIdentifier(, expression) |
| handleNoTypeArguments(continue) |
| handleNoArguments(continue) |
| handleSend(, continue) |
| handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], continue, continue) |
| endReturnStatement(true, return, ;) |
| handleRecoverableError(ContinueOutsideOfLoop, continue, continue) |
| handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], continue, continue) |
| handleContinueStatement(false, continue, ;) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(-) |
| handleNoArguments(-) |
| handleSend(x, -) |
| beginBinaryExpression(-) |
| handleLiteralInt(1) |
| endBinaryExpression(-) |
| handleParenthesizedExpression(() |
| beginBinaryExpression(+) |
| handleLiteralInt(1) |
| endBinaryExpression(+) |
| handleExpressionStatement(;) |
| endBlockFunctionBody(4, {, }) |
| endClassMethod(null, int, (, null, }) |
| endMember() |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginMember() |
| beginMethod(null, null, null, null, null, covariant) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(covariant) |
| handleType(int, null) |
| handleIdentifier(covariant, methodDeclaration) |
| handleNoTypeVariables(() |
| beginFormalParameters((, MemberKind.NonStaticMethod) |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(x) |
| handleType(int, null) |
| handleIdentifier(x, formalParameterDeclaration) |
| handleFormalParameterWithoutValue()) |
| endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) |
| endFormalParameters(1, (, ), MemberKind.NonStaticMethod) |
| handleNoInitializers() |
| handleAsyncModifier(null, null) |
| beginBlockFunctionBody({) |
| beginIfStatement(if) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(==) |
| handleNoArguments(==) |
| handleSend(x, ==) |
| beginBinaryExpression(==) |
| handleLiteralInt(0) |
| endBinaryExpression(==) |
| handleParenthesizedCondition(() |
| beginThenStatement(return) |
| beginReturnStatement(return) |
| handleLiteralInt(42) |
| endReturnStatement(true, return, ;) |
| endThenStatement(;) |
| endIfStatement(if, null) |
| beginReturnStatement(return) |
| handleIdentifier(covariant, expression) |
| handleNoTypeArguments(() |
| beginArguments(() |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(-) |
| handleNoArguments(-) |
| handleSend(x, -) |
| beginBinaryExpression(-) |
| handleLiteralInt(1) |
| endBinaryExpression(-) |
| endArguments(1, (, )) |
| handleSend(covariant, +) |
| beginBinaryExpression(+) |
| handleLiteralInt(1) |
| endBinaryExpression(+) |
| endReturnStatement(true, return, ;) |
| endBlockFunctionBody(2, {, }) |
| endClassMethod(null, int, (, null, }) |
| endMember() |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginMember() |
| beginMethod(null, null, null, null, null, default) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(default) |
| handleType(int, null) |
| handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'default' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: default}], default, default) |
| handleIdentifier(default, methodDeclaration) |
| handleNoTypeVariables(() |
| beginFormalParameters((, MemberKind.NonStaticMethod) |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(x) |
| handleType(int, null) |
| handleIdentifier(x, formalParameterDeclaration) |
| handleFormalParameterWithoutValue()) |
| endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) |
| endFormalParameters(1, (, ), MemberKind.NonStaticMethod) |
| handleNoInitializers() |
| handleAsyncModifier(null, null) |
| beginBlockFunctionBody({) |
| beginIfStatement(if) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(==) |
| handleNoArguments(==) |
| handleSend(x, ==) |
| beginBinaryExpression(==) |
| handleLiteralInt(0) |
| endBinaryExpression(==) |
| handleParenthesizedCondition(() |
| beginThenStatement(return) |
| beginReturnStatement(return) |
| handleLiteralInt(42) |
| endReturnStatement(true, return, ;) |
| endThenStatement(;) |
| endIfStatement(if, null) |
| beginReturnStatement(return) |
| handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'default' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: default}], default, default) |
| handleIdentifier(default, expression) |
| handleNoTypeArguments(() |
| beginArguments(() |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(-) |
| handleNoArguments(-) |
| handleSend(x, -) |
| beginBinaryExpression(-) |
| handleLiteralInt(1) |
| endBinaryExpression(-) |
| endArguments(1, (, )) |
| handleSend(default, +) |
| beginBinaryExpression(+) |
| handleLiteralInt(1) |
| endBinaryExpression(+) |
| endReturnStatement(true, return, ;) |
| endBlockFunctionBody(2, {, }) |
| endClassMethod(null, int, (, null, }) |
| endMember() |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginMember() |
| beginMethod(null, null, null, null, null, deferred) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(deferred) |
| handleType(int, null) |
| handleIdentifier(deferred, methodDeclaration) |
| handleNoTypeVariables(() |
| beginFormalParameters((, MemberKind.NonStaticMethod) |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(x) |
| handleType(int, null) |
| handleIdentifier(x, formalParameterDeclaration) |
| handleFormalParameterWithoutValue()) |
| endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) |
| endFormalParameters(1, (, ), MemberKind.NonStaticMethod) |
| handleNoInitializers() |
| handleAsyncModifier(null, null) |
| beginBlockFunctionBody({) |
| beginIfStatement(if) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(==) |
| handleNoArguments(==) |
| handleSend(x, ==) |
| beginBinaryExpression(==) |
| handleLiteralInt(0) |
| endBinaryExpression(==) |
| handleParenthesizedCondition(() |
| beginThenStatement(return) |
| beginReturnStatement(return) |
| handleLiteralInt(42) |
| endReturnStatement(true, return, ;) |
| endThenStatement(;) |
| endIfStatement(if, null) |
| beginReturnStatement(return) |
| handleIdentifier(deferred, expression) |
| handleNoTypeArguments(() |
| beginArguments(() |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(-) |
| handleNoArguments(-) |
| handleSend(x, -) |
| beginBinaryExpression(-) |
| handleLiteralInt(1) |
| endBinaryExpression(-) |
| endArguments(1, (, )) |
| handleSend(deferred, +) |
| beginBinaryExpression(+) |
| handleLiteralInt(1) |
| endBinaryExpression(+) |
| endReturnStatement(true, return, ;) |
| endBlockFunctionBody(2, {, }) |
| endClassMethod(null, int, (, null, }) |
| endMember() |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginMember() |
| beginMethod(null, null, null, null, null, do) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(do) |
| handleType(int, null) |
| handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'do' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: do}], do, do) |
| handleIdentifier(do, methodDeclaration) |
| handleNoTypeVariables(() |
| beginFormalParameters((, MemberKind.NonStaticMethod) |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(x) |
| handleType(int, null) |
| handleIdentifier(x, formalParameterDeclaration) |
| handleFormalParameterWithoutValue()) |
| endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) |
| endFormalParameters(1, (, ), MemberKind.NonStaticMethod) |
| handleNoInitializers() |
| handleAsyncModifier(null, null) |
| beginBlockFunctionBody({) |
| beginIfStatement(if) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(==) |
| handleNoArguments(==) |
| handleSend(x, ==) |
| beginBinaryExpression(==) |
| handleLiteralInt(0) |
| endBinaryExpression(==) |
| handleParenthesizedCondition(() |
| beginThenStatement(return) |
| beginReturnStatement(return) |
| handleLiteralInt(42) |
| endReturnStatement(true, return, ;) |
| endThenStatement(;) |
| endIfStatement(if, null) |
| beginReturnStatement(return) |
| handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'do'., Try inserting an identifier before 'do'., {lexeme: do}], do, do) |
| handleIdentifier(, expression) |
| handleNoTypeArguments(do) |
| handleNoArguments(do) |
| handleSend(, do) |
| handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], do, do) |
| endReturnStatement(true, return, ;) |
| beginDoWhileStatement(do) |
| beginDoWhileStatementBody(() |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(-) |
| handleNoArguments(-) |
| handleSend(x, -) |
| beginBinaryExpression(-) |
| handleLiteralInt(1) |
| endBinaryExpression(-) |
| handleParenthesizedExpression(() |
| beginBinaryExpression(+) |
| handleLiteralInt(1) |
| endBinaryExpression(+) |
| handleExpressionStatement(;) |
| endDoWhileStatementBody(;) |
| handleRecoverableError(Message[ExpectedButGot, Expected 'while' before this., null, {string: while}], }, }) |
| handleRecoverableError(Message[ExpectedToken, Expected to find '('., null, {string: (}], }, }) |
| handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '}'., Try inserting an identifier before '}'., {lexeme: }}], }, }) |
| handleIdentifier(, expression) |
| handleNoTypeArguments()) |
| handleNoArguments()) |
| handleSend(, )) |
| handleParenthesizedCondition(() |
| handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], }, }) |
| endDoWhileStatement(do, while, ;) |
| endBlockFunctionBody(3, {, }) |
| endClassMethod(null, int, (, null, }) |
| endMember() |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginMember() |
| beginMethod(null, null, null, null, null, dynamic) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(dynamic) |
| handleType(int, null) |
| handleIdentifier(dynamic, methodDeclaration) |
| handleNoTypeVariables(() |
| beginFormalParameters((, MemberKind.NonStaticMethod) |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(x) |
| handleType(int, null) |
| handleIdentifier(x, formalParameterDeclaration) |
| handleFormalParameterWithoutValue()) |
| endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) |
| endFormalParameters(1, (, ), MemberKind.NonStaticMethod) |
| handleNoInitializers() |
| handleAsyncModifier(null, null) |
| beginBlockFunctionBody({) |
| beginIfStatement(if) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(==) |
| handleNoArguments(==) |
| handleSend(x, ==) |
| beginBinaryExpression(==) |
| handleLiteralInt(0) |
| endBinaryExpression(==) |
| handleParenthesizedCondition(() |
| beginThenStatement(return) |
| beginReturnStatement(return) |
| handleLiteralInt(42) |
| endReturnStatement(true, return, ;) |
| endThenStatement(;) |
| endIfStatement(if, null) |
| beginReturnStatement(return) |
| handleIdentifier(dynamic, expression) |
| handleNoTypeArguments(() |
| beginArguments(() |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(-) |
| handleNoArguments(-) |
| handleSend(x, -) |
| beginBinaryExpression(-) |
| handleLiteralInt(1) |
| endBinaryExpression(-) |
| endArguments(1, (, )) |
| handleSend(dynamic, +) |
| beginBinaryExpression(+) |
| handleLiteralInt(1) |
| endBinaryExpression(+) |
| endReturnStatement(true, return, ;) |
| endBlockFunctionBody(2, {, }) |
| endClassMethod(null, int, (, null, }) |
| endMember() |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginMember() |
| beginMethod(null, null, null, null, null, else) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(else) |
| handleType(int, null) |
| handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'else' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: else}], else, else) |
| handleIdentifier(else, methodDeclaration) |
| handleNoTypeVariables(() |
| beginFormalParameters((, MemberKind.NonStaticMethod) |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(x) |
| handleType(int, null) |
| handleIdentifier(x, formalParameterDeclaration) |
| handleFormalParameterWithoutValue()) |
| endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) |
| endFormalParameters(1, (, ), MemberKind.NonStaticMethod) |
| handleNoInitializers() |
| handleAsyncModifier(null, null) |
| beginBlockFunctionBody({) |
| beginIfStatement(if) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(==) |
| handleNoArguments(==) |
| handleSend(x, ==) |
| beginBinaryExpression(==) |
| handleLiteralInt(0) |
| endBinaryExpression(==) |
| handleParenthesizedCondition(() |
| beginThenStatement(return) |
| beginReturnStatement(return) |
| handleLiteralInt(42) |
| endReturnStatement(true, return, ;) |
| endThenStatement(;) |
| endIfStatement(if, null) |
| beginReturnStatement(return) |
| handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'else'., Try inserting an identifier before 'else'., {lexeme: else}], else, else) |
| handleIdentifier(, expression) |
| handleNoTypeArguments(else) |
| handleNoArguments(else) |
| handleSend(, else) |
| handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], else, else) |
| endReturnStatement(true, return, ;) |
| handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'else'., Try inserting an identifier before 'else'., {lexeme: else}], else, else) |
| handleIdentifier(, expression) |
| handleNoTypeArguments(else) |
| handleNoArguments(else) |
| handleSend(, else) |
| handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], else, else) |
| handleExpressionStatement(;) |
| handleRecoverableError(Message[UnexpectedToken, Unexpected token ';'., null, {lexeme: ;}], else, else) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(-) |
| handleNoArguments(-) |
| handleSend(x, -) |
| beginBinaryExpression(-) |
| handleLiteralInt(1) |
| endBinaryExpression(-) |
| handleParenthesizedExpression(() |
| beginBinaryExpression(+) |
| handleLiteralInt(1) |
| endBinaryExpression(+) |
| handleExpressionStatement(;) |
| endBlockFunctionBody(4, {, }) |
| endClassMethod(null, int, (, null, }) |
| endMember() |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginMember() |
| beginMethod(null, null, null, null, null, enum) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(enum) |
| handleType(int, null) |
| handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'enum' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: enum}], enum, enum) |
| handleIdentifier(enum, methodDeclaration) |
| handleNoTypeVariables(() |
| beginFormalParameters((, MemberKind.NonStaticMethod) |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(x) |
| handleType(int, null) |
| handleIdentifier(x, formalParameterDeclaration) |
| handleFormalParameterWithoutValue()) |
| endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) |
| endFormalParameters(1, (, ), MemberKind.NonStaticMethod) |
| handleNoInitializers() |
| handleAsyncModifier(null, null) |
| beginBlockFunctionBody({) |
| beginIfStatement(if) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(==) |
| handleNoArguments(==) |
| handleSend(x, ==) |
| beginBinaryExpression(==) |
| handleLiteralInt(0) |
| endBinaryExpression(==) |
| handleParenthesizedCondition(() |
| beginThenStatement(return) |
| beginReturnStatement(return) |
| handleLiteralInt(42) |
| endReturnStatement(true, return, ;) |
| endThenStatement(;) |
| endIfStatement(if, null) |
| beginReturnStatement(return) |
| handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'enum' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: enum}], enum, enum) |
| handleIdentifier(enum, expression) |
| handleNoTypeArguments(() |
| beginArguments(() |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(-) |
| handleNoArguments(-) |
| handleSend(x, -) |
| beginBinaryExpression(-) |
| handleLiteralInt(1) |
| endBinaryExpression(-) |
| endArguments(1, (, )) |
| handleSend(enum, +) |
| beginBinaryExpression(+) |
| handleLiteralInt(1) |
| endBinaryExpression(+) |
| endReturnStatement(true, return, ;) |
| endBlockFunctionBody(2, {, }) |
| endClassMethod(null, int, (, null, }) |
| endMember() |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginMember() |
| beginMethod(null, null, null, null, null, export) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(export) |
| handleType(int, null) |
| handleIdentifier(export, methodDeclaration) |
| handleNoTypeVariables(() |
| beginFormalParameters((, MemberKind.NonStaticMethod) |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(x) |
| handleType(int, null) |
| handleIdentifier(x, formalParameterDeclaration) |
| handleFormalParameterWithoutValue()) |
| endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) |
| endFormalParameters(1, (, ), MemberKind.NonStaticMethod) |
| handleNoInitializers() |
| handleAsyncModifier(null, null) |
| beginBlockFunctionBody({) |
| beginIfStatement(if) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(==) |
| handleNoArguments(==) |
| handleSend(x, ==) |
| beginBinaryExpression(==) |
| handleLiteralInt(0) |
| endBinaryExpression(==) |
| handleParenthesizedCondition(() |
| beginThenStatement(return) |
| beginReturnStatement(return) |
| handleLiteralInt(42) |
| endReturnStatement(true, return, ;) |
| endThenStatement(;) |
| endIfStatement(if, null) |
| beginReturnStatement(return) |
| handleIdentifier(export, expression) |
| handleNoTypeArguments(() |
| beginArguments(() |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(-) |
| handleNoArguments(-) |
| handleSend(x, -) |
| beginBinaryExpression(-) |
| handleLiteralInt(1) |
| endBinaryExpression(-) |
| endArguments(1, (, )) |
| handleSend(export, +) |
| beginBinaryExpression(+) |
| handleLiteralInt(1) |
| endBinaryExpression(+) |
| endReturnStatement(true, return, ;) |
| endBlockFunctionBody(2, {, }) |
| endClassMethod(null, int, (, null, }) |
| endMember() |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginMember() |
| beginMethod(null, null, null, null, null, extends) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(extends) |
| handleType(int, null) |
| handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'extends' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: extends}], extends, extends) |
| handleIdentifier(extends, methodDeclaration) |
| handleNoTypeVariables(() |
| beginFormalParameters((, MemberKind.NonStaticMethod) |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(x) |
| handleType(int, null) |
| handleIdentifier(x, formalParameterDeclaration) |
| handleFormalParameterWithoutValue()) |
| endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) |
| endFormalParameters(1, (, ), MemberKind.NonStaticMethod) |
| handleNoInitializers() |
| handleAsyncModifier(null, null) |
| beginBlockFunctionBody({) |
| beginIfStatement(if) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(==) |
| handleNoArguments(==) |
| handleSend(x, ==) |
| beginBinaryExpression(==) |
| handleLiteralInt(0) |
| endBinaryExpression(==) |
| handleParenthesizedCondition(() |
| beginThenStatement(return) |
| beginReturnStatement(return) |
| handleLiteralInt(42) |
| endReturnStatement(true, return, ;) |
| endThenStatement(;) |
| endIfStatement(if, null) |
| beginReturnStatement(return) |
| handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'extends' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: extends}], extends, extends) |
| handleIdentifier(extends, expression) |
| handleNoTypeArguments(() |
| beginArguments(() |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(-) |
| handleNoArguments(-) |
| handleSend(x, -) |
| beginBinaryExpression(-) |
| handleLiteralInt(1) |
| endBinaryExpression(-) |
| endArguments(1, (, )) |
| handleSend(extends, +) |
| beginBinaryExpression(+) |
| handleLiteralInt(1) |
| endBinaryExpression(+) |
| endReturnStatement(true, return, ;) |
| endBlockFunctionBody(2, {, }) |
| endClassMethod(null, int, (, null, }) |
| endMember() |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginMember() |
| beginMethod(null, null, null, null, null, extension) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(extension) |
| handleType(int, null) |
| handleIdentifier(extension, methodDeclaration) |
| handleNoTypeVariables(() |
| beginFormalParameters((, MemberKind.NonStaticMethod) |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(x) |
| handleType(int, null) |
| handleIdentifier(x, formalParameterDeclaration) |
| handleFormalParameterWithoutValue()) |
| endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) |
| endFormalParameters(1, (, ), MemberKind.NonStaticMethod) |
| handleNoInitializers() |
| handleAsyncModifier(null, null) |
| beginBlockFunctionBody({) |
| beginIfStatement(if) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(==) |
| handleNoArguments(==) |
| handleSend(x, ==) |
| beginBinaryExpression(==) |
| handleLiteralInt(0) |
| endBinaryExpression(==) |
| handleParenthesizedCondition(() |
| beginThenStatement(return) |
| beginReturnStatement(return) |
| handleLiteralInt(42) |
| endReturnStatement(true, return, ;) |
| endThenStatement(;) |
| endIfStatement(if, null) |
| beginReturnStatement(return) |
| handleIdentifier(extension, expression) |
| handleNoTypeArguments(() |
| beginArguments(() |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(-) |
| handleNoArguments(-) |
| handleSend(x, -) |
| beginBinaryExpression(-) |
| handleLiteralInt(1) |
| endBinaryExpression(-) |
| endArguments(1, (, )) |
| handleSend(extension, +) |
| beginBinaryExpression(+) |
| handleLiteralInt(1) |
| endBinaryExpression(+) |
| endReturnStatement(true, return, ;) |
| endBlockFunctionBody(2, {, }) |
| endClassMethod(null, int, (, null, }) |
| endMember() |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginMember() |
| beginMethod(null, null, null, null, null, external) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(external) |
| handleType(int, null) |
| handleIdentifier(external, methodDeclaration) |
| handleNoTypeVariables(() |
| beginFormalParameters((, MemberKind.NonStaticMethod) |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(x) |
| handleType(int, null) |
| handleIdentifier(x, formalParameterDeclaration) |
| handleFormalParameterWithoutValue()) |
| endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) |
| endFormalParameters(1, (, ), MemberKind.NonStaticMethod) |
| handleNoInitializers() |
| handleAsyncModifier(null, null) |
| beginBlockFunctionBody({) |
| beginIfStatement(if) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(==) |
| handleNoArguments(==) |
| handleSend(x, ==) |
| beginBinaryExpression(==) |
| handleLiteralInt(0) |
| endBinaryExpression(==) |
| handleParenthesizedCondition(() |
| beginThenStatement(return) |
| beginReturnStatement(return) |
| handleLiteralInt(42) |
| endReturnStatement(true, return, ;) |
| endThenStatement(;) |
| endIfStatement(if, null) |
| beginReturnStatement(return) |
| handleIdentifier(external, expression) |
| handleNoTypeArguments(() |
| beginArguments(() |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(-) |
| handleNoArguments(-) |
| handleSend(x, -) |
| beginBinaryExpression(-) |
| handleLiteralInt(1) |
| endBinaryExpression(-) |
| endArguments(1, (, )) |
| handleSend(external, +) |
| beginBinaryExpression(+) |
| handleLiteralInt(1) |
| endBinaryExpression(+) |
| endReturnStatement(true, return, ;) |
| endBlockFunctionBody(2, {, }) |
| endClassMethod(null, int, (, null, }) |
| endMember() |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginMember() |
| beginMethod(null, null, null, null, null, factory) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(factory) |
| handleType(int, null) |
| handleIdentifier(factory, methodDeclaration) |
| handleNoTypeVariables(() |
| beginFormalParameters((, MemberKind.NonStaticMethod) |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(x) |
| handleType(int, null) |
| handleIdentifier(x, formalParameterDeclaration) |
| handleFormalParameterWithoutValue()) |
| endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) |
| endFormalParameters(1, (, ), MemberKind.NonStaticMethod) |
| handleNoInitializers() |
| handleAsyncModifier(null, null) |
| beginBlockFunctionBody({) |
| beginIfStatement(if) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(==) |
| handleNoArguments(==) |
| handleSend(x, ==) |
| beginBinaryExpression(==) |
| handleLiteralInt(0) |
| endBinaryExpression(==) |
| handleParenthesizedCondition(() |
| beginThenStatement(return) |
| beginReturnStatement(return) |
| handleLiteralInt(42) |
| endReturnStatement(true, return, ;) |
| endThenStatement(;) |
| endIfStatement(if, null) |
| beginReturnStatement(return) |
| handleIdentifier(factory, expression) |
| handleNoTypeArguments(() |
| beginArguments(() |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(-) |
| handleNoArguments(-) |
| handleSend(x, -) |
| beginBinaryExpression(-) |
| handleLiteralInt(1) |
| endBinaryExpression(-) |
| endArguments(1, (, )) |
| handleSend(factory, +) |
| beginBinaryExpression(+) |
| handleLiteralInt(1) |
| endBinaryExpression(+) |
| endReturnStatement(true, return, ;) |
| endBlockFunctionBody(2, {, }) |
| endClassMethod(null, int, (, null, }) |
| endMember() |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginMember() |
| beginMethod(null, null, null, null, null, false) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(false) |
| handleType(int, null) |
| handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'false' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: false}], false, false) |
| handleIdentifier(false, methodDeclaration) |
| handleNoTypeVariables(() |
| beginFormalParameters((, MemberKind.NonStaticMethod) |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(x) |
| handleType(int, null) |
| handleIdentifier(x, formalParameterDeclaration) |
| handleFormalParameterWithoutValue()) |
| endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) |
| endFormalParameters(1, (, ), MemberKind.NonStaticMethod) |
| handleNoInitializers() |
| handleAsyncModifier(null, null) |
| beginBlockFunctionBody({) |
| beginIfStatement(if) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(==) |
| handleNoArguments(==) |
| handleSend(x, ==) |
| beginBinaryExpression(==) |
| handleLiteralInt(0) |
| endBinaryExpression(==) |
| handleParenthesizedCondition(() |
| beginThenStatement(return) |
| beginReturnStatement(return) |
| handleLiteralInt(42) |
| endReturnStatement(true, return, ;) |
| endThenStatement(;) |
| endIfStatement(if, null) |
| beginReturnStatement(return) |
| handleLiteralBool(false) |
| handleNoTypeArguments(() |
| beginArguments(() |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(-) |
| handleNoArguments(-) |
| handleSend(x, -) |
| beginBinaryExpression(-) |
| handleLiteralInt(1) |
| endBinaryExpression(-) |
| endArguments(1, (, )) |
| handleSend((, )) |
| beginBinaryExpression(+) |
| handleLiteralInt(1) |
| endBinaryExpression(+) |
| endReturnStatement(true, return, ;) |
| endBlockFunctionBody(2, {, }) |
| endClassMethod(null, int, (, null, }) |
| endMember() |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginMember() |
| beginMethod(null, null, null, null, null, final) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(final) |
| handleType(int, null) |
| handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'final' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: final}], final, final) |
| handleIdentifier(final, methodDeclaration) |
| handleNoTypeVariables(() |
| beginFormalParameters((, MemberKind.NonStaticMethod) |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(x) |
| handleType(int, null) |
| handleIdentifier(x, formalParameterDeclaration) |
| handleFormalParameterWithoutValue()) |
| endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) |
| endFormalParameters(1, (, ), MemberKind.NonStaticMethod) |
| handleNoInitializers() |
| handleAsyncModifier(null, null) |
| beginBlockFunctionBody({) |
| beginIfStatement(if) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(==) |
| handleNoArguments(==) |
| handleSend(x, ==) |
| beginBinaryExpression(==) |
| handleLiteralInt(0) |
| endBinaryExpression(==) |
| handleParenthesizedCondition(() |
| beginThenStatement(return) |
| beginReturnStatement(return) |
| handleLiteralInt(42) |
| endReturnStatement(true, return, ;) |
| endThenStatement(;) |
| endIfStatement(if, null) |
| beginReturnStatement(return) |
| handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'final'., Try inserting an identifier before 'final'., {lexeme: final}], final, final) |
| handleIdentifier(, expression) |
| handleNoTypeArguments(final) |
| handleNoArguments(final) |
| handleSend(, final) |
| handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], final, final) |
| endReturnStatement(true, return, ;) |
| beginMetadataStar(final) |
| endMetadataStar(0) |
| handleNoType(final) |
| beginVariablesDeclaration((, null, final) |
| handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., Try inserting an identifier before '('., {lexeme: (}], (, () |
| handleIdentifier(, localVariableDeclaration) |
| beginInitializedIdentifier() |
| handleNoVariableInitializer() |
| endInitializedIdentifier() |
| handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], x, x) |
| endVariablesDeclaration(1, ;) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(-) |
| handleNoArguments(-) |
| handleSend(x, -) |
| beginBinaryExpression(-) |
| handleLiteralInt(1) |
| endBinaryExpression(-) |
| handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], 1, 1) |
| handleExpressionStatement(;) |
| handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ')'., Try inserting an identifier before ')'., {lexeme: )}], ), )) |
| handleIdentifier(, expression) |
| handleNoTypeArguments()) |
| handleNoArguments()) |
| handleSend(, )) |
| handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], ), )) |
| handleExpressionStatement(;) |
| handleRecoverableError(Message[UnexpectedToken, Unexpected token ';'., null, {lexeme: ;}], ), )) |
| handleRecoverableError(UnsupportedPrefixPlus, +, +) |
| handleIdentifier(, expression) |
| handleNoTypeArguments(+) |
| handleNoArguments(+) |
| handleSend(, +) |
| beginBinaryExpression(+) |
| handleLiteralInt(1) |
| endBinaryExpression(+) |
| handleExpressionStatement(;) |
| endBlockFunctionBody(6, {, }) |
| endClassMethod(null, int, (, null, }) |
| endMember() |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginMember() |
| beginMethod(null, null, null, null, null, finally) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(finally) |
| handleType(int, null) |
| handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'finally' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: finally}], finally, finally) |
| handleIdentifier(finally, methodDeclaration) |
| handleNoTypeVariables(() |
| beginFormalParameters((, MemberKind.NonStaticMethod) |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(x) |
| handleType(int, null) |
| handleIdentifier(x, formalParameterDeclaration) |
| handleFormalParameterWithoutValue()) |
| endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) |
| endFormalParameters(1, (, ), MemberKind.NonStaticMethod) |
| handleNoInitializers() |
| handleAsyncModifier(null, null) |
| beginBlockFunctionBody({) |
| beginIfStatement(if) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(==) |
| handleNoArguments(==) |
| handleSend(x, ==) |
| beginBinaryExpression(==) |
| handleLiteralInt(0) |
| endBinaryExpression(==) |
| handleParenthesizedCondition(() |
| beginThenStatement(return) |
| beginReturnStatement(return) |
| handleLiteralInt(42) |
| endReturnStatement(true, return, ;) |
| endThenStatement(;) |
| endIfStatement(if, null) |
| beginReturnStatement(return) |
| handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'finally' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: finally}], finally, finally) |
| handleIdentifier(finally, expression) |
| handleNoTypeArguments(() |
| beginArguments(() |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(-) |
| handleNoArguments(-) |
| handleSend(x, -) |
| beginBinaryExpression(-) |
| handleLiteralInt(1) |
| endBinaryExpression(-) |
| endArguments(1, (, )) |
| handleSend(finally, +) |
| beginBinaryExpression(+) |
| handleLiteralInt(1) |
| endBinaryExpression(+) |
| endReturnStatement(true, return, ;) |
| endBlockFunctionBody(2, {, }) |
| endClassMethod(null, int, (, null, }) |
| endMember() |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginMember() |
| beginMethod(null, null, null, null, null, for) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(for) |
| handleType(int, null) |
| handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'for' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: for}], for, for) |
| handleIdentifier(for, methodDeclaration) |
| handleNoTypeVariables(() |
| beginFormalParameters((, MemberKind.NonStaticMethod) |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(x) |
| handleType(int, null) |
| handleIdentifier(x, formalParameterDeclaration) |
| handleFormalParameterWithoutValue()) |
| endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) |
| endFormalParameters(1, (, ), MemberKind.NonStaticMethod) |
| handleNoInitializers() |
| handleAsyncModifier(null, null) |
| beginBlockFunctionBody({) |
| beginIfStatement(if) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(==) |
| handleNoArguments(==) |
| handleSend(x, ==) |
| beginBinaryExpression(==) |
| handleLiteralInt(0) |
| endBinaryExpression(==) |
| handleParenthesizedCondition(() |
| beginThenStatement(return) |
| beginReturnStatement(return) |
| handleLiteralInt(42) |
| endReturnStatement(true, return, ;) |
| endThenStatement(;) |
| endIfStatement(if, null) |
| beginReturnStatement(return) |
| handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'for'., Try inserting an identifier before 'for'., {lexeme: for}], for, for) |
| handleIdentifier(, expression) |
| handleNoTypeArguments(for) |
| handleNoArguments(for) |
| handleSend(, for) |
| handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], for, for) |
| endReturnStatement(true, return, ;) |
| beginForStatement(for) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(-) |
| handleNoArguments(-) |
| handleSend(x, -) |
| beginBinaryExpression(-) |
| handleLiteralInt(1) |
| endBinaryExpression(-) |
| handleForInitializerExpressionStatement(1, false) |
| handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], 1, 1) |
| handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ')'., Try inserting an identifier before ')'., {lexeme: )}], ), )) |
| handleIdentifier(, expression) |
| handleNoTypeArguments()) |
| handleNoArguments()) |
| handleSend(, )) |
| handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], ), )) |
| handleExpressionStatement(;) |
| handleForLoopParts(for, (, ;, 0) |
| beginForStatementBody(+) |
| handleRecoverableError(UnsupportedPrefixPlus, +, +) |
| handleIdentifier(, expression) |
| handleNoTypeArguments(+) |
| handleNoArguments(+) |
| handleSend(, +) |
| beginBinaryExpression(+) |
| handleLiteralInt(1) |
| endBinaryExpression(+) |
| handleExpressionStatement(;) |
| endForStatementBody(}) |
| endForStatement(}) |
| endBlockFunctionBody(3, {, }) |
| endClassMethod(null, int, (, null, }) |
| endMember() |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginMember() |
| beginMethod(null, null, null, null, null, Function) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(Function) |
| handleType(int, null) |
| handleIdentifier(Function, methodDeclaration) |
| handleNoTypeVariables(() |
| beginFormalParameters((, MemberKind.NonStaticMethod) |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(x) |
| handleType(int, null) |
| handleIdentifier(x, formalParameterDeclaration) |
| handleFormalParameterWithoutValue()) |
| endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) |
| endFormalParameters(1, (, ), MemberKind.NonStaticMethod) |
| handleNoInitializers() |
| handleAsyncModifier(null, null) |
| beginBlockFunctionBody({) |
| beginIfStatement(if) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(==) |
| handleNoArguments(==) |
| handleSend(x, ==) |
| beginBinaryExpression(==) |
| handleLiteralInt(0) |
| endBinaryExpression(==) |
| handleParenthesizedCondition(() |
| beginThenStatement(return) |
| beginReturnStatement(return) |
| handleLiteralInt(42) |
| endReturnStatement(true, return, ;) |
| endThenStatement(;) |
| endIfStatement(if, null) |
| beginReturnStatement(return) |
| handleIdentifier(Function, expression) |
| handleNoTypeArguments(() |
| beginArguments(() |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(-) |
| handleNoArguments(-) |
| handleSend(x, -) |
| beginBinaryExpression(-) |
| handleLiteralInt(1) |
| endBinaryExpression(-) |
| endArguments(1, (, )) |
| handleSend(Function, +) |
| beginBinaryExpression(+) |
| handleLiteralInt(1) |
| endBinaryExpression(+) |
| endReturnStatement(true, return, ;) |
| endBlockFunctionBody(2, {, }) |
| endClassMethod(null, int, (, null, }) |
| endMember() |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginMember() |
| beginMethod(null, null, null, null, null, get) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(get) |
| handleType(int, null) |
| handleIdentifier(get, methodDeclaration) |
| handleNoTypeVariables(() |
| beginFormalParameters((, MemberKind.NonStaticMethod) |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(x) |
| handleType(int, null) |
| handleIdentifier(x, formalParameterDeclaration) |
| handleFormalParameterWithoutValue()) |
| endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) |
| endFormalParameters(1, (, ), MemberKind.NonStaticMethod) |
| handleNoInitializers() |
| handleAsyncModifier(null, null) |
| beginBlockFunctionBody({) |
| beginIfStatement(if) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(==) |
| handleNoArguments(==) |
| handleSend(x, ==) |
| beginBinaryExpression(==) |
| handleLiteralInt(0) |
| endBinaryExpression(==) |
| handleParenthesizedCondition(() |
| beginThenStatement(return) |
| beginReturnStatement(return) |
| handleLiteralInt(42) |
| endReturnStatement(true, return, ;) |
| endThenStatement(;) |
| endIfStatement(if, null) |
| beginReturnStatement(return) |
| handleIdentifier(get, expression) |
| handleNoTypeArguments(() |
| beginArguments(() |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(-) |
| handleNoArguments(-) |
| handleSend(x, -) |
| beginBinaryExpression(-) |
| handleLiteralInt(1) |
| endBinaryExpression(-) |
| endArguments(1, (, )) |
| handleSend(get, +) |
| beginBinaryExpression(+) |
| handleLiteralInt(1) |
| endBinaryExpression(+) |
| endReturnStatement(true, return, ;) |
| endBlockFunctionBody(2, {, }) |
| endClassMethod(null, int, (, null, }) |
| endMember() |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginMember() |
| beginMethod(null, null, null, null, null, hide) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(hide) |
| handleType(int, null) |
| handleIdentifier(hide, methodDeclaration) |
| handleNoTypeVariables(() |
| beginFormalParameters((, MemberKind.NonStaticMethod) |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(x) |
| handleType(int, null) |
| handleIdentifier(x, formalParameterDeclaration) |
| handleFormalParameterWithoutValue()) |
| endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) |
| endFormalParameters(1, (, ), MemberKind.NonStaticMethod) |
| handleNoInitializers() |
| handleAsyncModifier(null, null) |
| beginBlockFunctionBody({) |
| beginIfStatement(if) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(==) |
| handleNoArguments(==) |
| handleSend(x, ==) |
| beginBinaryExpression(==) |
| handleLiteralInt(0) |
| endBinaryExpression(==) |
| handleParenthesizedCondition(() |
| beginThenStatement(return) |
| beginReturnStatement(return) |
| handleLiteralInt(42) |
| endReturnStatement(true, return, ;) |
| endThenStatement(;) |
| endIfStatement(if, null) |
| beginReturnStatement(return) |
| handleIdentifier(hide, expression) |
| handleNoTypeArguments(() |
| beginArguments(() |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(-) |
| handleNoArguments(-) |
| handleSend(x, -) |
| beginBinaryExpression(-) |
| handleLiteralInt(1) |
| endBinaryExpression(-) |
| endArguments(1, (, )) |
| handleSend(hide, +) |
| beginBinaryExpression(+) |
| handleLiteralInt(1) |
| endBinaryExpression(+) |
| endReturnStatement(true, return, ;) |
| endBlockFunctionBody(2, {, }) |
| endClassMethod(null, int, (, null, }) |
| endMember() |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginMember() |
| beginMethod(null, null, null, null, null, if) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(if) |
| handleType(int, null) |
| handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'if' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: if}], if, if) |
| handleIdentifier(if, methodDeclaration) |
| handleNoTypeVariables(() |
| beginFormalParameters((, MemberKind.NonStaticMethod) |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(x) |
| handleType(int, null) |
| handleIdentifier(x, formalParameterDeclaration) |
| handleFormalParameterWithoutValue()) |
| endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) |
| endFormalParameters(1, (, ), MemberKind.NonStaticMethod) |
| handleNoInitializers() |
| handleAsyncModifier(null, null) |
| beginBlockFunctionBody({) |
| beginIfStatement(if) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(==) |
| handleNoArguments(==) |
| handleSend(x, ==) |
| beginBinaryExpression(==) |
| handleLiteralInt(0) |
| endBinaryExpression(==) |
| handleParenthesizedCondition(() |
| beginThenStatement(return) |
| beginReturnStatement(return) |
| handleLiteralInt(42) |
| endReturnStatement(true, return, ;) |
| endThenStatement(;) |
| endIfStatement(if, null) |
| beginReturnStatement(return) |
| handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'if'., Try inserting an identifier before 'if'., {lexeme: if}], if, if) |
| handleIdentifier(, expression) |
| handleNoTypeArguments(if) |
| handleNoArguments(if) |
| handleSend(, if) |
| handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], if, if) |
| endReturnStatement(true, return, ;) |
| beginIfStatement(if) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(-) |
| handleNoArguments(-) |
| handleSend(x, -) |
| beginBinaryExpression(-) |
| handleLiteralInt(1) |
| endBinaryExpression(-) |
| handleParenthesizedCondition(() |
| beginThenStatement(+) |
| handleRecoverableError(UnsupportedPrefixPlus, +, +) |
| handleIdentifier(, expression) |
| handleNoTypeArguments(+) |
| handleNoArguments(+) |
| handleSend(, +) |
| beginBinaryExpression(+) |
| handleLiteralInt(1) |
| endBinaryExpression(+) |
| handleExpressionStatement(;) |
| endThenStatement(;) |
| endIfStatement(if, null) |
| endBlockFunctionBody(3, {, }) |
| endClassMethod(null, int, (, null, }) |
| endMember() |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginMember() |
| beginMethod(null, null, null, null, null, implements) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(implements) |
| handleType(int, null) |
| handleIdentifier(implements, methodDeclaration) |
| handleNoTypeVariables(() |
| beginFormalParameters((, MemberKind.NonStaticMethod) |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(x) |
| handleType(int, null) |
| handleIdentifier(x, formalParameterDeclaration) |
| handleFormalParameterWithoutValue()) |
| endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) |
| endFormalParameters(1, (, ), MemberKind.NonStaticMethod) |
| handleNoInitializers() |
| handleAsyncModifier(null, null) |
| beginBlockFunctionBody({) |
| beginIfStatement(if) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(==) |
| handleNoArguments(==) |
| handleSend(x, ==) |
| beginBinaryExpression(==) |
| handleLiteralInt(0) |
| endBinaryExpression(==) |
| handleParenthesizedCondition(() |
| beginThenStatement(return) |
| beginReturnStatement(return) |
| handleLiteralInt(42) |
| endReturnStatement(true, return, ;) |
| endThenStatement(;) |
| endIfStatement(if, null) |
| beginReturnStatement(return) |
| handleIdentifier(implements, expression) |
| handleNoTypeArguments(() |
| beginArguments(() |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(-) |
| handleNoArguments(-) |
| handleSend(x, -) |
| beginBinaryExpression(-) |
| handleLiteralInt(1) |
| endBinaryExpression(-) |
| endArguments(1, (, )) |
| handleSend(implements, +) |
| beginBinaryExpression(+) |
| handleLiteralInt(1) |
| endBinaryExpression(+) |
| endReturnStatement(true, return, ;) |
| endBlockFunctionBody(2, {, }) |
| endClassMethod(null, int, (, null, }) |
| endMember() |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginMember() |
| beginMethod(null, null, null, null, null, import) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(import) |
| handleType(int, null) |
| handleIdentifier(import, methodDeclaration) |
| handleNoTypeVariables(() |
| beginFormalParameters((, MemberKind.NonStaticMethod) |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(x) |
| handleType(int, null) |
| handleIdentifier(x, formalParameterDeclaration) |
| handleFormalParameterWithoutValue()) |
| endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) |
| endFormalParameters(1, (, ), MemberKind.NonStaticMethod) |
| handleNoInitializers() |
| handleAsyncModifier(null, null) |
| beginBlockFunctionBody({) |
| beginIfStatement(if) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(==) |
| handleNoArguments(==) |
| handleSend(x, ==) |
| beginBinaryExpression(==) |
| handleLiteralInt(0) |
| endBinaryExpression(==) |
| handleParenthesizedCondition(() |
| beginThenStatement(return) |
| beginReturnStatement(return) |
| handleLiteralInt(42) |
| endReturnStatement(true, return, ;) |
| endThenStatement(;) |
| endIfStatement(if, null) |
| beginReturnStatement(return) |
| handleIdentifier(import, expression) |
| handleNoTypeArguments(() |
| beginArguments(() |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(-) |
| handleNoArguments(-) |
| handleSend(x, -) |
| beginBinaryExpression(-) |
| handleLiteralInt(1) |
| endBinaryExpression(-) |
| endArguments(1, (, )) |
| handleSend(import, +) |
| beginBinaryExpression(+) |
| handleLiteralInt(1) |
| endBinaryExpression(+) |
| endReturnStatement(true, return, ;) |
| endBlockFunctionBody(2, {, }) |
| endClassMethod(null, int, (, null, }) |
| endMember() |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginMember() |
| beginMethod(null, null, null, null, null, in) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(in) |
| handleType(int, null) |
| handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'in' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: in}], in, in) |
| handleIdentifier(in, methodDeclaration) |
| handleNoTypeVariables(() |
| beginFormalParameters((, MemberKind.NonStaticMethod) |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(x) |
| handleType(int, null) |
| handleIdentifier(x, formalParameterDeclaration) |
| handleFormalParameterWithoutValue()) |
| endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) |
| endFormalParameters(1, (, ), MemberKind.NonStaticMethod) |
| handleNoInitializers() |
| handleAsyncModifier(null, null) |
| beginBlockFunctionBody({) |
| beginIfStatement(if) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(==) |
| handleNoArguments(==) |
| handleSend(x, ==) |
| beginBinaryExpression(==) |
| handleLiteralInt(0) |
| endBinaryExpression(==) |
| handleParenthesizedCondition(() |
| beginThenStatement(return) |
| beginReturnStatement(return) |
| handleLiteralInt(42) |
| endReturnStatement(true, return, ;) |
| endThenStatement(;) |
| endIfStatement(if, null) |
| beginReturnStatement(return) |
| handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'in' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: in}], in, in) |
| handleIdentifier(in, expression) |
| handleNoTypeArguments(() |
| beginArguments(() |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(-) |
| handleNoArguments(-) |
| handleSend(x, -) |
| beginBinaryExpression(-) |
| handleLiteralInt(1) |
| endBinaryExpression(-) |
| endArguments(1, (, )) |
| handleSend(in, +) |
| beginBinaryExpression(+) |
| handleLiteralInt(1) |
| endBinaryExpression(+) |
| endReturnStatement(true, return, ;) |
| endBlockFunctionBody(2, {, }) |
| endClassMethod(null, int, (, null, }) |
| endMember() |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginMember() |
| beginMethod(null, null, null, null, null, inout) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(inout) |
| handleType(int, null) |
| handleIdentifier(inout, methodDeclaration) |
| handleNoTypeVariables(() |
| beginFormalParameters((, MemberKind.NonStaticMethod) |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(x) |
| handleType(int, null) |
| handleIdentifier(x, formalParameterDeclaration) |
| handleFormalParameterWithoutValue()) |
| endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) |
| endFormalParameters(1, (, ), MemberKind.NonStaticMethod) |
| handleNoInitializers() |
| handleAsyncModifier(null, null) |
| beginBlockFunctionBody({) |
| beginIfStatement(if) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(==) |
| handleNoArguments(==) |
| handleSend(x, ==) |
| beginBinaryExpression(==) |
| handleLiteralInt(0) |
| endBinaryExpression(==) |
| handleParenthesizedCondition(() |
| beginThenStatement(return) |
| beginReturnStatement(return) |
| handleLiteralInt(42) |
| endReturnStatement(true, return, ;) |
| endThenStatement(;) |
| endIfStatement(if, null) |
| beginReturnStatement(return) |
| handleIdentifier(inout, expression) |
| handleNoTypeArguments(() |
| beginArguments(() |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(-) |
| handleNoArguments(-) |
| handleSend(x, -) |
| beginBinaryExpression(-) |
| handleLiteralInt(1) |
| endBinaryExpression(-) |
| endArguments(1, (, )) |
| handleSend(inout, +) |
| beginBinaryExpression(+) |
| handleLiteralInt(1) |
| endBinaryExpression(+) |
| endReturnStatement(true, return, ;) |
| endBlockFunctionBody(2, {, }) |
| endClassMethod(null, int, (, null, }) |
| endMember() |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginMember() |
| beginMethod(null, null, null, null, null, interface) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(interface) |
| handleType(int, null) |
| handleIdentifier(interface, methodDeclaration) |
| handleNoTypeVariables(() |
| beginFormalParameters((, MemberKind.NonStaticMethod) |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(x) |
| handleType(int, null) |
| handleIdentifier(x, formalParameterDeclaration) |
| handleFormalParameterWithoutValue()) |
| endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) |
| endFormalParameters(1, (, ), MemberKind.NonStaticMethod) |
| handleNoInitializers() |
| handleAsyncModifier(null, null) |
| beginBlockFunctionBody({) |
| beginIfStatement(if) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(==) |
| handleNoArguments(==) |
| handleSend(x, ==) |
| beginBinaryExpression(==) |
| handleLiteralInt(0) |
| endBinaryExpression(==) |
| handleParenthesizedCondition(() |
| beginThenStatement(return) |
| beginReturnStatement(return) |
| handleLiteralInt(42) |
| endReturnStatement(true, return, ;) |
| endThenStatement(;) |
| endIfStatement(if, null) |
| beginReturnStatement(return) |
| handleIdentifier(interface, expression) |
| handleNoTypeArguments(() |
| beginArguments(() |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(-) |
| handleNoArguments(-) |
| handleSend(x, -) |
| beginBinaryExpression(-) |
| handleLiteralInt(1) |
| endBinaryExpression(-) |
| endArguments(1, (, )) |
| handleSend(interface, +) |
| beginBinaryExpression(+) |
| handleLiteralInt(1) |
| endBinaryExpression(+) |
| endReturnStatement(true, return, ;) |
| endBlockFunctionBody(2, {, }) |
| endClassMethod(null, int, (, null, }) |
| endMember() |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginMember() |
| beginMethod(null, null, null, null, null, is) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(is) |
| handleType(int, null) |
| handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'is' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: is}], is, is) |
| handleIdentifier(is, methodDeclaration) |
| handleNoTypeVariables(() |
| beginFormalParameters((, MemberKind.NonStaticMethod) |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(x) |
| handleType(int, null) |
| handleIdentifier(x, formalParameterDeclaration) |
| handleFormalParameterWithoutValue()) |
| endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) |
| endFormalParameters(1, (, ), MemberKind.NonStaticMethod) |
| handleNoInitializers() |
| handleAsyncModifier(null, null) |
| beginBlockFunctionBody({) |
| beginIfStatement(if) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(==) |
| handleNoArguments(==) |
| handleSend(x, ==) |
| beginBinaryExpression(==) |
| handleLiteralInt(0) |
| endBinaryExpression(==) |
| handleParenthesizedCondition(() |
| beginThenStatement(return) |
| beginReturnStatement(return) |
| handleLiteralInt(42) |
| endReturnStatement(true, return, ;) |
| endThenStatement(;) |
| endIfStatement(if, null) |
| beginReturnStatement(return) |
| handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'is'., Try inserting an identifier before 'is'., {lexeme: is}], is, is) |
| handleIdentifier(, expression) |
| handleNoTypeArguments(is) |
| handleNoArguments(is) |
| handleSend(, is) |
| beginIsOperatorType(is) |
| handleRecoverableError(Message[ExpectedType, Expected a type, but got '('., null, {lexeme: (}], (, () |
| handleIdentifier(, typeReference) |
| handleNoTypeArguments(() |
| handleType(, null) |
| endIsOperatorType(is) |
| handleIsOperator(is, null) |
| handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], (, () |
| endReturnStatement(true, return, ;) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(-) |
| handleNoArguments(-) |
| handleSend(x, -) |
| beginBinaryExpression(-) |
| handleLiteralInt(1) |
| endBinaryExpression(-) |
| handleParenthesizedExpression(() |
| beginBinaryExpression(+) |
| handleLiteralInt(1) |
| endBinaryExpression(+) |
| handleExpressionStatement(;) |
| endBlockFunctionBody(3, {, }) |
| endClassMethod(null, int, (, null, }) |
| endMember() |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginMember() |
| beginMethod(null, null, null, null, null, late) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(late) |
| handleType(int, null) |
| handleIdentifier(late, methodDeclaration) |
| handleNoTypeVariables(() |
| beginFormalParameters((, MemberKind.NonStaticMethod) |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(x) |
| handleType(int, null) |
| handleIdentifier(x, formalParameterDeclaration) |
| handleFormalParameterWithoutValue()) |
| endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) |
| endFormalParameters(1, (, ), MemberKind.NonStaticMethod) |
| handleNoInitializers() |
| handleAsyncModifier(null, null) |
| beginBlockFunctionBody({) |
| beginIfStatement(if) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(==) |
| handleNoArguments(==) |
| handleSend(x, ==) |
| beginBinaryExpression(==) |
| handleLiteralInt(0) |
| endBinaryExpression(==) |
| handleParenthesizedCondition(() |
| beginThenStatement(return) |
| beginReturnStatement(return) |
| handleLiteralInt(42) |
| endReturnStatement(true, return, ;) |
| endThenStatement(;) |
| endIfStatement(if, null) |
| beginReturnStatement(return) |
| handleIdentifier(late, expression) |
| handleNoTypeArguments(() |
| beginArguments(() |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(-) |
| handleNoArguments(-) |
| handleSend(x, -) |
| beginBinaryExpression(-) |
| handleLiteralInt(1) |
| endBinaryExpression(-) |
| endArguments(1, (, )) |
| handleSend(late, +) |
| beginBinaryExpression(+) |
| handleLiteralInt(1) |
| endBinaryExpression(+) |
| endReturnStatement(true, return, ;) |
| endBlockFunctionBody(2, {, }) |
| endClassMethod(null, int, (, null, }) |
| endMember() |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginMember() |
| beginMethod(null, null, null, null, null, library) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(library) |
| handleType(int, null) |
| handleIdentifier(library, methodDeclaration) |
| handleNoTypeVariables(() |
| beginFormalParameters((, MemberKind.NonStaticMethod) |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(x) |
| handleType(int, null) |
| handleIdentifier(x, formalParameterDeclaration) |
| handleFormalParameterWithoutValue()) |
| endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) |
| endFormalParameters(1, (, ), MemberKind.NonStaticMethod) |
| handleNoInitializers() |
| handleAsyncModifier(null, null) |
| beginBlockFunctionBody({) |
| beginIfStatement(if) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(==) |
| handleNoArguments(==) |
| handleSend(x, ==) |
| beginBinaryExpression(==) |
| handleLiteralInt(0) |
| endBinaryExpression(==) |
| handleParenthesizedCondition(() |
| beginThenStatement(return) |
| beginReturnStatement(return) |
| handleLiteralInt(42) |
| endReturnStatement(true, return, ;) |
| endThenStatement(;) |
| endIfStatement(if, null) |
| beginReturnStatement(return) |
| handleIdentifier(library, expression) |
| handleNoTypeArguments(() |
| beginArguments(() |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(-) |
| handleNoArguments(-) |
| handleSend(x, -) |
| beginBinaryExpression(-) |
| handleLiteralInt(1) |
| endBinaryExpression(-) |
| endArguments(1, (, )) |
| handleSend(library, +) |
| beginBinaryExpression(+) |
| handleLiteralInt(1) |
| endBinaryExpression(+) |
| endReturnStatement(true, return, ;) |
| endBlockFunctionBody(2, {, }) |
| endClassMethod(null, int, (, null, }) |
| endMember() |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginMember() |
| beginMethod(null, null, null, null, null, mixin) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(mixin) |
| handleType(int, null) |
| handleIdentifier(mixin, methodDeclaration) |
| handleNoTypeVariables(() |
| beginFormalParameters((, MemberKind.NonStaticMethod) |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(x) |
| handleType(int, null) |
| handleIdentifier(x, formalParameterDeclaration) |
| handleFormalParameterWithoutValue()) |
| endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) |
| endFormalParameters(1, (, ), MemberKind.NonStaticMethod) |
| handleNoInitializers() |
| handleAsyncModifier(null, null) |
| beginBlockFunctionBody({) |
| beginIfStatement(if) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(==) |
| handleNoArguments(==) |
| handleSend(x, ==) |
| beginBinaryExpression(==) |
| handleLiteralInt(0) |
| endBinaryExpression(==) |
| handleParenthesizedCondition(() |
| beginThenStatement(return) |
| beginReturnStatement(return) |
| handleLiteralInt(42) |
| endReturnStatement(true, return, ;) |
| endThenStatement(;) |
| endIfStatement(if, null) |
| beginReturnStatement(return) |
| handleIdentifier(mixin, expression) |
| handleNoTypeArguments(() |
| beginArguments(() |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(-) |
| handleNoArguments(-) |
| handleSend(x, -) |
| beginBinaryExpression(-) |
| handleLiteralInt(1) |
| endBinaryExpression(-) |
| endArguments(1, (, )) |
| handleSend(mixin, +) |
| beginBinaryExpression(+) |
| handleLiteralInt(1) |
| endBinaryExpression(+) |
| endReturnStatement(true, return, ;) |
| endBlockFunctionBody(2, {, }) |
| endClassMethod(null, int, (, null, }) |
| endMember() |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginMember() |
| beginMethod(null, null, null, null, null, native) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(native) |
| handleType(int, null) |
| handleIdentifier(native, methodDeclaration) |
| handleNoTypeVariables(() |
| beginFormalParameters((, MemberKind.NonStaticMethod) |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(x) |
| handleType(int, null) |
| handleIdentifier(x, formalParameterDeclaration) |
| handleFormalParameterWithoutValue()) |
| endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) |
| endFormalParameters(1, (, ), MemberKind.NonStaticMethod) |
| handleNoInitializers() |
| handleAsyncModifier(null, null) |
| beginBlockFunctionBody({) |
| beginIfStatement(if) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(==) |
| handleNoArguments(==) |
| handleSend(x, ==) |
| beginBinaryExpression(==) |
| handleLiteralInt(0) |
| endBinaryExpression(==) |
| handleParenthesizedCondition(() |
| beginThenStatement(return) |
| beginReturnStatement(return) |
| handleLiteralInt(42) |
| endReturnStatement(true, return, ;) |
| endThenStatement(;) |
| endIfStatement(if, null) |
| beginReturnStatement(return) |
| handleIdentifier(native, expression) |
| handleNoTypeArguments(() |
| beginArguments(() |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(-) |
| handleNoArguments(-) |
| handleSend(x, -) |
| beginBinaryExpression(-) |
| handleLiteralInt(1) |
| endBinaryExpression(-) |
| endArguments(1, (, )) |
| handleSend(native, +) |
| beginBinaryExpression(+) |
| handleLiteralInt(1) |
| endBinaryExpression(+) |
| endReturnStatement(true, return, ;) |
| endBlockFunctionBody(2, {, }) |
| endClassMethod(null, int, (, null, }) |
| endMember() |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginMember() |
| beginMethod(null, null, null, null, null, new) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(new) |
| handleType(int, null) |
| handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'new' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: new}], new, new) |
| handleIdentifier(new, methodDeclaration) |
| handleNoTypeVariables(() |
| beginFormalParameters((, MemberKind.NonStaticMethod) |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(x) |
| handleType(int, null) |
| handleIdentifier(x, formalParameterDeclaration) |
| handleFormalParameterWithoutValue()) |
| endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) |
| endFormalParameters(1, (, ), MemberKind.NonStaticMethod) |
| handleNoInitializers() |
| handleAsyncModifier(null, null) |
| beginBlockFunctionBody({) |
| beginIfStatement(if) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(==) |
| handleNoArguments(==) |
| handleSend(x, ==) |
| beginBinaryExpression(==) |
| handleLiteralInt(0) |
| endBinaryExpression(==) |
| handleParenthesizedCondition(() |
| beginThenStatement(return) |
| beginReturnStatement(return) |
| handleLiteralInt(42) |
| endReturnStatement(true, return, ;) |
| endThenStatement(;) |
| endIfStatement(if, null) |
| beginReturnStatement(return) |
| beginNewExpression(new) |
| handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '('., Try inserting an identifier before '('., {lexeme: (}], (, () |
| handleIdentifier(, constructorReference) |
| beginConstructorReference() |
| handleNoTypeArguments(() |
| handleNoConstructorReferenceContinuationAfterTypeArguments(() |
| endConstructorReference(, null, () |
| beginArguments(() |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(-) |
| handleNoArguments(-) |
| handleSend(x, -) |
| beginBinaryExpression(-) |
| handleLiteralInt(1) |
| endBinaryExpression(-) |
| endArguments(1, (, )) |
| endNewExpression(new) |
| beginBinaryExpression(+) |
| handleLiteralInt(1) |
| endBinaryExpression(+) |
| endReturnStatement(true, return, ;) |
| endBlockFunctionBody(2, {, }) |
| endClassMethod(null, int, (, null, }) |
| endMember() |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginMember() |
| beginMethod(null, null, null, null, null, null) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(null) |
| handleType(int, null) |
| handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'null' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: null}], null, null) |
| handleIdentifier(null, methodDeclaration) |
| handleNoTypeVariables(() |
| beginFormalParameters((, MemberKind.NonStaticMethod) |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(x) |
| handleType(int, null) |
| handleIdentifier(x, formalParameterDeclaration) |
| handleFormalParameterWithoutValue()) |
| endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) |
| endFormalParameters(1, (, ), MemberKind.NonStaticMethod) |
| handleNoInitializers() |
| handleAsyncModifier(null, null) |
| beginBlockFunctionBody({) |
| beginIfStatement(if) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(==) |
| handleNoArguments(==) |
| handleSend(x, ==) |
| beginBinaryExpression(==) |
| handleLiteralInt(0) |
| endBinaryExpression(==) |
| handleParenthesizedCondition(() |
| beginThenStatement(return) |
| beginReturnStatement(return) |
| handleLiteralInt(42) |
| endReturnStatement(true, return, ;) |
| endThenStatement(;) |
| endIfStatement(if, null) |
| beginReturnStatement(return) |
| handleLiteralNull(null) |
| handleNoTypeArguments(() |
| beginArguments(() |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(-) |
| handleNoArguments(-) |
| handleSend(x, -) |
| beginBinaryExpression(-) |
| handleLiteralInt(1) |
| endBinaryExpression(-) |
| endArguments(1, (, )) |
| handleSend((, )) |
| beginBinaryExpression(+) |
| handleLiteralInt(1) |
| endBinaryExpression(+) |
| endReturnStatement(true, return, ;) |
| endBlockFunctionBody(2, {, }) |
| endClassMethod(null, int, (, null, }) |
| endMember() |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginMember() |
| beginMethod(null, null, null, null, null, of) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(of) |
| handleType(int, null) |
| handleIdentifier(of, methodDeclaration) |
| handleNoTypeVariables(() |
| beginFormalParameters((, MemberKind.NonStaticMethod) |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(x) |
| handleType(int, null) |
| handleIdentifier(x, formalParameterDeclaration) |
| handleFormalParameterWithoutValue()) |
| endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) |
| endFormalParameters(1, (, ), MemberKind.NonStaticMethod) |
| handleNoInitializers() |
| handleAsyncModifier(null, null) |
| beginBlockFunctionBody({) |
| beginIfStatement(if) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(==) |
| handleNoArguments(==) |
| handleSend(x, ==) |
| beginBinaryExpression(==) |
| handleLiteralInt(0) |
| endBinaryExpression(==) |
| handleParenthesizedCondition(() |
| beginThenStatement(return) |
| beginReturnStatement(return) |
| handleLiteralInt(42) |
| endReturnStatement(true, return, ;) |
| endThenStatement(;) |
| endIfStatement(if, null) |
| beginReturnStatement(return) |
| handleIdentifier(of, expression) |
| handleNoTypeArguments(() |
| beginArguments(() |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(-) |
| handleNoArguments(-) |
| handleSend(x, -) |
| beginBinaryExpression(-) |
| handleLiteralInt(1) |
| endBinaryExpression(-) |
| endArguments(1, (, )) |
| handleSend(of, +) |
| beginBinaryExpression(+) |
| handleLiteralInt(1) |
| endBinaryExpression(+) |
| endReturnStatement(true, return, ;) |
| endBlockFunctionBody(2, {, }) |
| endClassMethod(null, int, (, null, }) |
| endMember() |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginMember() |
| beginMethod(null, null, null, null, null, on) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(on) |
| handleType(int, null) |
| handleIdentifier(on, methodDeclaration) |
| handleNoTypeVariables(() |
| beginFormalParameters((, MemberKind.NonStaticMethod) |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(x) |
| handleType(int, null) |
| handleIdentifier(x, formalParameterDeclaration) |
| handleFormalParameterWithoutValue()) |
| endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) |
| endFormalParameters(1, (, ), MemberKind.NonStaticMethod) |
| handleNoInitializers() |
| handleAsyncModifier(null, null) |
| beginBlockFunctionBody({) |
| beginIfStatement(if) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(==) |
| handleNoArguments(==) |
| handleSend(x, ==) |
| beginBinaryExpression(==) |
| handleLiteralInt(0) |
| endBinaryExpression(==) |
| handleParenthesizedCondition(() |
| beginThenStatement(return) |
| beginReturnStatement(return) |
| handleLiteralInt(42) |
| endReturnStatement(true, return, ;) |
| endThenStatement(;) |
| endIfStatement(if, null) |
| beginReturnStatement(return) |
| handleIdentifier(on, expression) |
| handleNoTypeArguments(() |
| beginArguments(() |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(-) |
| handleNoArguments(-) |
| handleSend(x, -) |
| beginBinaryExpression(-) |
| handleLiteralInt(1) |
| endBinaryExpression(-) |
| endArguments(1, (, )) |
| handleSend(on, +) |
| beginBinaryExpression(+) |
| handleLiteralInt(1) |
| endBinaryExpression(+) |
| endReturnStatement(true, return, ;) |
| endBlockFunctionBody(2, {, }) |
| endClassMethod(null, int, (, null, }) |
| endMember() |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginMember() |
| beginMethod(null, null, null, null, null, operator) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(operator) |
| handleType(int, null) |
| handleIdentifier(operator, methodDeclaration) |
| handleNoTypeVariables(() |
| beginFormalParameters((, MemberKind.NonStaticMethod) |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(x) |
| handleType(int, null) |
| handleIdentifier(x, formalParameterDeclaration) |
| handleFormalParameterWithoutValue()) |
| endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) |
| endFormalParameters(1, (, ), MemberKind.NonStaticMethod) |
| handleNoInitializers() |
| handleAsyncModifier(null, null) |
| beginBlockFunctionBody({) |
| beginIfStatement(if) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(==) |
| handleNoArguments(==) |
| handleSend(x, ==) |
| beginBinaryExpression(==) |
| handleLiteralInt(0) |
| endBinaryExpression(==) |
| handleParenthesizedCondition(() |
| beginThenStatement(return) |
| beginReturnStatement(return) |
| handleLiteralInt(42) |
| endReturnStatement(true, return, ;) |
| endThenStatement(;) |
| endIfStatement(if, null) |
| beginReturnStatement(return) |
| handleIdentifier(operator, expression) |
| handleNoTypeArguments(() |
| beginArguments(() |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(-) |
| handleNoArguments(-) |
| handleSend(x, -) |
| beginBinaryExpression(-) |
| handleLiteralInt(1) |
| endBinaryExpression(-) |
| endArguments(1, (, )) |
| handleSend(operator, +) |
| beginBinaryExpression(+) |
| handleLiteralInt(1) |
| endBinaryExpression(+) |
| endReturnStatement(true, return, ;) |
| endBlockFunctionBody(2, {, }) |
| endClassMethod(null, int, (, null, }) |
| endMember() |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginMember() |
| beginMethod(null, null, null, null, null, out) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(out) |
| handleType(int, null) |
| handleIdentifier(out, methodDeclaration) |
| handleNoTypeVariables(() |
| beginFormalParameters((, MemberKind.NonStaticMethod) |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(x) |
| handleType(int, null) |
| handleIdentifier(x, formalParameterDeclaration) |
| handleFormalParameterWithoutValue()) |
| endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) |
| endFormalParameters(1, (, ), MemberKind.NonStaticMethod) |
| handleNoInitializers() |
| handleAsyncModifier(null, null) |
| beginBlockFunctionBody({) |
| beginIfStatement(if) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(==) |
| handleNoArguments(==) |
| handleSend(x, ==) |
| beginBinaryExpression(==) |
| handleLiteralInt(0) |
| endBinaryExpression(==) |
| handleParenthesizedCondition(() |
| beginThenStatement(return) |
| beginReturnStatement(return) |
| handleLiteralInt(42) |
| endReturnStatement(true, return, ;) |
| endThenStatement(;) |
| endIfStatement(if, null) |
| beginReturnStatement(return) |
| handleIdentifier(out, expression) |
| handleNoTypeArguments(() |
| beginArguments(() |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(-) |
| handleNoArguments(-) |
| handleSend(x, -) |
| beginBinaryExpression(-) |
| handleLiteralInt(1) |
| endBinaryExpression(-) |
| endArguments(1, (, )) |
| handleSend(out, +) |
| beginBinaryExpression(+) |
| handleLiteralInt(1) |
| endBinaryExpression(+) |
| endReturnStatement(true, return, ;) |
| endBlockFunctionBody(2, {, }) |
| endClassMethod(null, int, (, null, }) |
| endMember() |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginMember() |
| beginMethod(null, null, null, null, null, part) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(part) |
| handleType(int, null) |
| handleIdentifier(part, methodDeclaration) |
| handleNoTypeVariables(() |
| beginFormalParameters((, MemberKind.NonStaticMethod) |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(x) |
| handleType(int, null) |
| handleIdentifier(x, formalParameterDeclaration) |
| handleFormalParameterWithoutValue()) |
| endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) |
| endFormalParameters(1, (, ), MemberKind.NonStaticMethod) |
| handleNoInitializers() |
| handleAsyncModifier(null, null) |
| beginBlockFunctionBody({) |
| beginIfStatement(if) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(==) |
| handleNoArguments(==) |
| handleSend(x, ==) |
| beginBinaryExpression(==) |
| handleLiteralInt(0) |
| endBinaryExpression(==) |
| handleParenthesizedCondition(() |
| beginThenStatement(return) |
| beginReturnStatement(return) |
| handleLiteralInt(42) |
| endReturnStatement(true, return, ;) |
| endThenStatement(;) |
| endIfStatement(if, null) |
| beginReturnStatement(return) |
| handleIdentifier(part, expression) |
| handleNoTypeArguments(() |
| beginArguments(() |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(-) |
| handleNoArguments(-) |
| handleSend(x, -) |
| beginBinaryExpression(-) |
| handleLiteralInt(1) |
| endBinaryExpression(-) |
| endArguments(1, (, )) |
| handleSend(part, +) |
| beginBinaryExpression(+) |
| handleLiteralInt(1) |
| endBinaryExpression(+) |
| endReturnStatement(true, return, ;) |
| endBlockFunctionBody(2, {, }) |
| endClassMethod(null, int, (, null, }) |
| endMember() |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginMember() |
| beginMethod(null, null, null, null, null, patch) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(patch) |
| handleType(int, null) |
| handleIdentifier(patch, methodDeclaration) |
| handleNoTypeVariables(() |
| beginFormalParameters((, MemberKind.NonStaticMethod) |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(x) |
| handleType(int, null) |
| handleIdentifier(x, formalParameterDeclaration) |
| handleFormalParameterWithoutValue()) |
| endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) |
| endFormalParameters(1, (, ), MemberKind.NonStaticMethod) |
| handleNoInitializers() |
| handleAsyncModifier(null, null) |
| beginBlockFunctionBody({) |
| beginIfStatement(if) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(==) |
| handleNoArguments(==) |
| handleSend(x, ==) |
| beginBinaryExpression(==) |
| handleLiteralInt(0) |
| endBinaryExpression(==) |
| handleParenthesizedCondition(() |
| beginThenStatement(return) |
| beginReturnStatement(return) |
| handleLiteralInt(42) |
| endReturnStatement(true, return, ;) |
| endThenStatement(;) |
| endIfStatement(if, null) |
| beginReturnStatement(return) |
| handleIdentifier(patch, expression) |
| handleNoTypeArguments(() |
| beginArguments(() |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(-) |
| handleNoArguments(-) |
| handleSend(x, -) |
| beginBinaryExpression(-) |
| handleLiteralInt(1) |
| endBinaryExpression(-) |
| endArguments(1, (, )) |
| handleSend(patch, +) |
| beginBinaryExpression(+) |
| handleLiteralInt(1) |
| endBinaryExpression(+) |
| endReturnStatement(true, return, ;) |
| endBlockFunctionBody(2, {, }) |
| endClassMethod(null, int, (, null, }) |
| endMember() |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginMember() |
| beginMethod(null, null, null, null, null, required) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(required) |
| handleType(int, null) |
| handleIdentifier(required, methodDeclaration) |
| handleNoTypeVariables(() |
| beginFormalParameters((, MemberKind.NonStaticMethod) |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(x) |
| handleType(int, null) |
| handleIdentifier(x, formalParameterDeclaration) |
| handleFormalParameterWithoutValue()) |
| endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) |
| endFormalParameters(1, (, ), MemberKind.NonStaticMethod) |
| handleNoInitializers() |
| handleAsyncModifier(null, null) |
| beginBlockFunctionBody({) |
| beginIfStatement(if) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(==) |
| handleNoArguments(==) |
| handleSend(x, ==) |
| beginBinaryExpression(==) |
| handleLiteralInt(0) |
| endBinaryExpression(==) |
| handleParenthesizedCondition(() |
| beginThenStatement(return) |
| beginReturnStatement(return) |
| handleLiteralInt(42) |
| endReturnStatement(true, return, ;) |
| endThenStatement(;) |
| endIfStatement(if, null) |
| beginReturnStatement(return) |
| handleIdentifier(required, expression) |
| handleNoTypeArguments(() |
| beginArguments(() |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(-) |
| handleNoArguments(-) |
| handleSend(x, -) |
| beginBinaryExpression(-) |
| handleLiteralInt(1) |
| endBinaryExpression(-) |
| endArguments(1, (, )) |
| handleSend(required, +) |
| beginBinaryExpression(+) |
| handleLiteralInt(1) |
| endBinaryExpression(+) |
| endReturnStatement(true, return, ;) |
| endBlockFunctionBody(2, {, }) |
| endClassMethod(null, int, (, null, }) |
| endMember() |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginMember() |
| beginMethod(null, null, null, null, null, rethrow) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(rethrow) |
| handleType(int, null) |
| handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'rethrow' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: rethrow}], rethrow, rethrow) |
| handleIdentifier(rethrow, methodDeclaration) |
| handleNoTypeVariables(() |
| beginFormalParameters((, MemberKind.NonStaticMethod) |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(x) |
| handleType(int, null) |
| handleIdentifier(x, formalParameterDeclaration) |
| handleFormalParameterWithoutValue()) |
| endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) |
| endFormalParameters(1, (, ), MemberKind.NonStaticMethod) |
| handleNoInitializers() |
| handleAsyncModifier(null, null) |
| beginBlockFunctionBody({) |
| beginIfStatement(if) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(==) |
| handleNoArguments(==) |
| handleSend(x, ==) |
| beginBinaryExpression(==) |
| handleLiteralInt(0) |
| endBinaryExpression(==) |
| handleParenthesizedCondition(() |
| beginThenStatement(return) |
| beginReturnStatement(return) |
| handleLiteralInt(42) |
| endReturnStatement(true, return, ;) |
| endThenStatement(;) |
| endIfStatement(if, null) |
| beginReturnStatement(return) |
| handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'rethrow' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: rethrow}], rethrow, rethrow) |
| handleIdentifier(rethrow, expression) |
| handleNoTypeArguments(() |
| beginArguments(() |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(-) |
| handleNoArguments(-) |
| handleSend(x, -) |
| beginBinaryExpression(-) |
| handleLiteralInt(1) |
| endBinaryExpression(-) |
| endArguments(1, (, )) |
| handleSend(rethrow, +) |
| beginBinaryExpression(+) |
| handleLiteralInt(1) |
| endBinaryExpression(+) |
| endReturnStatement(true, return, ;) |
| endBlockFunctionBody(2, {, }) |
| endClassMethod(null, int, (, null, }) |
| endMember() |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginMember() |
| beginMethod(null, null, null, null, null, return) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(return) |
| handleType(int, null) |
| handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'return' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: return}], return, return) |
| handleIdentifier(return, methodDeclaration) |
| handleNoTypeVariables(() |
| beginFormalParameters((, MemberKind.NonStaticMethod) |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(x) |
| handleType(int, null) |
| handleIdentifier(x, formalParameterDeclaration) |
| handleFormalParameterWithoutValue()) |
| endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) |
| endFormalParameters(1, (, ), MemberKind.NonStaticMethod) |
| handleNoInitializers() |
| handleAsyncModifier(null, null) |
| beginBlockFunctionBody({) |
| beginIfStatement(if) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(==) |
| handleNoArguments(==) |
| handleSend(x, ==) |
| beginBinaryExpression(==) |
| handleLiteralInt(0) |
| endBinaryExpression(==) |
| handleParenthesizedCondition(() |
| beginThenStatement(return) |
| beginReturnStatement(return) |
| handleLiteralInt(42) |
| endReturnStatement(true, return, ;) |
| endThenStatement(;) |
| endIfStatement(if, null) |
| beginReturnStatement(return) |
| handleRecoverableError(Message[UnexpectedToken, Unexpected token 'return'., null, {lexeme: return}], return, return) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(-) |
| handleNoArguments(-) |
| handleSend(x, -) |
| beginBinaryExpression(-) |
| handleLiteralInt(1) |
| endBinaryExpression(-) |
| handleParenthesizedExpression(() |
| beginBinaryExpression(+) |
| handleLiteralInt(1) |
| endBinaryExpression(+) |
| endReturnStatement(true, return, ;) |
| endBlockFunctionBody(2, {, }) |
| endClassMethod(null, int, (, null, }) |
| endMember() |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginMember() |
| beginMethod(null, null, null, null, null, set) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(set) |
| handleType(int, null) |
| handleIdentifier(set, methodDeclaration) |
| handleNoTypeVariables(() |
| beginFormalParameters((, MemberKind.NonStaticMethod) |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(x) |
| handleType(int, null) |
| handleIdentifier(x, formalParameterDeclaration) |
| handleFormalParameterWithoutValue()) |
| endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) |
| endFormalParameters(1, (, ), MemberKind.NonStaticMethod) |
| handleNoInitializers() |
| handleAsyncModifier(null, null) |
| beginBlockFunctionBody({) |
| beginIfStatement(if) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(==) |
| handleNoArguments(==) |
| handleSend(x, ==) |
| beginBinaryExpression(==) |
| handleLiteralInt(0) |
| endBinaryExpression(==) |
| handleParenthesizedCondition(() |
| beginThenStatement(return) |
| beginReturnStatement(return) |
| handleLiteralInt(42) |
| endReturnStatement(true, return, ;) |
| endThenStatement(;) |
| endIfStatement(if, null) |
| beginReturnStatement(return) |
| handleIdentifier(set, expression) |
| handleNoTypeArguments(() |
| beginArguments(() |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(-) |
| handleNoArguments(-) |
| handleSend(x, -) |
| beginBinaryExpression(-) |
| handleLiteralInt(1) |
| endBinaryExpression(-) |
| endArguments(1, (, )) |
| handleSend(set, +) |
| beginBinaryExpression(+) |
| handleLiteralInt(1) |
| endBinaryExpression(+) |
| endReturnStatement(true, return, ;) |
| endBlockFunctionBody(2, {, }) |
| endClassMethod(null, int, (, null, }) |
| endMember() |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginMember() |
| beginMethod(null, null, null, null, null, show) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(show) |
| handleType(int, null) |
| handleIdentifier(show, methodDeclaration) |
| handleNoTypeVariables(() |
| beginFormalParameters((, MemberKind.NonStaticMethod) |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(x) |
| handleType(int, null) |
| handleIdentifier(x, formalParameterDeclaration) |
| handleFormalParameterWithoutValue()) |
| endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) |
| endFormalParameters(1, (, ), MemberKind.NonStaticMethod) |
| handleNoInitializers() |
| handleAsyncModifier(null, null) |
| beginBlockFunctionBody({) |
| beginIfStatement(if) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(==) |
| handleNoArguments(==) |
| handleSend(x, ==) |
| beginBinaryExpression(==) |
| handleLiteralInt(0) |
| endBinaryExpression(==) |
| handleParenthesizedCondition(() |
| beginThenStatement(return) |
| beginReturnStatement(return) |
| handleLiteralInt(42) |
| endReturnStatement(true, return, ;) |
| endThenStatement(;) |
| endIfStatement(if, null) |
| beginReturnStatement(return) |
| handleIdentifier(show, expression) |
| handleNoTypeArguments(() |
| beginArguments(() |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(-) |
| handleNoArguments(-) |
| handleSend(x, -) |
| beginBinaryExpression(-) |
| handleLiteralInt(1) |
| endBinaryExpression(-) |
| endArguments(1, (, )) |
| handleSend(show, +) |
| beginBinaryExpression(+) |
| handleLiteralInt(1) |
| endBinaryExpression(+) |
| endReturnStatement(true, return, ;) |
| endBlockFunctionBody(2, {, }) |
| endClassMethod(null, int, (, null, }) |
| endMember() |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginMember() |
| beginMethod(null, null, null, null, null, source) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(source) |
| handleType(int, null) |
| handleIdentifier(source, methodDeclaration) |
| handleNoTypeVariables(() |
| beginFormalParameters((, MemberKind.NonStaticMethod) |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(x) |
| handleType(int, null) |
| handleIdentifier(x, formalParameterDeclaration) |
| handleFormalParameterWithoutValue()) |
| endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) |
| endFormalParameters(1, (, ), MemberKind.NonStaticMethod) |
| handleNoInitializers() |
| handleAsyncModifier(null, null) |
| beginBlockFunctionBody({) |
| beginIfStatement(if) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(==) |
| handleNoArguments(==) |
| handleSend(x, ==) |
| beginBinaryExpression(==) |
| handleLiteralInt(0) |
| endBinaryExpression(==) |
| handleParenthesizedCondition(() |
| beginThenStatement(return) |
| beginReturnStatement(return) |
| handleLiteralInt(42) |
| endReturnStatement(true, return, ;) |
| endThenStatement(;) |
| endIfStatement(if, null) |
| beginReturnStatement(return) |
| handleIdentifier(source, expression) |
| handleNoTypeArguments(() |
| beginArguments(() |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(-) |
| handleNoArguments(-) |
| handleSend(x, -) |
| beginBinaryExpression(-) |
| handleLiteralInt(1) |
| endBinaryExpression(-) |
| endArguments(1, (, )) |
| handleSend(source, +) |
| beginBinaryExpression(+) |
| handleLiteralInt(1) |
| endBinaryExpression(+) |
| endReturnStatement(true, return, ;) |
| endBlockFunctionBody(2, {, }) |
| endClassMethod(null, int, (, null, }) |
| endMember() |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginMember() |
| beginMethod(null, null, null, null, null, static) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(static) |
| handleType(int, null) |
| handleIdentifier(static, methodDeclaration) |
| handleNoTypeVariables(() |
| beginFormalParameters((, MemberKind.NonStaticMethod) |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(x) |
| handleType(int, null) |
| handleIdentifier(x, formalParameterDeclaration) |
| handleFormalParameterWithoutValue()) |
| endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) |
| endFormalParameters(1, (, ), MemberKind.NonStaticMethod) |
| handleNoInitializers() |
| handleAsyncModifier(null, null) |
| beginBlockFunctionBody({) |
| beginIfStatement(if) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(==) |
| handleNoArguments(==) |
| handleSend(x, ==) |
| beginBinaryExpression(==) |
| handleLiteralInt(0) |
| endBinaryExpression(==) |
| handleParenthesizedCondition(() |
| beginThenStatement(return) |
| beginReturnStatement(return) |
| handleLiteralInt(42) |
| endReturnStatement(true, return, ;) |
| endThenStatement(;) |
| endIfStatement(if, null) |
| beginReturnStatement(return) |
| handleIdentifier(static, expression) |
| handleNoTypeArguments(() |
| beginArguments(() |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(-) |
| handleNoArguments(-) |
| handleSend(x, -) |
| beginBinaryExpression(-) |
| handleLiteralInt(1) |
| endBinaryExpression(-) |
| endArguments(1, (, )) |
| handleSend(static, +) |
| beginBinaryExpression(+) |
| handleLiteralInt(1) |
| endBinaryExpression(+) |
| endReturnStatement(true, return, ;) |
| endBlockFunctionBody(2, {, }) |
| endClassMethod(null, int, (, null, }) |
| endMember() |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginMember() |
| beginMethod(null, null, null, null, null, super) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(super) |
| handleType(int, null) |
| handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'super' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: super}], super, super) |
| handleIdentifier(super, methodDeclaration) |
| handleNoTypeVariables(() |
| beginFormalParameters((, MemberKind.NonStaticMethod) |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(x) |
| handleType(int, null) |
| handleIdentifier(x, formalParameterDeclaration) |
| handleFormalParameterWithoutValue()) |
| endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) |
| endFormalParameters(1, (, ), MemberKind.NonStaticMethod) |
| handleNoInitializers() |
| handleAsyncModifier(null, null) |
| beginBlockFunctionBody({) |
| beginIfStatement(if) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(==) |
| handleNoArguments(==) |
| handleSend(x, ==) |
| beginBinaryExpression(==) |
| handleLiteralInt(0) |
| endBinaryExpression(==) |
| handleParenthesizedCondition(() |
| beginThenStatement(return) |
| beginReturnStatement(return) |
| handleLiteralInt(42) |
| endReturnStatement(true, return, ;) |
| endThenStatement(;) |
| endIfStatement(if, null) |
| beginReturnStatement(return) |
| handleSuperExpression(super, expression) |
| handleNoTypeArguments(() |
| beginArguments(() |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(-) |
| handleNoArguments(-) |
| handleSend(x, -) |
| beginBinaryExpression(-) |
| handleLiteralInt(1) |
| endBinaryExpression(-) |
| endArguments(1, (, )) |
| handleSend(super, +) |
| beginBinaryExpression(+) |
| handleLiteralInt(1) |
| endBinaryExpression(+) |
| endReturnStatement(true, return, ;) |
| endBlockFunctionBody(2, {, }) |
| endClassMethod(null, int, (, null, }) |
| endMember() |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginMember() |
| beginMethod(null, null, null, null, null, switch) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(switch) |
| handleType(int, null) |
| handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'switch' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: switch}], switch, switch) |
| handleIdentifier(switch, methodDeclaration) |
| handleNoTypeVariables(() |
| beginFormalParameters((, MemberKind.NonStaticMethod) |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(x) |
| handleType(int, null) |
| handleIdentifier(x, formalParameterDeclaration) |
| handleFormalParameterWithoutValue()) |
| endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) |
| endFormalParameters(1, (, ), MemberKind.NonStaticMethod) |
| handleNoInitializers() |
| handleAsyncModifier(null, null) |
| beginBlockFunctionBody({) |
| beginIfStatement(if) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(==) |
| handleNoArguments(==) |
| handleSend(x, ==) |
| beginBinaryExpression(==) |
| handleLiteralInt(0) |
| endBinaryExpression(==) |
| handleParenthesizedCondition(() |
| beginThenStatement(return) |
| beginReturnStatement(return) |
| handleLiteralInt(42) |
| endReturnStatement(true, return, ;) |
| endThenStatement(;) |
| endIfStatement(if, null) |
| beginReturnStatement(return) |
| handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'switch'., Try inserting an identifier before 'switch'., {lexeme: switch}], switch, switch) |
| handleIdentifier(, expression) |
| handleNoTypeArguments(switch) |
| handleNoArguments(switch) |
| handleSend(, switch) |
| handleRecoverableError(Message[ExpectedAfterButGot, Expected ';' after this., null, {string: ;}], switch, switch) |
| endReturnStatement(true, return, ;) |
| beginSwitchStatement(switch) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(-) |
| handleNoArguments(-) |
| handleSend(x, -) |
| beginBinaryExpression(-) |
| handleLiteralInt(1) |
| endBinaryExpression(-) |
| handleParenthesizedCondition(() |
| handleRecoverableError(Message[ExpectedClassOrMixinBody, A switch statement must have a body, even if it is empty., Try adding an empty body., {string: switch statement}], ), )) |
| beginSwitchBlock({) |
| endSwitchBlock(0, {, }) |
| endSwitchStatement(switch, }) |
| handleRecoverableError(UnsupportedPrefixPlus, +, +) |
| handleIdentifier(, expression) |
| handleNoTypeArguments(+) |
| handleNoArguments(+) |
| handleSend(, +) |
| beginBinaryExpression(+) |
| handleLiteralInt(1) |
| endBinaryExpression(+) |
| handleExpressionStatement(;) |
| endBlockFunctionBody(4, {, }) |
| endClassMethod(null, int, (, null, }) |
| endMember() |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginMember() |
| beginMethod(null, null, null, null, null, sync) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(sync) |
| handleType(int, null) |
| handleIdentifier(sync, methodDeclaration) |
| handleNoTypeVariables(() |
| beginFormalParameters((, MemberKind.NonStaticMethod) |
| beginMetadataStar(int) |
| endMetadataStar(0) |
| beginFormalParameter(int, MemberKind.NonStaticMethod, null, null, null) |
| handleIdentifier(int, typeReference) |
| handleNoTypeArguments(x) |
| handleType(int, null) |
| handleIdentifier(x, formalParameterDeclaration) |
| handleFormalParameterWithoutValue()) |
| endFormalParameter(null, null, x, null, null, FormalParameterKind.mandatory, MemberKind.NonStaticMethod) |
| endFormalParameters(1, (, ), MemberKind.NonStaticMethod) |
| handleNoInitializers() |
| handleAsyncModifier(null, null) |
| beginBlockFunctionBody({) |
| beginIfStatement(if) |
| handleIdentifier(x, expression) |
| handleNoTypeArguments(==) |
| handleNoArguments(==) |
| handleSend(x, ==) |
| beginBinaryExpression(==) |
| handleLiteralInt(0) |
| endBinaryExpression(==) |
| handleParenthesizedCondition(() |
| beginThenStatement(return) |
| beginReturnStatement(return) |
| handleLiteralInt(42) |
| endReturnStatement(true, return, ;) |
| endThenStatement(;) |
|
