private ParseTree parseSwitchStatement() { SourcePosition start = getTreeStartLocation(); eat(TokenType.SWITCH); eat(TokenType.OPEN_PAREN); ParseTree expression = parseExpression(); eat(TokenType.CLOSE_PAREN); eat(TokenType.OPEN_CURLY); ImmutableList<ParseTree> caseClauses = parseCaseClauses(); eat(TokenType.CLOSE_CURLY); return new SwitchStatementTree(getTreeLocation(start), expression, caseClauses); }
private ParseTree parseEnumDeclaration() { SourcePosition start = getTreeStartLocation(); eat(TokenType.ENUM); IdentifierToken name = eatId(); eat(TokenType.OPEN_CURLY); ImmutableList<ParseTree> members = parseEnumMembers(); eat(TokenType.CLOSE_CURLY); return new EnumDeclarationTree(getTreeLocation(start), name, members); }
private ParseTree parseBreakStatement() { SourcePosition start = getTreeStartLocation(); eat(TokenType.BREAK); IdentifierToken name = null; if (!peekImplicitSemiColon()) { name = eatIdOpt(); } eatPossibleImplicitSemiColon(); return new BreakStatementTree(getTreeLocation(start), name); }
private ParseTree parseForAwaitOfStatement(SourcePosition start, ParseTree initializer) { eatPredefinedString(PredefinedName.OF); ParseTree collection = parseExpression(); eat(TokenType.CLOSE_PAREN); ParseTree body = parseStatement(); return new ForAwaitOfStatementTree(getTreeLocation(start), initializer, collection, body); }
private ParseTree parseForOfStatement( SourcePosition start, ParseTree initializer) { eatPredefinedString(PredefinedName.OF); ParseTree collection = parseExpression(); eat(TokenType.CLOSE_PAREN); ParseTree body = parseStatement(); return new ForOfStatementTree( getTreeLocation(start), initializer, collection, body); }
private ParseTree parseArrayTypeExpression() { SourcePosition start = getTreeStartLocation(); ParseTree typeExpression = parseParenTypeExpression(); while (!peekImplicitSemiColon() && peek(TokenType.OPEN_SQUARE)) { eat(TokenType.OPEN_SQUARE); eat(TokenType.CLOSE_SQUARE); typeExpression = new ArrayTypeTree(getTreeLocation(start), typeExpression); } return typeExpression; }
private ParseTree parseRecordTypeExpression() { SourcePosition start = getTreeStartLocation(); ParseTree typeExpression; if (peek(TokenType.OPEN_CURLY)) { eat(TokenType.OPEN_CURLY); typeExpression = new RecordTypeTree(getTreeLocation(start), parseInterfaceElements()); eat(TokenType.CLOSE_CURLY); } else { typeExpression = parseTypeQuery(); } return typeExpression; }
private EmptyStatementTree parseEmptyStatement() { SourcePosition start = getTreeStartLocation(); eat(TokenType.SEMI_COLON); return new EmptyStatementTree(getTreeLocation(start)); }
private ThisExpressionTree parseThisExpression() { SourcePosition start = getTreeStartLocation(); eat(TokenType.THIS); return new ThisExpressionTree(getTreeLocation(start)); }
private SpreadExpressionTree parseSpreadExpression() { SourcePosition start = getTreeStartLocation(); eat(TokenType.SPREAD); ParseTree operand = parseAssignmentExpression(); return new SpreadExpressionTree(getTreeLocation(start), operand); }
private ParseTree parsePatternRest(PatternKind patternKind) { SourcePosition start = getTreeStartLocation(); eat(TokenType.SPREAD); ParseTree patternAssignmentTarget = parseRestAssignmentTarget(patternKind); return new AssignmentRestElementTree(getTreeLocation(start), patternAssignmentTarget); }
private ParseTree parseAmbientDeclaration() { SourcePosition start = getTreeStartLocation(); eat(TokenType.DECLARE); ParseTree declare = parseAmbientDeclarationHelper(); return new AmbientDeclarationTree(getTreeLocation(start), declare); }
private FinallyTree parseFinallyBlock() { SourcePosition start = getTreeStartLocation(); eat(TokenType.FINALLY); BlockTree finallyBlock = parseBlock(); return new FinallyTree(getTreeLocation(start), finallyBlock); }
public ProgramTree parseProgram() { try { SourcePosition start = getTreeStartLocation(); ImmutableList<ParseTree> sourceElements = parseGlobalSourceElements(); eat(TokenType.END_OF_FILE); return new ProgramTree( getTreeLocation(start), sourceElements, commentRecorder.getComments()); } catch (StackOverflowError e) { reportError("Too deep recursion while parsing"); return null; } }
private CallSignatureTree parseCallSignature(boolean isNew) { SourcePosition start = getTreeStartLocation(); if (isNew) { eat(TokenType.NEW); } GenericTypeListTree generics = maybeParseGenericTypes(); FormalParameterListTree params = parseFormalParameterList(ParamContext.SIGNATURE); ParseTree returnType = maybeParseColonType(); return new CallSignatureTree(getTreeLocation(start), isNew, generics, params, returnType); }
private ParseTree parseLogicalOR(Expression expressionIn) { SourcePosition start = getTreeStartLocation(); ParseTree left = parseLogicalAND(expressionIn); while (peek(TokenType.OR)) { Token operator = eat(TokenType.OR); ParseTree right = parseLogicalAND(expressionIn); left = new BinaryOperatorTree(getTreeLocation(start), left, operator, right); } return left; }
private ParseTree parseBitwiseAND(Expression expressionIn) { SourcePosition start = getTreeStartLocation(); ParseTree left = parseEquality(expressionIn); while (peek(TokenType.AMPERSAND)) { Token operator = eat(TokenType.AMPERSAND); ParseTree right = parseEquality(expressionIn); left = new BinaryOperatorTree(getTreeLocation(start), left, operator, right); } return left; }