rustc_parse/parser/expr/

diagnostics.rs

use rustc_ast::util::parser::AssocOp;
use rustc_ast::{BinOpKind, Expr, ExprKind, token};
use rustc_ast_pretty::pprust;
use rustc_errors::{Applicability, Diag, PResult};
use rustc_span::{Span, Spanned, respan, sym};

use crate::parser::{Parser, SeqSep};
use crate::{diagnostics, exp};

impl<'a> Parser<'a> {
    /// Recover from a binary operator after complete statement expression as in `{ 4 } / 2`.
    pub(super) fn recover_from_bin_op_after_complete_stmt_expr(&self, lhs: &Expr) -> bool {
        use BinOpKind::*;

        // Starting point: We've just parsed a *complete* stmt expr (e.g., a block like `{ 4 }`).

        let Some(op) = AssocOp::from_token(&self.token) else { return false };

        // We've now encountered a token that could(!) be interpreted as a binary operator. This
        // could mean that the user intended to write a binary operation where the left operand is
        // block-like. In that case they would need to parenthesize the LHS or the entire operation
        // (e.g., `{ 4 } / 2` -> `({ 4 }) / 2` or `({ 4 } / 2)`).

        if op_can_continue_stmt_expr_unambiguously(op) {
            // We know that the token (e.g., `/`) can't possibly begin a new statement or pattern.
            // Instead of letting the stmt/pat parser emit a generic & rather confusing diagnostic,
            // let's emit a more targeted one, and continue parsing the expression.

            self.dcx().emit_err(diagnostics::FoundExprWouldBeStmt {
                span: self.token.span,
                token: pprust::token_to_string(&self.token),
                suggestion: diagnostics::ExprParenthesesNeeded::surrounding(lhs.span),
            });
            return true;
        }

        // The token can begin a new statement or pattern; this means we're on the happy path!
        // Still, the user might've meant to write a bin op here but we can't tell at this stage of
        // compilation. So if it's a "common lookalike" let's proactively register it somewhere for
        // later stages of compilation to potentially retrieve (e.g., in typeck).
        //
        // We've left out `BitAnd` because guessing its intent is hard. We can make suggestions
        // based on the assumption that double-refs are rarely intentional, and closures are
        // distinct enough that they don't get mixed up with their return value.
        if let AssocOp::Binary(Add | And | BitOr | Mul | Or | Sub) = op {
            let sp = self.psess.source_map().start_point(self.token.span);
            self.psess
                .complete_stmt_exprs_before_bin_op_lookalike
                .borrow_mut()
                .insert(sp, lhs.span);
        }

        false
    }

    /// Recover from alphabetic logic operators `and` and `or` as found in e.g., Python and PHP.
    pub(super) fn recover_from_alpha_logic_op(&self) -> Option<Spanned<AssocOp>> {
        if self.may_recover()
            && let Some(ident) = self.token.non_raw_ident()
        {
            let (op, sub): (_, fn(_) -> _) = match ident.name {
                sym::and => (BinOpKind::And, diagnostics::InvalidLogicalOperatorSub::Conjunction),
                sym::or => (BinOpKind::Or, diagnostics::InvalidLogicalOperatorSub::Disjunction),
                _ => return None,
            };

            self.dcx().emit_err(diagnostics::InvalidLogicalOperator {
                span: self.token.span,
                incorrect: ident.name,
                sub: sub(self.token.span),
            });

            Some(respan(self.token.span, AssocOp::Binary(op)))
        } else {
            None
        }
    }

    /// Reject `...` being used as an expression operator.
    pub(super) fn reject_dotdotdot_expr_op(&self) {
        if self.token == token::DotDotDot {
            self.dcx().emit_err(diagnostics::DotDotDotExprOp { span: self.token.span });
        }
    }

    /// Reject `<-` being used as an expression operator.
    pub(super) fn reject_larrow_expr_op(&self) {
        if self.token == token::LArrow {
            self.dcx().emit_err(diagnostics::LArrowExprOp { span: self.token.span });
        }
    }

