add ast::ExprKind::Is and placeholder builtin syntax

Until it can be parsed properly, `expr is pat` is written
`builtin # is(expr is pat)`.

To be more concise, the included tests use a macro wrapper around it.

Author: dianne

compiler/rustc_ast/src/ast.rs

@@ -1562,6 +1562,9 @@ impl Expr {
             // need parens sometimes. E.g. we can print `(let _ = a) && b` as `let _ = a && b`
             // but we need to print `(let _ = a) < b` as-is with parens.
             | ExprKind::Let(..)
+            // FIXME(is): `expr is pat` should be binop-like, but until it can be parsed as such,
+            // it's using prefix placeholder syntax.
+            | ExprKind::Is(..)
             | ExprKind::Unary(..) => ExprPrecedence::Prefix,
 
             // Need parens if and only if there are prefix attributes.
@@ -1739,6 +1742,11 @@ pub enum ExprKind {
     ///
     /// `Span` represents the whole `let pat = expr` statement.
     Let(P<Pat>, P<Expr>, Span, Recovered),
+    /// An `expr is pat` expression. Currently, there's no `is` keyword, so as a placeholder it's
+    /// parsed as `builtin # is(expr is pat)`.
+    ///
+    /// This is desugared to `if` and `let` expressions.
+    Is(P<Expr>, P<Pat>),
     /// An `if` block, with an optional `else` block.
     ///
     /// `if expr { block } else { expr }`

compiler/rustc_ast/src/util/classify.rs

@@ -99,6 +99,7 @@ pub fn expr_requires_semi_to_be_stmt(e: &ast::Expr) -> bool {
 /// }
 /// ```
 pub fn leading_labeled_expr(mut expr: &ast::Expr) -> bool {
+    // FIXME(is): This will need tests for `is` once it can be parsed.
     loop {
         match &expr.kind {
             Block(_, label) | ForLoop { label, .. } | Loop(_, label, _) | While(_, _, label) => {
@@ -110,6 +111,7 @@ pub fn leading_labeled_expr(mut expr: &ast::Expr) -> bool {
             | Await(e, _)
             | Use(e, _)
             | Binary(_, e, _)
+            | Is(e, _)
             | Call(e, _)
             | Cast(e, _)
             | Field(e, _)
@@ -171,6 +173,7 @@ pub enum TrailingBrace<'a> {
 
 /// If an expression ends with `}`, returns the innermost expression ending in the `}`
 pub fn expr_trailing_brace(mut expr: &ast::Expr) -> Option<TrailingBrace<'_>> {
+    // FIXME(is): We should have a test for `let b = expr is Variant {} else { return }`.
     loop {
         match &expr.kind {
             AddrOf(_, _, e)
@@ -237,6 +240,7 @@ pub fn expr_trailing_brace(mut expr: &ast::Expr) -> Option<TrailingBrace<'_>> {
             | Paren(_)
             | Try(_)
             | Yeet(None)
+            | Is(..)
             | UnsafeBinderCast(..)
             | Err(_)
             | Dummy => {

compiler/rustc_ast/src/visit.rs

@@ -972,6 +972,8 @@ macro_rules! common_visitor_and_walkers {
                     visit_visitable!($($mut)? vis, subexpression, typ),
                 ExprKind::Let(pat, expr, span, _recovered) =>
                     visit_visitable!($($mut)? vis, pat, expr, span),
+                ExprKind::Is(expr, pat) =>
+                    visit_visitable!($($mut)? vis, expr, pat),
                 ExprKind::If(head_expression, if_block, optional_else) =>
                     visit_visitable!($($mut)? vis, head_expression, if_block, optional_else),
                 ExprKind::While(subexpression, block, opt_label) =>

compiler/rustc_ast_lowering/src/expr.rs

@@ -176,6 +176,16 @@ impl<'hir> LoweringContext<'_, 'hir> {
                         recovered: *recovered,
                     }))
                 }
+                ExprKind::Is(scrutinee, pat) => {
+                    // TODO: properly desugar `is` outside of `if`/`while`
+                    hir::ExprKind::Let(self.arena.alloc(hir::LetExpr {
+                        span: self.lower_span(e.span),
+                        pat: self.lower_pat(pat),
+                        ty: None,
+                        init: self.lower_expr(scrutinee),
+                        recovered: Recovered::No,
+                    }))
+                }
                 ExprKind::If(cond, then, else_opt) => {
                     self.lower_expr_if(cond, then, else_opt.as_deref())
                 }

compiler/rustc_ast_pretty/src/pprust/state/expr.rs

@@ -503,6 +503,13 @@ impl<'a> State<'a> {
             ast::ExprKind::Let(pat, scrutinee, _, _) => {
                 self.print_let(pat, scrutinee, fixup);
             }
+            ast::ExprKind::Is(scrutinee, pat) => {
+                // FIXME(is): This is a placeholder. Pretty-print properly once `is` can be parsed.
+                self.print_expr(scrutinee, fixup);
+                self.space();
+                self.word_space("is");
+                self.print_pat(pat);
+            }
             ast::ExprKind::If(test, blk, elseopt) => self.print_if(test, blk, elseopt.as_deref()),
             ast::ExprKind::While(test, blk, opt_label) => {
                 if let Some(label) = opt_label {

compiler/rustc_builtin_macros/src/assert/context.rs

@@ -243,6 +243,9 @@ impl<'cx, 'a> Context<'cx, 'a> {
             ExprKind::Let(_, local_expr, _, _) => {
                 self.manage_cond_expr(local_expr);
             }
+            ExprKind::Is(local_expr, _) => {
+                self.manage_cond_expr(local_expr);
+            }
             ExprKind::Match(local_expr, ..) => {
                 self.manage_cond_expr(local_expr);
             }

compiler/rustc_parse/src/parser/expr.rs

@@ -1962,6 +1962,7 @@ impl<'a> Parser<'a> {
                 sym::unwrap_binder => {
                     Some(this.parse_expr_unsafe_binder_cast(lo, UnsafeBinderCastKind::Unwrap)?)
                 }
+                sym::is => Some(this.parse_expr_is(lo)?),
                 _ => None,
             })
         })
@@ -2046,6 +2047,17 @@ impl<'a> Parser<'a> {
         Ok(self.mk_expr(span, ExprKind::UnsafeBinderCast(kind, expr, ty)))
     }
 
+    /// Parse placeholder built-in syntax for `is` (rfcs#3573)
+    fn parse_expr_is(&mut self, lo: Span) -> PResult<'a, P<Expr>> {
+        let scrutinee = self.parse_expr()?;
+        self.expect_keyword(exp!(Is))?;
+        // Likely this will need to be `parse_pat_no_top_alt` for the final syntax.
+        // FIXME(is): If so, we'll want a `PatternLocation` variant for `is` for diagnostics.
+        let pat = self.parse_pat_no_top_alt(None, None)?;
+        let span = lo.to(self.token.span);
+        Ok(self.mk_expr(span, ExprKind::Is(scrutinee, pat)))
+    }
+
     /// Returns a string literal if the next token is a string literal.
     /// In case of error returns `Some(lit)` if the next token is a literal with a wrong kind,
     /// and returns `None` if the next token is not literal at all.
@@ -3436,6 +3448,10 @@ impl<'a> Parser<'a> {
     fn parse_match_arm_guard(&mut self) -> PResult<'a, Option<P<Expr>>> {
         // Used to check the `if_let_guard` feature mostly by scanning
         // `&&` tokens.
+        // FIXME(is): This can't catch `is` expressions. In order to implement placeholder
+        // macro-based syntax for `is`, `is` within a macro expansion is treated as part of whatever
+        // condition it expands into. As such, gating `is` in match guards would need to be part of
+        // the `feature_gate` AST pass.
         fn has_let_expr(expr: &Expr) -> bool {
             match &expr.kind {
                 ExprKind::Binary(BinOp { node: BinOpKind::And, .. }, lhs, rhs) => {
@@ -4123,6 +4139,16 @@ impl MutVisitor for CondChecker<'_> {
                     }
                 }
             }
+            ExprKind::Is(_, _) => {
+                // FIXME(is): Handle edition-dependent rules for `is` in `&&`-chains. Currently,
+                // `is` desugars to `let` where `let`-chains are permitted, and otherwise desugars
+                // to `if let`. In the latter case, we could change the desugaring to rescope its
+                // temporaries to work on all Editions. For `is` inside an existing `if`
+                // expression's condition, however, temporaries in the condition live too long to
+                // permit all `&&` chains in Editions ≤ 2021. Since `is` will be a new keyword, it
+                // may only be possible for this to arise through the use of mixed-edition macro
+                // expansion or raw keywords (rfcs#3098).
+            }
             ExprKind::Binary(Spanned { node: BinOpKind::And, .. }, _, _) => {
                 mut_visit::walk_expr(self, e);
             }

compiler/rustc_passes/src/input_stats.rs

@@ -655,7 +655,7 @@ impl<'v> ast_visit::Visitor<'v> for StatCollector<'v> {
         record_variants!(
             (self, e, e.kind, None, ast, Expr, ExprKind),
             [
-                Array, ConstBlock, Call, MethodCall, Tup, Binary, Unary, Lit, Cast, Type, Let,
+                Array, ConstBlock, Call, MethodCall, Tup, Binary, Unary, Lit, Cast, Type, Let, Is,
                 If, While, ForLoop, Loop, Match, Closure, Block, Await, Use, TryBlock, Assign,
                 AssignOp, Field, Index, Range, Underscore, Path, AddrOf, Break, Continue, Ret,
                 InlineAsm, FormatArgs, OffsetOf, MacCall, Struct, Repeat, Paren, Try, Yield, Yeet,

compiler/rustc_resolve/src/late.rs

@@ -61,6 +61,7 @@ struct BindingInfo {
 pub(crate) enum PatternSource {
     Match,
     Let,
+    Is,
     For,
     FnParam,
 }
@@ -88,6 +89,7 @@ impl PatternSource {
         match self {
             PatternSource::Match => "match binding",
             PatternSource::Let => "let binding",
+            PatternSource::Is => "is binding",
             PatternSource::For => "for binding",
             PatternSource::FnParam => "function parameter",
         }
@@ -4844,6 +4846,13 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
                 self.apply_pattern_bindings(bindings);
             }
 
+            ExprKind::Is(ref scrutinee, ref pat) => {
+                // TODO: handle `is` outside of `if`/`while`: we'll need to introduce a new rib for
+                // the `is`'s `&&`-chain.
+                self.visit_expr(scrutinee);
+                self.resolve_pattern_top(pat, PatternSource::Is);
+            }
+
             ExprKind::If(ref cond, ref then, ref opt_else) => {
                 self.with_rib(ValueNS, RibKind::Normal, |this| {
                     let old = this.diag_metadata.in_if_condition.replace(cond);

src/tools/clippy/clippy_utils/src/sugg.rs

@@ -184,6 +184,8 @@ impl<'a> Sugg<'a> {
             | ast::ExprKind::Closure { .. }
             | ast::ExprKind::If(..)
             | ast::ExprKind::Let(..)
+            // FIXME(is): Once `is` can be parsed, it should provide `BinOp` suggestions.
+            | ast::ExprKind::Is(..)
             | ast::ExprKind::Unary(..)
             | ast::ExprKind::Match(..) => match snippet_with_context(cx, expr.span, ctxt, default, app) {
                 (snip, false) => Sugg::MaybeParen(snip),