rustc_parse/parser/expr/

diagnostics.rs

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

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

impl<'a> Parser<'a> {
    /// 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
            }
        }
    }
}

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

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