private IdentifierExpressionTree parseIdentifierExpression() { SourcePosition start = getTreeStartLocation(); IdentifierToken identifier = eatId(); return new IdentifierExpressionTree(getTreeLocation(start), identifier); }
private ParseTree parseRegularExpressionLiteral() { SourcePosition start = getTreeStartLocation(); LiteralToken literal = nextRegularExpressionLiteralToken(); return new LiteralExpressionTree(getTreeLocation(start), literal); }
private ThisExpressionTree parseThisExpression() { SourcePosition start = getTreeStartLocation(); eat(TokenType.THIS); return new ThisExpressionTree(getTreeLocation(start)); }
private LiteralExpressionTree parseLiteralExpression() { SourcePosition start = getTreeStartLocation(); Token literal = nextLiteralToken(); return new LiteralExpressionTree(getTreeLocation(start), literal); }
private TypeNameTree parseTypeName() { SourcePosition start = getTreeStartLocation(); IdentifierToken token = eatIdOrKeywordAsId(); // for 'void'. return new TypeNameTree(getTreeLocation(start), buildIdentifierPath(token)); }
private ParseTree parseMissingPrimaryExpression() { SourcePosition start = getTreeStartLocation(); nextToken(); reportError("primary expression expected"); return new MissingPrimaryExpressionTree(getTreeLocation(start)); }
private ParseTree parseAmbientDeclaration() { SourcePosition start = getTreeStartLocation(); eat(TokenType.DECLARE); ParseTree declare = parseAmbientDeclarationHelper(); return new AmbientDeclarationTree(getTreeLocation(start), declare); }
private ParseTree parseRestParameter() { SourcePosition start = getTreeStartLocation(); eat(TokenType.SPREAD); return new RestParameterTree( getTreeLocation(start), parseRestAssignmentTarget(PatternKind.INITIALIZER)); }
private VariableStatementTree parseVariableStatement() { SourcePosition start = getTreeStartLocation(); VariableDeclarationListTree declarations = parseVariableDeclarationList(); eatPossibleImplicitSemiColon(); return new VariableStatementTree(getTreeLocation(start), declarations); }
private FinallyTree parseFinallyBlock() { SourcePosition start = getTreeStartLocation(); eat(TokenType.FINALLY); BlockTree finallyBlock = parseBlock(); return new FinallyTree(getTreeLocation(start), finallyBlock); }
private BlockTree parseFunctionBody() { SourcePosition start = getTreeStartLocation(); eat(TokenType.OPEN_CURLY); ImmutableList<ParseTree> result = parseSourceElementList(); eat(TokenType.CLOSE_CURLY); return new BlockTree(getTreeLocation(start), result); }
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 parseNewDotSomething() { // currently only "target" is valid after "new." SourcePosition start = getTreeStartLocation(); eat(TokenType.NEW); eat(TokenType.PERIOD); eatPredefinedString("target"); return new NewTargetExpressionTree(getTreeLocation(start)); }
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 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 parseBreakStatement() { SourcePosition start = getTreeStartLocation(); eat(TokenType.BREAK); IdentifierToken name = null; if (!peekImplicitSemiColon()) { name = eatIdOpt(); } eatPossibleImplicitSemiColon(); return new BreakStatementTree(getTreeLocation(start), name); }
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 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; }
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 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); }