Examples with MissingPrimaryExpressionTree com.google.javascript.jscomp.parsing.parser.trees.MissingPrimaryExpressionTree used on opensource projects

Example 1 with MissingPrimaryExpressionTree

use of com.google.javascript.jscomp.parsing.parser.trees.MissingPrimaryExpressionTree in project closure-compiler by google.

the class Parser method parseCoverParenthesizedExpressionAndArrowParameterList.

// 12.2 Primary Expression
// CoverParenthesizedExpressionAndArrowParameterList ::=
// ( Expression )
// ( Expression, )
// ( )
// ( ... BindingIdentifier )
// ( Expression , ... BindingIdentifier )
private ParseTree parseCoverParenthesizedExpressionAndArrowParameterList() {
    if (peekType(1) == TokenType.FOR) {
        return parseGeneratorComprehension();
    }
    SourcePosition start = getTreeStartLocation();
    eat(TokenType.OPEN_PAREN);
    // Case ( )
    if (peek(TokenType.CLOSE_PAREN)) {
        eat(TokenType.CLOSE_PAREN);
        if (peek(TokenType.ARROW)) {
            return new FormalParameterListTree(getTreeLocation(start), ImmutableList.<ParseTree>of(), /* hasTrailingComma= */
            false, ImmutableList.<SourcePosition>of());
        } else {
            reportError("invalid parenthesized expression");
            return new MissingPrimaryExpressionTree(getTreeLocation(start));
        }
    }
    // Case ( ... BindingIdentifier )
    if (peek(TokenType.ELLIPSIS)) {
        ImmutableList<ParseTree> params = ImmutableList.of(parseParameter());
        eat(TokenType.CLOSE_PAREN);
        if (peek(TokenType.ARROW)) {
            return new FormalParameterListTree(getTreeLocation(start), params, /* hasTrailingComma= */
            false, ImmutableList.<SourcePosition>of());
        } else {
            reportError("invalid parenthesized expression");
            return new MissingPrimaryExpressionTree(getTreeLocation(start));
        }
    }
    // For either of the three remaining cases:
    // ( Expression )
    // ( Expression, )
    // ( Expression, ...BindingIdentifier )
    // we can parse as an expression.
    ParseTree result = parseExpression();
    // case.
    if (peek(TokenType.COMMA)) {
        if (peek(1, TokenType.CLOSE_PAREN)) {
            // Create the formal parameter list here so we can record
            // the trailing comma
            resetScanner(start);
            // parseFormalParameterList will take care of reporting errors.
            return parseFormalParameterList();
        } else {
            eat(TokenType.COMMA);
            // Since we already parsed as an expression, we will guaranteed reparse this expression
            // as an arrow function parameter list, but just leave it as a comma expression for now.
            result = new CommaExpressionTree(getTreeLocation(start), ImmutableList.of(result, parseParameter()));
        }
    }
    eat(TokenType.CLOSE_PAREN);
    return new ParenExpressionTree(getTreeLocation(start), result);
}

Example 2 with MissingPrimaryExpressionTree

use of com.google.javascript.jscomp.parsing.parser.trees.MissingPrimaryExpressionTree in project closure-compiler by google.

the class Parser method parseMissingPrimaryExpression.

private ParseTree parseMissingPrimaryExpression() {
    SourcePosition start = getTreeStartLocation();
    nextToken();
    reportError("primary expression expected");
    return new MissingPrimaryExpressionTree(getTreeLocation(start));
}

Example 3 with MissingPrimaryExpressionTree

use of com.google.javascript.jscomp.parsing.parser.trees.MissingPrimaryExpressionTree in project closure-compiler by google.

the class Parser method parseAssignment.

private ParseTree parseAssignment(Expression expressionIn) {
    if (peek(TokenType.YIELD) && inGeneratorContext()) {
        return parseYield(expressionIn);
    }
    SourcePosition start = getTreeStartLocation();
    ParseTree left = parseConditional(expressionIn);
    if (isStartOfAsyncArrowFunction(left)) {
        // re-evaluate as an async arrow function.
        resetScanner(left);
        return parseAsyncArrowFunction(expressionIn);
    }
    if (peek(TokenType.ARROW)) {
        return completeAssignmentExpressionParseAtArrow(left, expressionIn);
    }
    if (peekAssignmentOperator()) {
        left = transformLeftHandSideExpression(left);
        if (!left.isValidAssignmentTarget()) {
            reportError("invalid assignment target");
            return new MissingPrimaryExpressionTree(getTreeLocation(getTreeStartLocation()));
        }
        Token operator = nextToken();
        ParseTree right = parseAssignment(expressionIn);
        return new BinaryOperatorTree(getTreeLocation(start), left, operator, right);
    }
    return left;
}

Example 4 with MissingPrimaryExpressionTree

use of com.google.javascript.jscomp.parsing.parser.trees.MissingPrimaryExpressionTree in project closure-compiler by google.

the class Parser method parseArrayPattern.

// Pattern ::= ... | "[" Element? ("," Element?)* "]"
private ParseTree parseArrayPattern(PatternKind kind) {
    SourcePosition start = getTreeStartLocation();
    ImmutableList.Builder<ParseTree> elements = ImmutableList.builder();
    eat(TokenType.OPEN_SQUARE);
    while (peek(TokenType.COMMA) || peekArrayPatternElement()) {
        if (peek(TokenType.COMMA)) {
            SourcePosition nullStart = getTreeStartLocation();
            eat(TokenType.COMMA);
            elements.add(new NullTree(getTreeLocation(nullStart)));
        } else {
            elements.add(parsePatternAssignmentTarget(kind));
            if (peek(TokenType.COMMA)) {
                // Consume the comma separator
                eat(TokenType.COMMA);
            } else {
                // Otherwise we must be done
                break;
            }
        }
    }
    if (peek(TokenType.ELLIPSIS)) {
        recordFeatureUsed(Feature.ARRAY_PATTERN_REST);
        elements.add(parseIterRest(kind));
    }
    if (eat(TokenType.CLOSE_SQUARE) == null) {
        // source has syntactic errors.
        return new MissingPrimaryExpressionTree(getTreeLocation(getTreeStartLocation()));
    }
    return new ArrayPatternTree(getTreeLocation(start), elements.build());
}