    /// Recover from strict equality operators `===` and `!==` as found in e.g., JS and PHP.
    pub(super) fn recover_from_strict_eq_op(&mut self, op: Spanned<AssocOp>) {
        if let AssocOp::Binary(bop @ BinOpKind::Eq | bop @ BinOpKind::Ne) = op.node
            && self.token == token::Eq
            && self.prev_token.span.hi() == self.token.span.lo()
        {
            let sp = op.span.to(self.token.span);
            let sugg = bop.as_str().into();
            let invalid = format!("{sugg}=");
            self.dcx().emit_err(diagnostics::InvalidComparisonOperator {
                span: sp,
                invalid: invalid.clone(),
                sub: diagnostics::InvalidComparisonOperatorSub::Correctable {
                    span: sp,
                    invalid,
                    correct: sugg,
                },
            });
            self.bump();
        }
    }

    /// Recover from inequality operator `<>` ("diamond") as found in e.g., PHP.
    pub(super) fn recover_from_diamond_ne_op(&mut self) {
        if let (token::Lt, token::Gt) = (self.prev_token.kind, self.token.kind)
            && self.prev_token.span.hi() == self.token.span.lo()
        {
            let sp = self.prev_token.span.to(self.token.span);
            self.dcx().emit_err(diagnostics::InvalidComparisonOperator {
                span: sp,
                invalid: "<>".into(),
                sub: diagnostics::InvalidComparisonOperatorSub::Correctable {
                    span: sp,
                    invalid: "<>".into(),
                    correct: "!=".into(),
                },
            });
            self.bump();
        }
    }

    /// Recover from comparison operator `<=>` ("spaceship") as found in e.g., C++.
    pub(super) fn recover_from_spaceship_cmp_op(&mut self) {
        if let (token::Le, token::Gt) = (self.prev_token.kind, self.token.kind)
            && self.prev_token.span.hi() == self.token.span.lo()
        {
            let sp = self.prev_token.span.to(self.token.span);
            self.dcx().emit_err(diagnostics::InvalidComparisonOperator {
                span: sp,
                invalid: "<=>".into(),
                sub: diagnostics::InvalidComparisonOperatorSub::Spaceship(sp),
            });
            self.bump();
        }
    }

