private boolean peekAsyncMethod() { return peekPredefinedString(ASYNC) && !peekImplicitSemiColon(1) && (peekPropertyNameOrComputedProp(1) || (peek(1, TokenType.STAR) && peekPropertyNameOrComputedProp(2))); }
/** * Whether we have a spread expression or an assignment next. * * <p>This does not peek the operand for the spread expression. This means that * {@link #parseAssignmentOrSpread} might still fail when this returns true. */ private boolean peekAssignmentOrSpread() { return peek(TokenType.SPREAD) || peekAssignmentExpression(); }
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; }
/** * Returns true if the next token is of the expected type. Does not consume the token. */ private boolean peek(TokenType expectedType) { return peek(0, expectedType); }
private boolean peekAmbientNamespaceElement() { return peek(TokenType.VAR) || peek(TokenType.LET) || peek(TokenType.CONST) || peek(TokenType.FUNCTION) || peek(TokenType.CLASS) || peek(TokenType.INTERFACE) || peek(TokenType.ENUM) || peek(TokenType.MODULE) || peek(TokenType.NAMESPACE) || peek(TokenType.EXPORT); }
private ParseTree maybeParseColonType() { ParseTree type = null; if (peek(TokenType.COLON)) { type = parseTypeAnnotation(); } return type; }
private ImmutableList<ParseTree> parseGlobalSourceElements() { ImmutableList.Builder<ParseTree> result = ImmutableList.builder(); while (!peek(TokenType.END_OF_FILE)) { result.add(parseScriptElement()); } return result.build(); }
private ParseTree parseRestAssignmentTarget(PatternKind patternKind) { ParseTree patternAssignmentTarget = parsePatternAssignmentTargetNoDefault(patternKind); if (peek(TokenType.EQUAL)) { reportError("A default value cannot be specified after '...'"); } return patternAssignmentTarget; }
private ParseTree parseAssignmentOrSpread() { if (peek(TokenType.SPREAD)) { return parseSpreadExpression(); } return parseAssignmentExpression(); }
private ParseTree parseTypeReference() { SourcePosition start = getTreeStartLocation(); TypeNameTree typeName = parseTypeName(); if (!peek(TokenType.OPEN_ANGLE)) { return typeName; } return parseTypeArgumentList(start, typeName); }
private ParseTree parseParenTypeExpression() { ParseTree typeExpression; if (peek(TokenType.OPEN_PAREN)) { eat(TokenType.OPEN_PAREN); typeExpression = parseType(); eat(TokenType.CLOSE_PAREN); } else { typeExpression = parseRecordTypeExpression(); } return typeExpression; }
private ParseTree parseClassElement(boolean isAmbient) { if (peek(TokenType.SEMI_COLON)) { return parseEmptyStatement(); } else { PartialClassElement partialElement = getClassElementDefaults(); partialElement.isAmbient = isAmbient; partialElement.accessModifier = maybeParseAccessibilityModifier(); partialElement.isStatic = eatOpt(TokenType.STATIC) != null; return parseClassElement(partialElement); } }
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; }
private ParseTree parseLogicalAND(Expression expressionIn) { SourcePosition start = getTreeStartLocation(); ParseTree left = parseBitwiseOR(expressionIn); while (peek(TokenType.AND)) { Token operator = eat(TokenType.AND); ParseTree right = parseBitwiseOR(expressionIn); left = new BinaryOperatorTree(getTreeLocation(start), left, operator, right); } return left; }
private ParseTree parseBitwiseXOR(Expression expressionIn) { SourcePosition start = getTreeStartLocation(); ParseTree left = parseBitwiseAND(expressionIn); while (peek(TokenType.CARET)) { Token operator = eat(TokenType.CARET); ParseTree right = parseBitwiseAND(expressionIn); left = new BinaryOperatorTree(getTreeLocation(start), left, operator, right); } return left; }
private ParseTree parseBitwiseXOR(Expression expressionIn) { SourcePosition start = getTreeStartLocation(); ParseTree left = parseBitwiseAND(expressionIn); while (peek(TokenType.CARET)) { Token operator = eat(TokenType.CARET); ParseTree right = parseBitwiseAND(expressionIn); left = new BinaryOperatorTree(getTreeLocation(start), left, operator, right); } return left; }
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; }