compiler/rustc_ast/src/util/parser.rs

   1 use crate::ast::{self, BinOpKind};
   2 use crate::token::{self, BinOpToken, Token};
   3 use rustc_span::symbol::kw;
   4
   5 /// Associative operator with precedence.
   6 ///
   7 /// This is the enum which specifies operator precedence and fixity to the parser.
   8 #[derive(Copy, Clone, PartialEq, Debug)]
   9 pub enum AssocOp {
  10     /// `+`
  11     Add,
  12     /// `-`
  13     Subtract,
  14     /// `*`
  15     Multiply,
  16     /// `/`
  17     Divide,
  18     /// `%`
  19     Modulus,
  20     /// `&&`
  21     LAnd,
  22     /// `||`
  23     LOr,
  24     /// `^`
  25     BitXor,
  26     /// `&`
  27     BitAnd,
  28     /// `|`
  29     BitOr,
  30     /// `<<`
  31     ShiftLeft,
  32     /// `>>`
  33     ShiftRight,
  34     /// `==`
  35     Equal,
  36     /// `<`
  37     Less,
  38     /// `<=`
  39     LessEqual,
  40     /// `!=`
  41     NotEqual,
  42     /// `>`
  43     Greater,
  44     /// `>=`
  45     GreaterEqual,
  46     /// `=`
  47     Assign,
  48     /// `?=` where ? is one of the BinOpToken
  49     AssignOp(BinOpToken),
  50     /// `as`
  51     As,
  52     /// `..` range
  53     DotDot,
  54     /// `..=` range
  55     DotDotEq,
  56     /// `:`
  57     Colon,
  58 }
  59
  60 #[derive(PartialEq, Debug)]
  61 pub enum Fixity {
  62     /// The operator is left-associative
  63     Left,
  64     /// The operator is right-associative
  65     Right,
  66     /// The operator is not associative
  67     None,
  68 }
  69
  70 impl AssocOp {
  71     /// Creates a new AssocOP from a token
  72     pub fn from_token(t: &Token) -> Option<AssocOp> {
  73         use AssocOp::*;
  74         match t.kind {
  75             token::BinOpEq(k) => Some(AssignOp(k)),
  76             token::Eq => Some(Assign),
  77             token::BinOp(BinOpToken::Star) => Some(Multiply),
  78             token::BinOp(BinOpToken::Slash) => Some(Divide),
  79             token::BinOp(BinOpToken::Percent) => Some(Modulus),
  80             token::BinOp(BinOpToken::Plus) => Some(Add),
  81             token::BinOp(BinOpToken::Minus) => Some(Subtract),
  82             token::BinOp(BinOpToken::Shl) => Some(ShiftLeft),
  83             token::BinOp(BinOpToken::Shr) => Some(ShiftRight),
  84             token::BinOp(BinOpToken::And) => Some(BitAnd),
  85             token::BinOp(BinOpToken::Caret) => Some(BitXor),
  86             token::BinOp(BinOpToken::Or) => Some(BitOr),
  87             token::Lt => Some(Less),
  88             token::Le => Some(LessEqual),
  89             token::Ge => Some(GreaterEqual),
  90             token::Gt => Some(Greater),
  91             token::EqEq => Some(Equal),
  92             token::Ne => Some(NotEqual),
  93             token::AndAnd => Some(LAnd),
  94             token::OrOr => Some(LOr),
  95             token::DotDot => Some(DotDot),
  96             token::DotDotEq => Some(DotDotEq),
  97             // DotDotDot is no longer supported, but we need some way to display the error
  98             token::DotDotDot => Some(DotDotEq),
  99             token::Colon => Some(Colon),
 100             // `<-` should probably be `< -`
 101             token::LArrow => Some(Less),
 102             _ if t.is_keyword(kw::As) => Some(As),
 103             _ => None,
 104         }
 105     }
 106
 107     /// Creates a new AssocOp from ast::BinOpKind.
 108     pub fn from_ast_binop(op: BinOpKind) -> Self {
 109         use AssocOp::*;
 110         match op {
 111             BinOpKind::Lt => Less,
 112             BinOpKind::Gt => Greater,
 113             BinOpKind::Le => LessEqual,
 114             BinOpKind::Ge => GreaterEqual,
 115             BinOpKind::Eq => Equal,
 116             BinOpKind::Ne => NotEqual,
 117             BinOpKind::Mul => Multiply,
 118             BinOpKind::Div => Divide,
 119             BinOpKind::Rem => Modulus,
 120             BinOpKind::Add => Add,
 121             BinOpKind::Sub => Subtract,
 122             BinOpKind::Shl => ShiftLeft,
 123             BinOpKind::Shr => ShiftRight,
 124             BinOpKind::BitAnd => BitAnd,
 125             BinOpKind::BitXor => BitXor,
 126             BinOpKind::BitOr => BitOr,
 127             BinOpKind::And => LAnd,
 128             BinOpKind::Or => LOr,
 129         }
 130     }
 131
 132     /// Gets the precedence of this operator
 133     pub fn precedence(&self) -> usize {
 134         use AssocOp::*;
 135         match *self {
 136             As | Colon => 14,
 137             Multiply | Divide | Modulus => 13,
 138             Add | Subtract => 12,
 139             ShiftLeft | ShiftRight => 11,
 140             BitAnd => 10,
 141             BitXor => 9,
 142             BitOr => 8,
 143             Less | Greater | LessEqual | GreaterEqual | Equal | NotEqual => 7,
 144             LAnd => 6,
 145             LOr => 5,
 146             DotDot | DotDotEq => 4,
 147             Assign | AssignOp(_) => 2,
 148         }
 149     }
 150
 151     /// Gets the fixity of this operator
 152     pub fn fixity(&self) -> Fixity {
 153         use AssocOp::*;
 154         // NOTE: it is a bug to have an operators that has same precedence but different fixities!
 155         match *self {
 156             Assign | AssignOp(_) => Fixity::Right,
 157             As | Multiply | Divide | Modulus | Add | Subtract | ShiftLeft | ShiftRight | BitAnd
 158             | BitXor | BitOr | Less | Greater | LessEqual | GreaterEqual | Equal | NotEqual
 159             | LAnd | LOr | Colon => Fixity::Left,
 160             DotDot | DotDotEq => Fixity::None,
 161         }
 162     }
 163
 164     pub fn is_comparison(&self) -> bool {
 165         use AssocOp::*;
 166         match *self {
 167             Less | Greater | LessEqual | GreaterEqual | Equal | NotEqual => true,
 168             Assign | AssignOp(_) | As | Multiply | Divide | Modulus | Add | Subtract
 169             | ShiftLeft | ShiftRight | BitAnd | BitXor | BitOr | LAnd | LOr | DotDot | DotDotEq
 170             | Colon => false,
 171         }
 172     }
 173
 174     pub fn is_assign_like(&self) -> bool {
 175         use AssocOp::*;
 176         match *self {
 177             Assign | AssignOp(_) => true,
 178             Less | Greater | LessEqual | GreaterEqual | Equal | NotEqual | As | Multiply
 179             | Divide | Modulus | Add | Subtract | ShiftLeft | ShiftRight | BitAnd | BitXor
 180             | BitOr | LAnd | LOr | DotDot | DotDotEq | Colon => false,
 181         }
 182     }
 183
 184     pub fn to_ast_binop(&self) -> Option<BinOpKind> {
 185         use AssocOp::*;
 186         match *self {
 187             Less => Some(BinOpKind::Lt),
 188             Greater => Some(BinOpKind::Gt),
 189             LessEqual => Some(BinOpKind::Le),
 190             GreaterEqual => Some(BinOpKind::Ge),
 191             Equal => Some(BinOpKind::Eq),
 192             NotEqual => Some(BinOpKind::Ne),
 193             Multiply => Some(BinOpKind::Mul),
 194             Divide => Some(BinOpKind::Div),
 195             Modulus => Some(BinOpKind::Rem),
 196             Add => Some(BinOpKind::Add),
 197             Subtract => Some(BinOpKind::Sub),
 198             ShiftLeft => Some(BinOpKind::Shl),
 199             ShiftRight => Some(BinOpKind::Shr),
 200             BitAnd => Some(BinOpKind::BitAnd),
 201             BitXor => Some(BinOpKind::BitXor),
 202             BitOr => Some(BinOpKind::BitOr),
 203             LAnd => Some(BinOpKind::And),
 204             LOr => Some(BinOpKind::Or),
 205             Assign | AssignOp(_) | As | DotDot | DotDotEq | Colon => None,
 206         }
 207     }
 208
 209     /// This operator could be used to follow a block unambiguously.
 210     ///
 211     /// This is used for error recovery at the moment, providing a suggestion to wrap blocks with
 212     /// parentheses while having a high degree of confidence on the correctness of the suggestion.
 213     pub fn can_continue_expr_unambiguously(&self) -> bool {
 214         use AssocOp::*;
 215         matches!(
 216             self,
 217             BitXor | // `{ 42 } ^ 3`
 218             Assign | // `{ 42 } = { 42 }`
 219             Divide | // `{ 42 } / 42`
 220             Modulus | // `{ 42 } % 2`
 221             ShiftRight | // `{ 42 } >> 2`
 222             LessEqual | // `{ 42 } <= 3`
 223             Greater | // `{ 42 } > 3`
 224             GreaterEqual | // `{ 42 } >= 3`
 225             AssignOp(_) | // `{ 42 } +=`
 226             As | // `{ 42 } as usize`
 227             // Equal | // `{ 42 } == { 42 }`    Accepting these here would regress incorrect
 228             // NotEqual | // `{ 42 } != { 42 }  struct literals parser recovery.
 229             Colon, // `{ 42 }: usize`
 230         )
 231     }
 232 }
 233
 234 pub const PREC_CLOSURE: i8 = -40;
 235 pub const PREC_JUMP: i8 = -30;
 236 pub const PREC_RANGE: i8 = -10;
 237 // The range 2..=14 is reserved for AssocOp binary operator precedences.
 238 pub const PREC_PREFIX: i8 = 50;
 239 pub const PREC_POSTFIX: i8 = 60;
 240 pub const PREC_PAREN: i8 = 99;
 241 pub const PREC_FORCE_PAREN: i8 = 100;
 242
 243 #[derive(Debug, Clone, Copy)]
 244 pub enum ExprPrecedence {
 245     Closure,
 246     Break,
 247     Continue,
 248     Ret,
 249     Yield,
 250     Yeet,
 251
 252     Range,
 253
 254     Binary(BinOpKind),
 255
 256     Cast,
 257     Type,
 258
 259     Assign,
 260     AssignOp,
 261
 262     Box,
 263     AddrOf,
 264     Let,
 265     Unary,
 266
 267     Call,
 268     MethodCall,
 269     Field,
 270     Index,
 271     Try,
 272     InlineAsm,
 273     Mac,
 274
 275     Array,
 276     Repeat,
 277     Tup,
 278     Lit,
 279     Path,
 280     Paren,
 281     If,
 282     While,
 283     ForLoop,
 284     Loop,
 285     Match,
 286     ConstBlock,
 287     Block,
 288     TryBlock,
 289     Struct,
 290     Async,
 291     Await,
 292     Err,
 293 }
 294
 295 impl ExprPrecedence {
 296     pub fn order(self) -> i8 {
 297         match self {
 298             ExprPrecedence::Closure => PREC_CLOSURE,
 299
 300             ExprPrecedence::Break
 301             | ExprPrecedence::Continue
 302             | ExprPrecedence::Ret
 303             | ExprPrecedence::Yield
 304             | ExprPrecedence::Yeet => PREC_JUMP,
 305
 306             // `Range` claims to have higher precedence than `Assign`, but `x .. x = x` fails to
 307             // parse, instead of parsing as `(x .. x) = x`.  Giving `Range` a lower precedence
 308             // ensures that `pprust` will add parentheses in the right places to get the desired
 309             // parse.
 310             ExprPrecedence::Range => PREC_RANGE,
 311
 312             // Binop-like expr kinds, handled by `AssocOp`.
 313             ExprPrecedence::Binary(op) => AssocOp::from_ast_binop(op).precedence() as i8,
 314             ExprPrecedence::Cast => AssocOp::As.precedence() as i8,
 315             ExprPrecedence::Type => AssocOp::Colon.precedence() as i8,
 316
 317             ExprPrecedence::Assign |
 318             ExprPrecedence::AssignOp => AssocOp::Assign.precedence() as i8,
 319
 320             // Unary, prefix
 321             ExprPrecedence::Box
 322             | ExprPrecedence::AddrOf
 323             // Here `let pats = expr` has `let pats =` as a "unary" prefix of `expr`.
 324             // However, this is not exactly right. When `let _ = a` is the LHS of a binop we
 325             // need parens sometimes. E.g. we can print `(let _ = a) && b` as `let _ = a && b`
 326             // but we need to print `(let _ = a) < b` as-is with parens.
 327             | ExprPrecedence::Let
 328             | ExprPrecedence::Unary => PREC_PREFIX,
 329
 330             // Unary, postfix
 331             ExprPrecedence::Await
 332             | ExprPrecedence::Call
 333             | ExprPrecedence::MethodCall
 334             | ExprPrecedence::Field
 335             | ExprPrecedence::Index
 336             | ExprPrecedence::Try
 337             | ExprPrecedence::InlineAsm
 338             | ExprPrecedence::Mac => PREC_POSTFIX,
 339
 340             // Never need parens
 341             ExprPrecedence::Array
 342             | ExprPrecedence::Repeat
 343             | ExprPrecedence::Tup
 344             | ExprPrecedence::Lit
 345             | ExprPrecedence::Path
 346             | ExprPrecedence::Paren
 347             | ExprPrecedence::If
 348             | ExprPrecedence::While
 349             | ExprPrecedence::ForLoop
 350             | ExprPrecedence::Loop
 351             | ExprPrecedence::Match
 352             | ExprPrecedence::ConstBlock
 353             | ExprPrecedence::Block
 354             | ExprPrecedence::TryBlock
 355             | ExprPrecedence::Async
 356             | ExprPrecedence::Struct
 357             | ExprPrecedence::Err => PREC_PAREN,
 358         }
 359     }
 360 }
 361
 362 /// In `let p = e`, operators with precedence `<=` this one requires parentheses in `e`.
 363 pub fn prec_let_scrutinee_needs_par() -> usize {
 364     AssocOp::LAnd.precedence()
 365 }
 366
 367 /// Suppose we have `let _ = e` and the `order` of `e`.
 368 /// Is the `order` such that `e` in `let _ = e` needs parentheses when it is on the RHS?
 369 ///
 370 /// Conversely, suppose that we have `(let _ = a) OP b` and `order` is that of `OP`.
 371 /// Can we print this as `let _ = a OP b`?
 372 pub fn needs_par_as_let_scrutinee(order: i8) -> bool {
 373     order <= prec_let_scrutinee_needs_par() as i8
 374 }
 375
 376 /// Expressions that syntactically contain an "exterior" struct literal i.e., not surrounded by any
 377 /// parens or other delimiters, e.g., `X { y: 1 }`, `X { y: 1 }.method()`, `foo == X { y: 1 }` and
 378 /// `X { y: 1 } == foo` all do, but `(X { y: 1 }) == foo` does not.
 379 pub fn contains_exterior_struct_lit(value: &ast::Expr) -> bool {
 380     match value.kind {
 381         ast::ExprKind::Struct(..) => true,
 382
 383         ast::ExprKind::Assign(ref lhs, ref rhs, _)
 384         | ast::ExprKind::AssignOp(_, ref lhs, ref rhs)
 385         | ast::ExprKind::Binary(_, ref lhs, ref rhs) => {
 386             // X { y: 1 } + X { y: 2 }
 387             contains_exterior_struct_lit(&lhs) || contains_exterior_struct_lit(&rhs)
 388         }
 389         ast::ExprKind::Await(ref x)
 390         | ast::ExprKind::Unary(_, ref x)
 391         | ast::ExprKind::Cast(ref x, _)
 392         | ast::ExprKind::Type(ref x, _)
 393         | ast::ExprKind::Field(ref x, _)
 394         | ast::ExprKind::Index(ref x, _) => {
 395             // &X { y: 1 }, X { y: 1 }.y
 396             contains_exterior_struct_lit(&x)
 397         }
 398
 399         ast::ExprKind::MethodCall(box ast::MethodCall { ref receiver, .. }) => {
 400             // X { y: 1 }.bar(...)
 401             contains_exterior_struct_lit(&receiver)
 402         }
 403
 404         _ => false,
 405     }
 406 }