    /// Recover from postfix increment operator `++` as found in many C-style languages.
    pub(super) fn recover_from_postfix_inc_op(
        &mut self,
        lhs: &Expr,
        starts_stmt: bool,
    ) -> PResult<'a, ()> {
        if let (token::Plus, token::Plus) = (self.prev_token.kind, self.token.kind)
            && self.prev_token.span.hi() == self.token.span.lo()
        {
            let op_span = self.prev_token.span.to(self.token.span);
            self.bump(); // eat the second `+`
            Err(self.report_inc_dec_op(lhs, starts_stmt, IncOrDec::Inc, UnaryFixity::Post, op_span))
        } else {
            Ok(())
        }
    }

    /// Recover from postfix decrement operator `--` as found in many C-style languages.
    pub(super) fn recover_from_postfix_dec_op(
        &mut self,
        lhs: &Expr,
        starts_stmt: bool,
    ) -> PResult<'a, ()> {
        if let (token::Minus, token::Minus) = (self.prev_token.kind, self.token.kind)
            && self.prev_token.span.hi() == self.token.span.lo()
            && !self.look_ahead(1, |tok| tok.can_begin_expr())
        {
            let op_span = self.prev_token.span.to(self.token.span);
            self.bump(); // eat the second `-`
            Err(self.report_inc_dec_op(lhs, starts_stmt, IncOrDec::Dec, UnaryFixity::Post, op_span))
        } else {
            Ok(())
        }
    }

    /// Report increment operator `++` & decrement operator `--` as found in many C-style languages.
    pub(super) fn report_inc_dec_op(
        &mut self,
        base: &Expr,
        starts_stmt: bool,
        op: IncOrDec,
        fixity: UnaryFixity,
        op_span: Span,
    ) -> Diag<'a> {
        // FIXME: Don't return an error diag, emit the diag here *and* return a new expr of the form
        //        `$base += 1` / `$base -= 1` (taking `base: Expr` by value) for *proper* recovery.
        //        (Just emitting the diag would be insufficient since callers would most likely just
        //        use `$base` as the recovered AST node which would lead to annoying follow-up diags
        //        like "variable doesn't need to be mutable" getting emitted in some cases.)

        let mut err = {
            let fixity = match fixity {
                UnaryFixity::Pre => "prefix",
                UnaryFixity::Post => "postfix",
            };
            let op = match op {
                IncOrDec::Inc => "increment",
                IncOrDec::Dec => "decrement",
            };
            self.dcx()
                .struct_span_err(op_span, format!("Rust has no {fixity} {op} operator"))
                .with_span_label(op_span, format!("not a valid {fixity} operator"))
        };

        let op = match op {
            IncOrDec::Inc => "+= 1",
            IncOrDec::Dec => "-= 1",
        };
        let (pre_span, post_span) = match fixity {
            UnaryFixity::Pre => (op_span, base.span.shrink_to_hi()),
            UnaryFixity::Post => (base.span.shrink_to_lo(), op_span),
        };

        if starts_stmt {
            let mut patches = Vec::new();
            if !pre_span.is_empty() {
                patches.push((pre_span, String::new()));
            }
            patches.push((post_span, format!(" {op}")));
            err.multipart_suggestion(
                format!("use `{op}` instead"),
                patches,
                Applicability::MachineApplicable,
            );
        } else {
            let Ok(base_src) = self.span_to_snippet(base.span) else {
                err.help(format!("use `{op}` instead"));
                return err;
            };
            match fixity {
                UnaryFixity::Pre => {
                    err.multipart_suggestion(
                        format!("use `{op}` instead"),
                        vec![(pre_span, "{ ".into()), (post_span, format!(" {op}; {base_src} }}"))],
                        Applicability::MachineApplicable,
                    );
                }
                UnaryFixity::Post => {
                    // won't suggest since we can not handle the precedences
                    // for example: `a + b++` has been parsed (a + b)++ and we can not suggest here
                    if !matches!(base.kind, ExprKind::Binary(..)) {
                        let tmp_var = if base_src.trim() == "tmp" { "tmp_" } else { "tmp" };
                        err.multipart_suggestion(
                            format!("use `{op}` instead"),
                            vec![
                                (pre_span, format!("{{ let {tmp_var} = ")),
                                (post_span, format!("; {base_src} {op}; {tmp_var} }}")),
                            ],
                            Applicability::HasPlaceholders,
                        );
                    }
                }
            }
        }
        err
    }

    /// Recover from array expressions as found in C like `{0, 1, 2, 3}`.
    pub(super) fn recover_from_c_array(&mut self, lo: Span) -> Option<Box<Expr>> {
        if !self.may_recover()
            || self.token.kind != token::OpenBrace
            || self.look_ahead(1, |t| !matches!(t.kind, token::Literal(_)))
            || self.look_ahead(2, |t| t != &token::Comma)
            || self.look_ahead(3, |t| !t.can_begin_expr())
        {
            return None;
        }

        let mut snapshot = self.create_snapshot_for_diagnostic();
        match snapshot.parse_expr_array_or_repeat(exp!(CloseBrace)) {
            Ok(arr) => {
                let guar = self.dcx().emit_err(diagnostics::ArrayBracketsInsteadOfBraces {
                    span: arr.span,
                    sub: diagnostics::ArrayBracketsInsteadOfBracesSugg {
                        left: lo,
                        right: snapshot.prev_token.span,
                    },
                });

                self.restore_snapshot(snapshot);
                Some(self.mk_expr_err(arr.span, guar))
            }
            Err(e) => {
                e.cancel();
                None
            }
        }
    }

    pub(super) fn recover_from_missing_semicolon_before_array(
        &self,
        prev_span: Span,
        open_delim_span: Span,
    ) -> PResult<'a, ()> {
        if !self.may_recover()
            || self.token != token::Comma
            // Only make this suggestion if the `[` is not on the same line as the last token of
            // the expression preceding it, which is a sign that it is not intended as an
            // index expression.
            || !self.psess.source_map().is_multiline(prev_span.until(open_delim_span))
        {
            return Ok(());
        }

        let mut snapshot = self.create_snapshot_for_diagnostic();
        snapshot.bump();
        match snapshot.parse_seq_to_before_end(
            exp!(CloseBracket),
            SeqSep::trailing_allowed(exp!(Comma)),
            |p| p.parse_expr(),
        ) {
            Ok(_)
                // When the close delim is `)`, `token.kind` is expected to be `token::CloseParen`,
                // but the actual `token.kind` is `token::CloseBracket`. This is because the
                // `token.kind` of the close delim is treated as the same as that of the open delim
                // in `TokenTreesReader::parse_token_tree`, even if the delimiters of them are
                // different. Therefore, `token.kind` should not be compared here.
                if snapshot
                    .span_to_snippet(snapshot.token.span)
                    .is_ok_and(|snippet| snippet == "]") =>
            {
                // FIXME: This is way to assertive for a diagnostic with so many false positives!
                //        Just `expect(Comma)` and modify the diagnostic with a note that says sth.
                //        along the lines of "consider adding a `;` here if you meant the `[...]` to
                //        denote an array instead of an index".
                // FIXME: In most cases there certainly isn't a "missing `;`". E.g., if we're nested
                //        in an expression like `(x[y, z])` or `match x[y, z] {}`. Requiring that
                //        we're not under `Restriction::STMT_EXPR` isn't sufficient by the way since
                //        we could still be part of a match arm body *and* it would prevent us from
                //        suggesting a `;` in cases like `let x = y[z, w];`.
                Err(self.dcx().create_err(crate::diagnostics::MissingSemicolonBeforeArray {
                    open_delim: open_delim_span,
                    semicolon: prev_span.shrink_to_hi(),
                }))
            }
            Ok(_) => Ok(()),
            Err(err) => {
                err.cancel();
                Ok(())
            }
        }
    }
}

