private ParseTree parseAssignmentExpression() { return parseAssignment(Expression.NORMAL); }
private ParseTree parseAssignmentExpression() { return parseAssignment(Expression.NORMAL); }
private ParseTree parseInitializer(Expression expressionIn) { eat(TokenType.EQUAL); return parseAssignment(expressionIn); }
private ParseTree parseInitializer(Expression expressionIn) { eat(TokenType.EQUAL); return parseAssignment(expressionIn); }
private ParseTree parseArrowFunctionBody(Expression expressionIn, FunctionFlavor functionFlavor) { functionContextStack.addLast(functionFlavor); ParseTree arrowFunctionBody; if (peek(TokenType.OPEN_CURLY)) { arrowFunctionBody = parseFunctionBody(); } else { arrowFunctionBody = parseAssignment(expressionIn); } functionContextStack.removeLast(); return arrowFunctionBody; }
private ParseTree parse(Expression expressionIn) { SourcePosition start = getTreeStartLocation(); ParseTree result = parseAssignment(expressionIn); if (peek(TokenType.COMMA) && !peek(1, TokenType.SPREAD)) { ImmutableList.Builder<ParseTree> exprs = ImmutableList.builder(); exprs.add(result); while (peek(TokenType.COMMA) && !peek(1, TokenType.SPREAD)) { eat(TokenType.COMMA); exprs.add(parseAssignment(expressionIn)); } return new CommaExpressionTree(getTreeLocation(start), exprs.build()); } return result; }
private ParseTree parse(Expression expressionIn) { SourcePosition start = getTreeStartLocation(); ParseTree result = parseAssignment(expressionIn); if (peek(TokenType.COMMA) && !peek(1, TokenType.SPREAD)) { ImmutableList.Builder<ParseTree> exprs = ImmutableList.builder(); exprs.add(result); while (peek(TokenType.COMMA) && !peek(1, TokenType.SPREAD)) { eat(TokenType.COMMA); exprs.add(parseAssignment(expressionIn)); } return new CommaExpressionTree(getTreeLocation(start), exprs.build()); } return result; }
private ParseTree parseConditional(Expression expressionIn) { SourcePosition start = getTreeStartLocation(); ParseTree condition = parseLogicalOR(expressionIn); if (peek(TokenType.QUESTION)) { eat(TokenType.QUESTION); ParseTree left = parseAssignment(expressionIn); eat(TokenType.COLON); ParseTree right = parseAssignment(expressionIn); return new ConditionalExpressionTree( getTreeLocation(start), condition, left, right); } return condition; }
private ParseTree parseConditional(Expression expressionIn) { SourcePosition start = getTreeStartLocation(); ParseTree condition = parseLogicalOR(expressionIn); if (peek(TokenType.QUESTION)) { eat(TokenType.QUESTION); ParseTree left = parseAssignment(expressionIn); eat(TokenType.COLON); ParseTree right = parseAssignment(expressionIn); return new ConditionalExpressionTree( getTreeLocation(start), condition, left, right); } return condition; }
private ParseTree parseYield(Expression expressionIn) { SourcePosition start = getTreeStartLocation(); eat(TokenType.YIELD); boolean isYieldFor = false; ParseTree expression = null; if (!peekImplicitSemiColon()) { isYieldFor = eatOpt(TokenType.STAR) != null; if (peekAssignmentExpression()) { expression = parseAssignment(expressionIn); } } return new YieldExpressionTree( getTreeLocation(start), isYieldFor, expression); }
private ParseTree parseYield(Expression expressionIn) { SourcePosition start = getTreeStartLocation(); eat(TokenType.YIELD); boolean isYieldAll = false; ParseTree expression = null; if (!peekImplicitSemiColon()) { isYieldAll = eatOpt(TokenType.STAR) != null; if (peekAssignmentExpression()) { expression = parseAssignment(expressionIn); } else if (isYieldAll) { reportError("yield* requires an expression"); } } return new YieldExpressionTree( getTreeLocation(start), isYieldAll, expression); }
private ParseTree parseArrowFunctionTail( SourcePosition start, GenericTypeListTree generics, FormalParameterListTree formalParameterList, Expression expressionIn) { inGeneratorContext.addLast(false); ParseTree returnType = null; if (peek(TokenType.COLON)) { returnType = parseTypeAnnotation(); } if (peekImplicitSemiColon()) { reportError("No newline allowed before '=>'"); } eat(TokenType.ARROW); ParseTree functionBody; if (peek(TokenType.OPEN_CURLY)) { functionBody = parseFunctionBody(); } else { functionBody = parseAssignment(expressionIn); } FunctionDeclarationTree declaration = new FunctionDeclarationTree( getTreeLocation(start), null, generics, false, false, false, null, FunctionDeclarationTree.Kind.ARROW, formalParameterList, returnType, functionBody); inGeneratorContext.removeLast(); return declaration; }
private ParseTree parseAssignment(Expression expressionIn) { if (peek(TokenType.YIELD) && inGeneratorContext()) { return parseYield(expressionIn); } SourcePosition start = getTreeStartLocation(); // TODO(blickly): Allow TypeScript syntax in arrow function parameters ParseTree left = parseConditional(expressionIn); if (peek(TokenType.ARROW)) { FormalParameterListTree params = transformArrowFunctionParameters(start, left); return parseArrowFunctionTail(start, null, params, expressionIn); } if (left.type == ParseTreeType.FORMAL_PARAMETER_LIST) { reportError("invalid paren expression"); } if (peekAssignmentOperator()) { left = transformLeftHandSideExpression(left); if (!left.isValidAssignmentTarget()) { reportError("invalid assignment target"); } Token operator = nextToken(); ParseTree right = parseAssignment(expressionIn); return new BinaryOperatorTree(getTreeLocation(start), left, operator, right); } return left; }
private ParseTree parseAssignment(Expression expressionIn) { if (peek(TokenType.YIELD) && inGeneratorContext()) { return parseYield(expressionIn); } SourcePosition start = getTreeStartLocation(); // TODO(blickly): Allow TypeScript syntax in arrow function parameters 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; }