Skip to content

Commit cd6f40b

Browse files
charliermarshcharliermarsh
committed
Share postfix parsing between identifier and atom paths
1 parent c5121d6 commit cd6f40b

1 file changed

Lines changed: 74 additions & 67 deletions

File tree

‎crates/ruff_python_parser/src/parser/expression.rs‎

Lines changed: 74 additions & 67 deletions
Original file line numberDiff line numberDiff line change
@@ -337,88 +337,95 @@ impl<'src> Parser<'src> {
337337
let token = self.current_token_kind();
338338
let start = self.node_start();
339339

340-
if let Some(unary_op) = token.as_unary_operator() {
341-
let expr = self.parse_unary_expression(unary_op, context);
340+
let mut is_parenthesized = false;
341+
let lhs = if token == TokenKind::Identifier {
342+
Expr::Name(self.parse_name(context))
343+
} else {
344+
if let Some(unary_op) = token.as_unary_operator() {
345+
let expr = self.parse_unary_expression(unary_op, context);
342346

343-
if matches!(unary_op, UnaryOp::Not) {
344-
if left_precedence > OperatorPrecedence::Not {
345-
self.add_error(
346-
ParseErrorType::OtherError(
347-
"Boolean 'not' expression cannot be used here".to_string(),
348-
),
349-
&expr,
350-
);
351-
}
352-
} else {
353-
// > The power operator `**` binds less tightly than an arithmetic
354-
// > or bitwise unary operator on its right, that is, 2**-1 is 0.5.
355-
//
356-
// Reference: https://docs.python.org/3/reference/expressions.html#id21
357-
if left_precedence > OperatorPrecedence::PosNegBitNot
358-
&& left_precedence != OperatorPrecedence::Exponent
359-
{
360-
self.add_error(
361-
ParseErrorType::OtherError(format!(
362-
"Unary '{unary_op}' expression cannot be used here",
363-
)),
364-
&expr,
365-
);
347+
if matches!(unary_op, UnaryOp::Not) {
348+
if left_precedence > OperatorPrecedence::Not {
349+
self.add_error(
350+
ParseErrorType::OtherError(
351+
"Boolean 'not' expression cannot be used here".to_string(),
352+
),
353+
&expr,
354+
);
355+
}
356+
} else {
357+
// > The power operator `**` binds less tightly than an arithmetic
358+
// > or bitwise unary operator on its right, that is, 2**-1 is 0.5.
359+
//
360+
// Reference: https://docs.python.org/3/reference/expressions.html#id21
361+
if left_precedence > OperatorPrecedence::PosNegBitNot
362+
&& left_precedence != OperatorPrecedence::Exponent
363+
{
364+
self.add_error(
365+
ParseErrorType::OtherError(format!(
366+
"Unary '{unary_op}' expression cannot be used here",
367+
)),
368+
&expr,
369+
);
370+
}
366371
}
372+
373+
return Expr::UnaryOp(expr).into();
367374
}
368375

369-
return Expr::UnaryOp(expr).into();
370-
}
376+
match token {
377+
TokenKind::Star => {
378+
let starred_expr = self.parse_starred_expression(context);
371379

372-
match token {
373-
TokenKind::Star => {
374-
let starred_expr = self.parse_starred_expression(context);
380+
if left_precedence > OperatorPrecedence::None
381+
|| !context.is_starred_expression_allowed()
382+
{
383+
self.add_error(
384+
ParseErrorType::InvalidStarredExpressionUsage,
385+
&starred_expr,
386+
);
387+
}
375388

376-
if left_precedence > OperatorPrecedence::None
377-
|| !context.is_starred_expression_allowed()
378-
{
379-
self.add_error(ParseErrorType::InvalidStarredExpressionUsage, &starred_expr);
389+
return Expr::Starred(starred_expr).into();
380390
}
391+
TokenKind::Await => {
392+
let await_expr = self.parse_await_expression();
381393

382-
return Expr::Starred(starred_expr).into();
383-
}
384-
TokenKind::Await => {
385-
let await_expr = self.parse_await_expression();
394+
// `await` expressions cannot be nested
395+
if left_precedence >= OperatorPrecedence::Await {
396+
self.add_error(
397+
ParseErrorType::OtherError(
398+
"Await expression cannot be used here".to_string(),
399+
),
400+
&await_expr,
401+
);
402+
}
386403

387-
// `await` expressions cannot be nested
388-
if left_precedence >= OperatorPrecedence::Await {
389-
self.add_error(
390-
ParseErrorType::OtherError(
391-
"Await expression cannot be used here".to_string(),
392-
),
393-
&await_expr,
394-
);
404+
return Expr::Await(await_expr).into();
405+
}
406+
TokenKind::Lambda => {
407+
// Lambda expression isn't allowed in this context but we'll still parse it and
408+
// report an error for better recovery.
409+
let lambda_expr = self.parse_lambda_expr();
410+
self.add_error(ParseErrorType::InvalidLambdaExpressionUsage, &lambda_expr);
411+
return Expr::Lambda(lambda_expr).into();
395412
}
413+
TokenKind::Yield => {
414+
let expr = self.parse_yield_expression();
396415

397-
return Expr::Await(await_expr).into();
398-
}
399-
TokenKind::Lambda => {
400-
// Lambda expression isn't allowed in this context but we'll still parse it and
401-
// report an error for better recovery.
402-
let lambda_expr = self.parse_lambda_expr();
403-
self.add_error(ParseErrorType::InvalidLambdaExpressionUsage, &lambda_expr);
404-
return Expr::Lambda(lambda_expr).into();
405-
}
406-
TokenKind::Yield => {
407-
let expr = self.parse_yield_expression();
416+
if left_precedence > OperatorPrecedence::None
417+
|| !context.is_yield_expression_allowed()
418+
{
419+
self.add_error(ParseErrorType::InvalidYieldExpressionUsage, &expr);
420+
}
408421

409-
if left_precedence > OperatorPrecedence::None
410-
|| !context.is_yield_expression_allowed()
411-
{
412-
self.add_error(ParseErrorType::InvalidYieldExpressionUsage, &expr);
422+
return expr.into();
413423
}
414-
415-
return expr.into();
424+
_ => {}
416425
}
417-
_ => {}
418-
}
419426

420-
let mut is_parenthesized = false;
421-
let lhs = self.parse_atom(context, &mut is_parenthesized);
427+
self.parse_atom(context, &mut is_parenthesized)
428+
};
422429

423430
ParsedExpr {
424431
expr: self.parse_postfix_expression(lhs, start, context),

0 commit comments

Comments
 (0)