| Problems reported: |
| |
| parser/error_recovery/symbols:4:8: 'void' can't be used as an identifier because it's a keyword. |
| #foo.void; |
| ^^^^ |
| |
| parser/error_recovery/symbols:5:4: 'assert' can't be used as an identifier because it's a keyword. |
| #assert; |
| ^^^^^^ |
| |
| parser/error_recovery/symbols:6:4: 'break' can't be used as an identifier because it's a keyword. |
| #break; |
| ^^^^^ |
| |
| parser/error_recovery/symbols:7:4: 'case' can't be used as an identifier because it's a keyword. |
| #case; |
| ^^^^ |
| |
| parser/error_recovery/symbols:8:4: 'catch' can't be used as an identifier because it's a keyword. |
| #catch; |
| ^^^^^ |
| |
| parser/error_recovery/symbols:9:4: 'class' can't be used as an identifier because it's a keyword. |
| #class; |
| ^^^^^ |
| |
| parser/error_recovery/symbols:10:4: 'const' can't be used as an identifier because it's a keyword. |
| #const; |
| ^^^^^ |
| |
| parser/error_recovery/symbols:11:4: 'continue' can't be used as an identifier because it's a keyword. |
| #continue; |
| ^^^^^^^^ |
| |
| parser/error_recovery/symbols:12:4: 'default' can't be used as an identifier because it's a keyword. |
| #default; |
| ^^^^^^^ |
| |
| parser/error_recovery/symbols:13:4: 'do' can't be used as an identifier because it's a keyword. |
| #do; |
| ^^ |
| |
| parser/error_recovery/symbols:14:4: 'else' can't be used as an identifier because it's a keyword. |
| #else; |
| ^^^^ |
| |
| parser/error_recovery/symbols:15:4: 'enum' can't be used as an identifier because it's a keyword. |
| #enum; |
| ^^^^ |
| |
| parser/error_recovery/symbols:16:4: 'extends' can't be used as an identifier because it's a keyword. |
| #extends; |
| ^^^^^^^ |
| |
| parser/error_recovery/symbols:17:4: 'false' can't be used as an identifier because it's a keyword. |
| #false; |
| ^^^^^ |
| |
| parser/error_recovery/symbols:18:4: 'final' can't be used as an identifier because it's a keyword. |
| #final; |
| ^^^^^ |
| |
| parser/error_recovery/symbols:19:4: 'finally' can't be used as an identifier because it's a keyword. |
| #finally; |
| ^^^^^^^ |
| |
| parser/error_recovery/symbols:20:4: 'for' can't be used as an identifier because it's a keyword. |
| #for; |
| ^^^ |
| |
| parser/error_recovery/symbols:21:4: 'if' can't be used as an identifier because it's a keyword. |
| #if; |
| ^^ |
| |
| parser/error_recovery/symbols:22:4: 'in' can't be used as an identifier because it's a keyword. |
| #in; |
| ^^ |
| |
| parser/error_recovery/symbols:23:4: 'is' can't be used as an identifier because it's a keyword. |
| #is; |
| ^^ |
| |
| parser/error_recovery/symbols:24:4: 'new' can't be used as an identifier because it's a keyword. |
| #new; |
| ^^^ |
| |
| parser/error_recovery/symbols:25:4: 'null' can't be used as an identifier because it's a keyword. |
| #null; |
| ^^^^ |
| |
| parser/error_recovery/symbols:26:4: 'rethrow' can't be used as an identifier because it's a keyword. |
| #rethrow; |
| ^^^^^^^ |
| |
| parser/error_recovery/symbols:27:4: 'return' can't be used as an identifier because it's a keyword. |
| #return; |
| ^^^^^^ |
| |
| parser/error_recovery/symbols:28:4: 'super' can't be used as an identifier because it's a keyword. |
| #super; |
| ^^^^^ |
| |
| parser/error_recovery/symbols:29:4: 'switch' can't be used as an identifier because it's a keyword. |
| #switch; |
| ^^^^^^ |
| |
| parser/error_recovery/symbols:30:4: 'this' can't be used as an identifier because it's a keyword. |
| #this; |
| ^^^^ |
| |
| parser/error_recovery/symbols:31:4: 'throw' can't be used as an identifier because it's a keyword. |
| #throw; |
| ^^^^^ |
| |
| parser/error_recovery/symbols:32:4: 'true' can't be used as an identifier because it's a keyword. |
| #true; |
| ^^^^ |
| |
| parser/error_recovery/symbols:33:4: 'try' can't be used as an identifier because it's a keyword. |
| #try; |
| ^^^ |
| |
| parser/error_recovery/symbols:34:4: 'var' can't be used as an identifier because it's a keyword. |
| #var; |
| ^^^ |
| |
| parser/error_recovery/symbols:35:4: 'while' can't be used as an identifier because it's a keyword. |
| #while; |
| ^^^^^ |
| |
| parser/error_recovery/symbols:36:4: 'with' can't be used as an identifier because it's a keyword. |
| #with; |
| ^^^^ |
| |
| parser/error_recovery/symbols:37:8: 'assert' can't be used as an identifier because it's a keyword. |
| #foo.assert; |
| ^^^^^^ |
| |
| parser/error_recovery/symbols:38:8: 'break' can't be used as an identifier because it's a keyword. |
| #foo.break; |
| ^^^^^ |
| |
| parser/error_recovery/symbols:39:8: 'case' can't be used as an identifier because it's a keyword. |
| #foo.case; |
| ^^^^ |
| |
| parser/error_recovery/symbols:40:8: 'catch' can't be used as an identifier because it's a keyword. |
| #foo.catch; |
| ^^^^^ |
| |
| parser/error_recovery/symbols:41:8: 'class' can't be used as an identifier because it's a keyword. |
| #foo.class; |
| ^^^^^ |
| |
| parser/error_recovery/symbols:42:8: 'const' can't be used as an identifier because it's a keyword. |
| #foo.const; |
| ^^^^^ |
| |
| parser/error_recovery/symbols:43:8: 'continue' can't be used as an identifier because it's a keyword. |
| #foo.continue; |
| ^^^^^^^^ |
| |
| parser/error_recovery/symbols:44:8: 'default' can't be used as an identifier because it's a keyword. |
| #foo.default; |
| ^^^^^^^ |
| |
| parser/error_recovery/symbols:45:8: 'do' can't be used as an identifier because it's a keyword. |
| #foo.do; |
| ^^ |
| |
| parser/error_recovery/symbols:46:8: 'else' can't be used as an identifier because it's a keyword. |
| #foo.else; |
| ^^^^ |
| |
| parser/error_recovery/symbols:47:8: 'enum' can't be used as an identifier because it's a keyword. |
| #foo.enum; |
| ^^^^ |
| |
| parser/error_recovery/symbols:48:8: 'extends' can't be used as an identifier because it's a keyword. |
| #foo.extends; |
| ^^^^^^^ |
| |
| parser/error_recovery/symbols:49:8: 'false' can't be used as an identifier because it's a keyword. |
| #foo.false; |
| ^^^^^ |
| |
| parser/error_recovery/symbols:50:8: 'final' can't be used as an identifier because it's a keyword. |
| #foo.final; |
| ^^^^^ |
| |
| parser/error_recovery/symbols:51:8: 'finally' can't be used as an identifier because it's a keyword. |
| #foo.finally; |
| ^^^^^^^ |
| |
| parser/error_recovery/symbols:52:8: 'for' can't be used as an identifier because it's a keyword. |
| #foo.for; |
| ^^^ |
| |
| parser/error_recovery/symbols:53:8: 'if' can't be used as an identifier because it's a keyword. |
| #foo.if; |
| ^^ |
| |
| parser/error_recovery/symbols:54:8: 'in' can't be used as an identifier because it's a keyword. |
| #foo.in; |
| ^^ |
| |
| parser/error_recovery/symbols:55:8: 'is' can't be used as an identifier because it's a keyword. |
| #foo.is; |
| ^^ |
| |
| parser/error_recovery/symbols:56:8: 'new' can't be used as an identifier because it's a keyword. |
| #foo.new; |
| ^^^ |
| |
| parser/error_recovery/symbols:57:8: 'null' can't be used as an identifier because it's a keyword. |
| #foo.null; |
| ^^^^ |
| |
| parser/error_recovery/symbols:58:8: 'rethrow' can't be used as an identifier because it's a keyword. |
| #foo.rethrow; |
| ^^^^^^^ |
| |
| parser/error_recovery/symbols:59:8: 'return' can't be used as an identifier because it's a keyword. |
| #foo.return; |
| ^^^^^^ |
| |
| parser/error_recovery/symbols:60:8: 'super' can't be used as an identifier because it's a keyword. |
| #foo.super; |
| ^^^^^ |
| |
| parser/error_recovery/symbols:61:8: 'switch' can't be used as an identifier because it's a keyword. |
| #foo.switch; |
| ^^^^^^ |
| |
| parser/error_recovery/symbols:62:8: 'this' can't be used as an identifier because it's a keyword. |
| #foo.this; |
| ^^^^ |
| |
| parser/error_recovery/symbols:63:8: 'throw' can't be used as an identifier because it's a keyword. |
| #foo.throw; |
| ^^^^^ |
| |
| parser/error_recovery/symbols:64:8: 'true' can't be used as an identifier because it's a keyword. |
| #foo.true; |
| ^^^^ |
| |
| parser/error_recovery/symbols:65:8: 'try' can't be used as an identifier because it's a keyword. |
| #foo.try; |
| ^^^ |
| |
| parser/error_recovery/symbols:66:8: 'var' can't be used as an identifier because it's a keyword. |
| #foo.var; |
| ^^^ |
| |
| parser/error_recovery/symbols:67:8: 'while' can't be used as an identifier because it's a keyword. |
| #foo.while; |
| ^^^^^ |
| |
| parser/error_recovery/symbols:68:8: 'with' can't be used as an identifier because it's a keyword. |
| #foo.with; |
| ^^^^ |
| |
| parser/error_recovery/symbols:69:4: 'assert' can't be used as an identifier because it's a keyword. |
| #assert.foo; |
| ^^^^^^ |
| |
| parser/error_recovery/symbols:70:4: 'break' can't be used as an identifier because it's a keyword. |
| #break.foo; |
| ^^^^^ |
| |
| parser/error_recovery/symbols:71:4: 'case' can't be used as an identifier because it's a keyword. |
| #case.foo; |
| ^^^^ |
| |
| parser/error_recovery/symbols:72:4: 'catch' can't be used as an identifier because it's a keyword. |
| #catch.foo; |
| ^^^^^ |
| |
| parser/error_recovery/symbols:73:4: 'class' can't be used as an identifier because it's a keyword. |
| #class.foo; |
| ^^^^^ |
| |
| parser/error_recovery/symbols:74:4: 'const' can't be used as an identifier because it's a keyword. |
| #const.foo; |
| ^^^^^ |
| |
| parser/error_recovery/symbols:75:4: 'continue' can't be used as an identifier because it's a keyword. |
| #continue.foo; |
| ^^^^^^^^ |
| |
| parser/error_recovery/symbols:76:4: 'default' can't be used as an identifier because it's a keyword. |
| #default.foo; |
| ^^^^^^^ |
| |
| parser/error_recovery/symbols:77:4: 'do' can't be used as an identifier because it's a keyword. |
| #do.foo; |
| ^^ |
| |
| parser/error_recovery/symbols:78:4: 'else' can't be used as an identifier because it's a keyword. |
| #else.foo; |
| ^^^^ |
| |
| parser/error_recovery/symbols:79:4: 'enum' can't be used as an identifier because it's a keyword. |
| #enum.foo; |
| ^^^^ |
| |
| parser/error_recovery/symbols:80:4: 'extends' can't be used as an identifier because it's a keyword. |
| #extends.foo; |
| ^^^^^^^ |
| |
| parser/error_recovery/symbols:81:4: 'false' can't be used as an identifier because it's a keyword. |
| #false.foo; |
| ^^^^^ |
| |
| parser/error_recovery/symbols:82:4: 'final' can't be used as an identifier because it's a keyword. |
| #final.foo; |
| ^^^^^ |
| |
| parser/error_recovery/symbols:83:4: 'finally' can't be used as an identifier because it's a keyword. |
| #finally.foo; |
| ^^^^^^^ |
| |
| parser/error_recovery/symbols:84:4: 'for' can't be used as an identifier because it's a keyword. |
| #for.foo; |
| ^^^ |
| |
| parser/error_recovery/symbols:85:4: 'if' can't be used as an identifier because it's a keyword. |
| #if.foo; |
| ^^ |
| |
| parser/error_recovery/symbols:86:4: 'in' can't be used as an identifier because it's a keyword. |
| #in.foo; |
| ^^ |
| |
| parser/error_recovery/symbols:87:4: 'is' can't be used as an identifier because it's a keyword. |
| #is.foo; |
| ^^ |
| |
| parser/error_recovery/symbols:88:4: 'new' can't be used as an identifier because it's a keyword. |
| #new.foo; |
| ^^^ |
| |
| parser/error_recovery/symbols:89:4: 'null' can't be used as an identifier because it's a keyword. |
| #null.foo; |
| ^^^^ |
| |
| parser/error_recovery/symbols:90:4: 'rethrow' can't be used as an identifier because it's a keyword. |
| #rethrow.foo; |
| ^^^^^^^ |
| |
| parser/error_recovery/symbols:91:4: 'return' can't be used as an identifier because it's a keyword. |
| #return.foo; |
| ^^^^^^ |
| |
| parser/error_recovery/symbols:92:4: 'super' can't be used as an identifier because it's a keyword. |
| #super.foo; |
| ^^^^^ |
| |
| parser/error_recovery/symbols:93:4: 'switch' can't be used as an identifier because it's a keyword. |
| #switch.foo; |
| ^^^^^^ |
| |
| parser/error_recovery/symbols:94:4: 'this' can't be used as an identifier because it's a keyword. |
| #this.foo; |
| ^^^^ |
| |
| parser/error_recovery/symbols:95:4: 'throw' can't be used as an identifier because it's a keyword. |
| #throw.foo; |
| ^^^^^ |
| |
| parser/error_recovery/symbols:96:4: 'true' can't be used as an identifier because it's a keyword. |
| #true.foo; |
| ^^^^ |
| |
| parser/error_recovery/symbols:97:4: 'try' can't be used as an identifier because it's a keyword. |
| #try.foo; |
| ^^^ |
| |
| parser/error_recovery/symbols:98:4: 'var' can't be used as an identifier because it's a keyword. |
| #var.foo; |
| ^^^ |
| |
| parser/error_recovery/symbols:99:4: 'while' can't be used as an identifier because it's a keyword. |
| #while.foo; |
| ^^^^^ |
| |
| parser/error_recovery/symbols:100:4: 'with' can't be used as an identifier because it's a keyword. |
| #with.foo; |
| ^^^^ |
| |
| beginCompilationUnit(main) |
| beginMetadataStar(main) |
| endMetadataStar(0) |
| beginTopLevelMember(main) |
| beginTopLevelMethod(, null, null) |
| handleNoType() |
| handleIdentifier(main, topLevelFunctionDeclaration) |
| handleNoTypeVariables(() |
| beginFormalParameters((, MemberKind.TopLevelMethod) |
| endFormalParameters(0, (, ), MemberKind.TopLevelMethod) |
| handleAsyncModifier(null, null) |
| beginBlockFunctionBody({) |
| beginLiteralSymbol(#) |
| handleSymbolVoid(void) |
| endLiteralSymbol(#, 1) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| handleSymbolVoid(void) |
| endLiteralSymbol(#, 1) |
| handleIdentifier(foo, expressionContinuation) |
| handleNoTypeArguments(;) |
| handleNoArguments(;) |
| handleSend(foo, ;) |
| handleEndingBinaryExpression(., foo) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| handleIdentifier(foo, literalSymbol) |
| handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'void' 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: void}], void, void) |
| handleIdentifier(void, literalSymbolContinuation) |
| endLiteralSymbol(#, 2) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| 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, literalSymbol) |
| endLiteralSymbol(#, 1) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| 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, literalSymbol) |
| endLiteralSymbol(#, 1) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| 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, literalSymbol) |
| endLiteralSymbol(#, 1) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| 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, literalSymbol) |
| endLiteralSymbol(#, 1) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| 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, literalSymbol) |
| endLiteralSymbol(#, 1) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| 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, literalSymbol) |
| endLiteralSymbol(#, 1) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| 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, literalSymbol) |
| endLiteralSymbol(#, 1) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| 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, literalSymbol) |
| endLiteralSymbol(#, 1) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| 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, literalSymbol) |
| endLiteralSymbol(#, 1) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| 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, literalSymbol) |
| endLiteralSymbol(#, 1) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| 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, literalSymbol) |
| endLiteralSymbol(#, 1) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| 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, literalSymbol) |
| endLiteralSymbol(#, 1) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| 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, literalSymbol) |
| endLiteralSymbol(#, 1) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| 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, literalSymbol) |
| endLiteralSymbol(#, 1) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| 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, literalSymbol) |
| endLiteralSymbol(#, 1) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| 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, literalSymbol) |
| endLiteralSymbol(#, 1) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| 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, literalSymbol) |
| endLiteralSymbol(#, 1) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| 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, literalSymbol) |
| endLiteralSymbol(#, 1) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| 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, literalSymbol) |
| endLiteralSymbol(#, 1) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| 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, literalSymbol) |
| endLiteralSymbol(#, 1) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| 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, literalSymbol) |
| endLiteralSymbol(#, 1) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| 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, literalSymbol) |
| endLiteralSymbol(#, 1) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| 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, literalSymbol) |
| endLiteralSymbol(#, 1) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| 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, literalSymbol) |
| endLiteralSymbol(#, 1) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| 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, literalSymbol) |
| endLiteralSymbol(#, 1) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'this' 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: this}], this, this) |
| handleIdentifier(this, literalSymbol) |
| endLiteralSymbol(#, 1) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'throw' 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: throw}], throw, throw) |
| handleIdentifier(throw, literalSymbol) |
| endLiteralSymbol(#, 1) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'true' 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: true}], true, true) |
| handleIdentifier(true, literalSymbol) |
| endLiteralSymbol(#, 1) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'try' 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: try}], try, try) |
| handleIdentifier(try, literalSymbol) |
| endLiteralSymbol(#, 1) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'var' 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: var}], var, var) |
| handleIdentifier(var, literalSymbol) |
| endLiteralSymbol(#, 1) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'while' 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: while}], while, while) |
| handleIdentifier(while, literalSymbol) |
| endLiteralSymbol(#, 1) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'with' 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: with}], with, with) |
| handleIdentifier(with, literalSymbol) |
| endLiteralSymbol(#, 1) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| handleIdentifier(foo, literalSymbol) |
| 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, literalSymbolContinuation) |
| endLiteralSymbol(#, 2) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| handleIdentifier(foo, literalSymbol) |
| 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, literalSymbolContinuation) |
| endLiteralSymbol(#, 2) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| handleIdentifier(foo, literalSymbol) |
| 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, literalSymbolContinuation) |
| endLiteralSymbol(#, 2) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| handleIdentifier(foo, literalSymbol) |
| 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, literalSymbolContinuation) |
| endLiteralSymbol(#, 2) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| handleIdentifier(foo, literalSymbol) |
| 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, literalSymbolContinuation) |
| endLiteralSymbol(#, 2) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| handleIdentifier(foo, literalSymbol) |
| 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, literalSymbolContinuation) |
| endLiteralSymbol(#, 2) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| handleIdentifier(foo, literalSymbol) |
| 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, literalSymbolContinuation) |
| endLiteralSymbol(#, 2) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| handleIdentifier(foo, literalSymbol) |
| 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, literalSymbolContinuation) |
| endLiteralSymbol(#, 2) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| handleIdentifier(foo, literalSymbol) |
| 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, literalSymbolContinuation) |
| endLiteralSymbol(#, 2) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| handleIdentifier(foo, literalSymbol) |
| 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, literalSymbolContinuation) |
| endLiteralSymbol(#, 2) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| handleIdentifier(foo, literalSymbol) |
| 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, literalSymbolContinuation) |
| endLiteralSymbol(#, 2) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| handleIdentifier(foo, literalSymbol) |
| 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, literalSymbolContinuation) |
| endLiteralSymbol(#, 2) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| handleIdentifier(foo, literalSymbol) |
| 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, literalSymbolContinuation) |
| endLiteralSymbol(#, 2) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| handleIdentifier(foo, literalSymbol) |
| 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, literalSymbolContinuation) |
| endLiteralSymbol(#, 2) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| handleIdentifier(foo, literalSymbol) |
| 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, literalSymbolContinuation) |
| endLiteralSymbol(#, 2) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| handleIdentifier(foo, literalSymbol) |
| 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, literalSymbolContinuation) |
| endLiteralSymbol(#, 2) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| handleIdentifier(foo, literalSymbol) |
| 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, literalSymbolContinuation) |
| endLiteralSymbol(#, 2) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| handleIdentifier(foo, literalSymbol) |
| 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, literalSymbolContinuation) |
| endLiteralSymbol(#, 2) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| handleIdentifier(foo, literalSymbol) |
| 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, literalSymbolContinuation) |
| endLiteralSymbol(#, 2) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| handleIdentifier(foo, literalSymbol) |
| 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, literalSymbolContinuation) |
| endLiteralSymbol(#, 2) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| handleIdentifier(foo, literalSymbol) |
| 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, literalSymbolContinuation) |
| endLiteralSymbol(#, 2) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| handleIdentifier(foo, literalSymbol) |
| 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, literalSymbolContinuation) |
| endLiteralSymbol(#, 2) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| handleIdentifier(foo, literalSymbol) |
| 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, literalSymbolContinuation) |
| endLiteralSymbol(#, 2) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| handleIdentifier(foo, literalSymbol) |
| 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, literalSymbolContinuation) |
| endLiteralSymbol(#, 2) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| handleIdentifier(foo, literalSymbol) |
| 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, literalSymbolContinuation) |
| endLiteralSymbol(#, 2) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| handleIdentifier(foo, literalSymbol) |
| handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'this' 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: this}], this, this) |
| handleIdentifier(this, literalSymbolContinuation) |
| endLiteralSymbol(#, 2) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| handleIdentifier(foo, literalSymbol) |
| handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'throw' 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: throw}], throw, throw) |
| handleIdentifier(throw, literalSymbolContinuation) |
| endLiteralSymbol(#, 2) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| handleIdentifier(foo, literalSymbol) |
| handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'true' 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: true}], true, true) |
| handleIdentifier(true, literalSymbolContinuation) |
| endLiteralSymbol(#, 2) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| handleIdentifier(foo, literalSymbol) |
| handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'try' 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: try}], try, try) |
| handleIdentifier(try, literalSymbolContinuation) |
| endLiteralSymbol(#, 2) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| handleIdentifier(foo, literalSymbol) |
| handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'var' 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: var}], var, var) |
| handleIdentifier(var, literalSymbolContinuation) |
| endLiteralSymbol(#, 2) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| handleIdentifier(foo, literalSymbol) |
| handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'while' 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: while}], while, while) |
| handleIdentifier(while, literalSymbolContinuation) |
| endLiteralSymbol(#, 2) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| handleIdentifier(foo, literalSymbol) |
| handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'with' 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: with}], with, with) |
| handleIdentifier(with, literalSymbolContinuation) |
| endLiteralSymbol(#, 2) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| 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, literalSymbol) |
| handleIdentifier(foo, literalSymbolContinuation) |
| endLiteralSymbol(#, 2) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| 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, literalSymbol) |
| handleIdentifier(foo, literalSymbolContinuation) |
| endLiteralSymbol(#, 2) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| 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, literalSymbol) |
| handleIdentifier(foo, literalSymbolContinuation) |
| endLiteralSymbol(#, 2) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| 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, literalSymbol) |
| handleIdentifier(foo, literalSymbolContinuation) |
| endLiteralSymbol(#, 2) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| 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, literalSymbol) |
| handleIdentifier(foo, literalSymbolContinuation) |
| endLiteralSymbol(#, 2) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| 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, literalSymbol) |
| handleIdentifier(foo, literalSymbolContinuation) |
| endLiteralSymbol(#, 2) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| 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, literalSymbol) |
| handleIdentifier(foo, literalSymbolContinuation) |
| endLiteralSymbol(#, 2) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| 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, literalSymbol) |
| handleIdentifier(foo, literalSymbolContinuation) |
| endLiteralSymbol(#, 2) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| 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, literalSymbol) |
| handleIdentifier(foo, literalSymbolContinuation) |
| endLiteralSymbol(#, 2) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| 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, literalSymbol) |
| handleIdentifier(foo, literalSymbolContinuation) |
| endLiteralSymbol(#, 2) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| 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, literalSymbol) |
| handleIdentifier(foo, literalSymbolContinuation) |
| endLiteralSymbol(#, 2) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| 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, literalSymbol) |
| handleIdentifier(foo, literalSymbolContinuation) |
| endLiteralSymbol(#, 2) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| 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, literalSymbol) |
| handleIdentifier(foo, literalSymbolContinuation) |
| endLiteralSymbol(#, 2) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| 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, literalSymbol) |
| handleIdentifier(foo, literalSymbolContinuation) |
| endLiteralSymbol(#, 2) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| 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, literalSymbol) |
| handleIdentifier(foo, literalSymbolContinuation) |
| endLiteralSymbol(#, 2) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| 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, literalSymbol) |
| handleIdentifier(foo, literalSymbolContinuation) |
| endLiteralSymbol(#, 2) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| 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, literalSymbol) |
| handleIdentifier(foo, literalSymbolContinuation) |
| endLiteralSymbol(#, 2) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| 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, literalSymbol) |
| handleIdentifier(foo, literalSymbolContinuation) |
| endLiteralSymbol(#, 2) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| 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, literalSymbol) |
| handleIdentifier(foo, literalSymbolContinuation) |
| endLiteralSymbol(#, 2) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| 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, literalSymbol) |
| handleIdentifier(foo, literalSymbolContinuation) |
| endLiteralSymbol(#, 2) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| 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, literalSymbol) |
| handleIdentifier(foo, literalSymbolContinuation) |
| endLiteralSymbol(#, 2) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| 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, literalSymbol) |
| handleIdentifier(foo, literalSymbolContinuation) |
| endLiteralSymbol(#, 2) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| 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, literalSymbol) |
| handleIdentifier(foo, literalSymbolContinuation) |
| endLiteralSymbol(#, 2) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| 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, literalSymbol) |
| handleIdentifier(foo, literalSymbolContinuation) |
| endLiteralSymbol(#, 2) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| 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, literalSymbol) |
| handleIdentifier(foo, literalSymbolContinuation) |
| endLiteralSymbol(#, 2) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'this' 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: this}], this, this) |
| handleIdentifier(this, literalSymbol) |
| handleIdentifier(foo, literalSymbolContinuation) |
| endLiteralSymbol(#, 2) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'throw' 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: throw}], throw, throw) |
| handleIdentifier(throw, literalSymbol) |
| handleIdentifier(foo, literalSymbolContinuation) |
| endLiteralSymbol(#, 2) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'true' 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: true}], true, true) |
| handleIdentifier(true, literalSymbol) |
| handleIdentifier(foo, literalSymbolContinuation) |
| endLiteralSymbol(#, 2) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'try' 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: try}], try, try) |
| handleIdentifier(try, literalSymbol) |
| handleIdentifier(foo, literalSymbolContinuation) |
| endLiteralSymbol(#, 2) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'var' 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: var}], var, var) |
| handleIdentifier(var, literalSymbol) |
| handleIdentifier(foo, literalSymbolContinuation) |
| endLiteralSymbol(#, 2) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'while' 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: while}], while, while) |
| handleIdentifier(while, literalSymbol) |
| handleIdentifier(foo, literalSymbolContinuation) |
| endLiteralSymbol(#, 2) |
| handleExpressionStatement(#, ;) |
| beginLiteralSymbol(#) |
| handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'with' 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: with}], with, with) |
| handleIdentifier(with, literalSymbol) |
| handleIdentifier(foo, literalSymbolContinuation) |
| endLiteralSymbol(#, 2) |
| handleExpressionStatement(#, ;) |
| endBlockFunctionBody(99, {, }) |
| endTopLevelMethod(main, null, }) |
| endTopLevelDeclaration(}) |
| endCompilationUnit(1, ) |