/// Whether this operator could be used to follow a complete statement expression unambiguously
/// during parse error recovery.
pub(in crate::parser) fn op_can_continue_stmt_expr_unambiguously(op: AssocOp) -> bool {
    // NOTE: At the time of writing, it's only safe to return `true` for tokens that don't share a
    //       prefix with statements or patterns. For context, statement lists and match arm bodies
    //       are (the only two) places that use `Restriction::STMT_EXPR` (in the happy path).

    use BinOpKind::*;
    match op {
        AssocOp::Assign | AssocOp::AssignOp(_) | AssocOp::Cast => true,
        AssocOp::Binary(bin_op) => match bin_op {
            | BitXor | Div | Ge | Gt | Le | Rem | Shr => true,
            | Add // unambiguous but would inhibit our recovery from unary plus
            | And // `&&` starts repeated borrow (e.g., `&&x`)
            | BitAnd // `&` starts borrow (e.g., `&x`)
            | BitOr // `|` starts closure (e.g., `|_| ()`) or leading vert (e.g., `| Some(_)`)
            | Eq | Ne // unambiguous but would inhibit our recovery from bad struct literals
            | Lt // `<` starts qualified path (e.g., `<T as X>::P`)
            | Mul // `*` starts unary deref (e.g., `*x`, `*x = 0`)
            | Or // `||` starts parameterless closure (e.g. `|| 0`)
            | Shl // `<<` starts repeated qualified path (e.g., `<<T>::Q as X>::P`)
            | Sub => false, // `-` starts unary negation (e.g, `-x`)
        },
        AssocOp::Range(_) => false, // `..`/`..=` start ranges w/o lower bound (e.g., `..`, `..=1`)
    }
}

#[derive(Copy, Clone)]
pub(super) enum IncOrDec {
    Inc,
    Dec,
}

#[derive(Copy, Clone)]
pub(super) enum UnaryFixity {
    Pre,
    Post,
}