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 ParseTree parseTypeReference() { SourcePosition start = getTreeStartLocation(); TypeNameTree typeName = parseTypeName(); if (!peek(TokenType.OPEN_ANGLE)) { return typeName; } return parseTypeArgumentList(start, typeName); }
private EmptyStatementTree parseEmptyStatement() { SourcePosition start = getTreeStartLocation(); eat(TokenType.SEMI_COLON); return new EmptyStatementTree(getTreeLocation(start)); }
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 SpreadExpressionTree parseSpreadExpression() { SourcePosition start = getTreeStartLocation(); eat(TokenType.SPREAD); ParseTree operand = parseAssignmentExpression(); return new SpreadExpressionTree(getTreeLocation(start), operand); }
private ExpressionStatementTree parseExpressionStatement() { SourcePosition start = getTreeStartLocation(); ParseTree expression = parseExpression(); eatPossibleImplicitSemiColon(); return new ExpressionStatementTree(getTreeLocation(start), expression); }
private ParseTree parsePatternRest(PatternKind patternKind) { SourcePosition start = getTreeStartLocation(); eat(TokenType.SPREAD); ParseTree patternAssignmentTarget = parseRestAssignmentTarget(patternKind); return new AssignmentRestElementTree(getTreeLocation(start), patternAssignmentTarget); }
private ParseTree parseAwaitExpression() { SourcePosition start = getTreeStartLocation(); if (functionContextStack.isEmpty() || !functionContextStack.peekLast().isAsynchronous) { reportError("'await' used in a non-async function context"); } eatPredefinedString(AWAIT); ParseTree expression = parseUnaryExpression(); return new AwaitExpressionTree(getTreeLocation(start), expression); }
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 parseNewDotSomething() { // currently only "target" is valid after "new." SourcePosition start = getTreeStartLocation(); eat(TokenType.NEW); eat(TokenType.PERIOD); eatPredefinedString("target"); return new NewTargetExpressionTree(getTreeLocation(start)); }
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 parseShiftExpression() { SourcePosition start = getTreeStartLocation(); ParseTree left = parseAdditiveExpression(); while (peekShiftOperator()) { Token operator = nextToken(); ParseTree right = parseAdditiveExpression(); 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 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 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); }