Lines Matching defs:expression
26 #include "src/parsing/expression-scope.h"
1140 // expression, where the relevant "function_kind" bit is of the function being
1166 // Use when parsing an expression that is known to not be a pattern or part of
1171 // These methods do not wrap the parsing of the expression inside a new
1211 ExpressionT ParseConditionalContinuation(ExpressionT expression, int pos);
1213 ExpressionT ParseCoalesceExpression(ExpressionT expression);
1220 V8_NOINLINE ExpressionT ParsePostfixContinuation(ExpressionT expression,
1223 ExpressionT ParseLeftHandSideContinuation(ExpressionT expression);
1228 ParseMemberExpressionContinuation(ExpressionT expression) {
1229 if (!Token::IsMember(peek())) return expression;
1230 return DoParseMemberExpressionContinuation(expression);
1232 ExpressionT DoParseMemberExpressionContinuation(ExpressionT expression);
1269 // Whether we're parsing a single-expression arrow function or something else.
1363 int stmt_pos, ExpressionT expression, int lhs_beg_pos, int lhs_end_pos,
1389 // Checks if the expression is a valid reference expression (e.g., on the
1394 ExpressionT RewriteInvalidReferenceExpression(ExpressionT expression,
1399 bool IsValidReferenceExpression(ExpressionT expression);
1401 bool IsAssignableIdentifier(ExpressionT expression) {
1402 if (!impl()->IsIdentifier(expression)) return false;
1404 impl()->IsEvalOrArguments(impl()->AsIdentifier(expression))) {
1456 // optimizations. This checks if expression is an eval call, and if yes,
1458 Call::PossiblyEval CheckPossibleEvalCall(ExpressionT expression,
1461 if (impl()->IsIdentifier(expression) &&
1462 impl()->IsEval(impl()->AsIdentifier(expression)) && !is_optional_call) {
1495 // Stack of expression expression_scopes.
2058 ExpressionT expression;
2068 expression = ParseAssignmentExpressionCoverGrammar();
2070 ClassifyArrowParameter(&accumulation_scope, expr_pos, expression);
2071 list.Add(expression);
2093 // only a single assignment expression. The preparser would lose this
2095 if (list.length() == 1) return expression;
2129 // valid expression.
2301 ExpressionT expression = ParseAssignmentExpression();
2306 return expression;
2315 ExpressionT expression =
2319 if (!IsValidReferenceExpression(expression)) {
2332 return expression;
2463 // Make sure the name expression is a string since we need a Name for
2710 // Make sure the name expression is a string since we need a Name for
2904 ExpressionT expression = ParseConditionalExpression();
2908 if (!Token::IsArrowOrAssignmentOp(op)) return expression;
2914 if (!impl()->IsIdentifier(expression) && !expression->is_parenthesized()) {
2916 Scanner::Location(expression->position(), position()),
2931 impl()->DeclareArrowFunctionFormalParameters(¶meters, expression, loc);
2933 expression = ParseArrowFunctionLiteral(parameters);
2935 return expression;
2938 if (V8_LIKELY(impl()->IsAssignableIdentifier(expression))) {
2939 if (expression->is_parenthesized()) {
2945 } else if (expression->IsProperty()) {
2950 } else if (expression->IsPattern() && op == Token::ASSIGN) {
2952 if (expression->is_parenthesized()) {
2965 expression_scope()->ValidateAsPattern(expression, lhs_beg_pos,
2968 DCHECK(!IsValidReferenceExpression(expression));
2972 expression = RewriteInvalidReferenceExpression(
2973 expression, lhs_beg_pos, end_position(),
2984 impl()->CheckAssigningFunctionLiteralToProperty(expression, right);
2988 // expression.
2995 impl()->SetFunctionNameFromIdentifierRef(right, expression);
3005 if (impl()->IsThisProperty(expression)) function_state_->AddProperty();
3013 return factory()->NewAssignment(op, expression, right, op_position);
3032 ExpressionT expression = impl()->NullExpression();
3053 expression = ParseAssignmentExpressionCoverGrammar();
3059 ExpressionT yieldstar = factory()->NewYieldStar(expression, pos);
3074 factory()->NewYield(expression, pos, Suspend::kOnExceptionThrow);
3089 ExpressionT expression = ParseLogicalExpression();
3091 ? ParseConditionalContinuation(expression, pos)
3092 : expression;
3104 ExpressionT expression = ParseBinaryExpression(6);
3108 expression = ParseBinaryContinuation(expression, 4, prec1);
3110 expression = ParseCoalesceExpression(expression);
3112 return expression;
3117 ParserBase<Impl>::ParseCoalesceExpression(ExpressionT expression) {
3140 expression =
3141 factory()->NewBinaryOperation(Token::NULLISH, expression, y, pos);
3142 impl()->RecordBinaryOperationSourceRange(expression, right_range);
3145 impl()->CollapseNaryExpression(&expression, y, Token::NULLISH, pos,
3149 return expression;
3154 ParserBase<Impl>::ParseConditionalContinuation(ExpressionT expression,
3162 // In parsing the first assignment expression in conditional
3174 ExpressionT expr = factory()->NewConditional(expression, left, right, pos);
3272 ExpressionT expression = ParseUnaryExpression();
3276 if (impl()->IsIdentifier(expression) && is_strict(language_mode())) {
3282 if (impl()->IsPrivateReference(expression)) {
3295 // Allow the parser's implementation to rewrite the expression.
3296 return impl()->BuildUnaryExpression(expression, op, pos);
3301 if (V8_LIKELY(IsValidReferenceExpression(expression))) {
3302 if (impl()->IsIdentifier(expression)) {
3307 expression = RewriteInvalidReferenceExpression(
3308 expression, expression_position, end_position(),
3312 return factory()->NewCountOperation(op, true /* prefix */, expression,
3378 ExpressionT expression = ParseLeftHandSideExpression();
3381 return expression;
3383 return ParsePostfixContinuation(expression, lhs_beg_pos);
3388 ParserBase<Impl>::ParsePostfixContinuation(ExpressionT expression,
3390 if (V8_UNLIKELY(!IsValidReferenceExpression(expression))) {
3392 expression = RewriteInvalidReferenceExpression(
3393 expression, lhs_beg_pos, end_position(),
3396 if (impl()->IsIdentifier(expression)) {
3401 return factory()->NewCountOperation(next, false /* postfix */, expression,
3580 // Examples of new expression:
3619 // The expression can still continue with . or [ after the arguments.
3686 // Parse the initial primary or function expression.
3811 ParserBase<Impl>::DoParseMemberExpressionContinuation(ExpressionT expression) {
3822 expression = factory()->NewProperty(expression, index, pos);
3831 expression = factory()->NewProperty(expression, key, pos);
3841 if (expression->IsFunctionLiteral()) {
3844 expression->AsFunctionLiteral()->SetShouldEagerCompile();
3847 expression = ParseTemplateLiteral(expression, pos, true);
3852 return expression;
4018 // Assignments need the variable expression for the assignment LHS, and
4019 // for of/in will need it later, so create the expression now.
4022 // Otherwise, elide the variable expression and just declare it.
4049 // Don't infer if it is "a = function(){...}();"-like expression.
4338 ExpressionT expression = ParseAssignmentExpression();
4342 impl()->RewriteAsyncFunctionBody(&inner_body, block, expression);
4345 BuildReturnStatement(expression, expression->position()));
4516 // `=> ...` is never a valid expression, so report as syntax error.
4581 ExpressionT expression = ParseConditionalExpression();
4592 impl()->DeclareArrowFunctionFormalParameters(¶meters, expression,
4619 // Single-expression body
4901 // text followed by a substitution expression), finalized by a single
4939 // If we open with a TEMPLATE_SPAN, we must scan the subsequent expression,
4948 ExpressionT expression = ParseExpressionCoverGrammar();
4949 impl()->AddTemplateExpression(&ts, expression);
4957 // If we didn't die parsing that expression, our next token should be a
4974 ParserBase<Impl>::RewriteInvalidReferenceExpression(ExpressionT expression,
4978 DCHECK(!IsValidReferenceExpression(expression));
4979 if (impl()->IsIdentifier(expression)) {
4981 DCHECK(impl()->IsEvalOrArguments(impl()->AsIdentifier(expression)));
4987 if (expression->IsCall() && !expression->AsCall()->is_tagged_template() &&
5000 return factory()->NewProperty(expression, error, beg_pos);
5038 bool ParserBase<Impl>::IsValidReferenceExpression(ExpressionT expression) {
5039 return IsAssignableIdentifier(expression) || expression->IsProperty();
5054 // assignment pattern errors if the parsed expression is more complex.
5480 // The whole expression was a single identifier, and not, e.g.,
5510 // Parsed expression statement, followed by semicolon.
5999 // We parse a declaration/expression after the 'for (' and then read the first
6000 // expression/declaration before we know if this is a for or a for-each.
6079 ExpressionT expression;
6084 expression = ParseExpressionCoverGrammar();
6086 // check if the token is ASYNC after parsing the expression.
6100 if (expression->IsPattern()) {
6101 parsing_scope.ValidatePattern(expression, lhs_beg_pos, lhs_end_pos);
6103 expression = parsing_scope.ValidateAndRewriteReference(
6104 expression, lhs_beg_pos, lhs_end_pos);
6113 stmt_pos, expression, lhs_beg_pos, lhs_end_pos, &for_info, labels,
6116 // Initializer is just an expression.
6117 init = factory()->NewExpressionStatement(expression, lhs_beg_pos);
6219 int stmt_pos, ExpressionT expression, int lhs_beg_pos, int lhs_end_pos,
6243 loop->Initialize(expression, enumerable, body);