diff --git a/compiler/rustc_ast/src/ast.rs b/compiler/rustc_ast/src/ast.rs
index 97e070958751a..af984dd9a7011 100644
--- a/compiler/rustc_ast/src/ast.rs
+++ b/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.
@@ -1618,6 +1621,19 @@ impl Expr {
         )
     }
 
+    /// Is this an `is` expression or a chain of `&&` operators containing an `is` expression?
+    /// This determines the scope of the `is` expression's bindings. E.g., since
+    /// `(expr is x) && f()` is broken up by parentheses, `x` is dropped before evaluating `f()`.
+    pub fn has_expr_is(&self) -> bool {
+        match &self.kind {
+            ExprKind::Is(..) => true,
+            ExprKind::Binary(BinOp { node: BinOpKind::And, .. }, lhs, rhs) => {
+                lhs.has_expr_is() || rhs.has_expr_is()
+            }
+            _ => false,
+        }
+    }
+
     /// Creates a dummy `Expr`.
     ///
     /// Should only be used when it will be replaced afterwards or as a return value when an error was encountered.
@@ -1739,6 +1755,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 }`
diff --git a/compiler/rustc_ast/src/util/classify.rs b/compiler/rustc_ast/src/util/classify.rs
index f7daec4b0648c..552e80609d207 100644
--- a/compiler/rustc_ast/src/util/classify.rs
+++ b/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 => {
diff --git a/compiler/rustc_ast/src/visit.rs b/compiler/rustc_ast/src/visit.rs
index ab15cb28fa12d..d6c776ad04222 100644
--- a/compiler/rustc_ast/src/visit.rs
+++ b/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) =>
diff --git a/compiler/rustc_ast_lowering/src/expr.rs b/compiler/rustc_ast_lowering/src/expr.rs
index 15e736261d583..d002112d241f7 100644
--- a/compiler/rustc_ast_lowering/src/expr.rs
+++ b/compiler/rustc_ast_lowering/src/expr.rs
@@ -94,6 +94,17 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 ExprKind::ForLoop { pat, iter, body, label, kind } => {
                     return self.lower_expr_for(e, pat, iter, body, *label, *kind);
                 }
+                // Desugar `expr is pat` expressions. This likewise needs special handling as `is`
+                // expressions outside of `if`/`while` conditions are wrapped in an `if` expression.
+                ExprKind::Is(..) => return self.lower_wrapped_cond_for_expr_is(e),
+                ExprKind::Binary(BinOp { node: BinOpKind::And, .. }, ..) => {
+                    if e.has_expr_is() {
+                        return self.lower_wrapped_cond_for_expr_is(e);
+                    } else {
+                        // `has_expr_is` will be false for this `&&`'s operands; don't check again.
+                        return self.lower_cond_mut(e);
+                    }
+                }
                 _ => (),
             }
 
@@ -369,7 +380,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
                 ExprKind::Try(sub_expr) => self.lower_expr_try(e.span, sub_expr),
 
-                ExprKind::Paren(_) | ExprKind::ForLoop { .. } => {
+                ExprKind::Paren(_) | ExprKind::ForLoop { .. } | ExprKind::Is(..) => {
                     unreachable!("already handled")
                 }
 
@@ -522,13 +533,86 @@ impl<'hir> LoweringContext<'_, 'hir> {
         hir::ExprKind::Call(f, self.lower_exprs(&real_args))
     }
 
+    /// Lower an expression in a context where `let` expressions are permitted, such as the
+    /// condition of an `if` or `while` expression. This allows `is` expressions to be lowered
+    /// directly to `let` expressions without needing to be wrapped in an `if`'s condition.
+    fn lower_cond(&mut self, e: &Expr) -> &'hir hir::Expr<'hir> {
+        self.arena.alloc(self.lower_cond_mut(e))
+    }
+
+    fn lower_cond_mut(&mut self, e: &Expr) -> hir::Expr<'hir> {
+        self.lower_cond_inner(e, None)
+    }
+
+    fn lower_cond_inner(&mut self, e: &Expr, wrapper: Option<(HirId, Span)>) -> hir::Expr<'hir> {
+        let lower_id_and_attrs = |this: &mut LoweringContext<'_, 'hir>| {
+            let expr_hir_id = this.lower_node_id(e.id);
+            // If the condition is wrapped in an `if` expression for `is` desugaring, attach
+            // attributes to the `if` expression instead of `e`.
+            let (attr_hir_id, attr_span) = wrapper.unwrap_or((expr_hir_id, e.span));
+            this.lower_attrs(attr_hir_id, &e.attrs, attr_span);
+            expr_hir_id
+        };
+        match &e.kind {
+            ExprKind::Is(scrutinee, pat) => {
+                // At the top level of a condition, `is` expressions lower directly to `let`.
+                let hir_id = lower_id_and_attrs(self);
+                let span = self.mark_span_with_reason(
+                    DesugaringKind::IsExpr,
+                    self.lower_span(e.span),
+                    None,
+                );
+                let kind = hir::ExprKind::Let(self.arena.alloc(hir::LetExpr {
+                    span,
+                    pat: self.lower_pat(pat),
+                    ty: None,
+                    init: self.lower_expr(scrutinee),
+                    recovered: Recovered::No,
+                }));
+                hir::Expr { hir_id, kind, span }
+            }
+            ExprKind::Binary(binop @ BinOp { node: BinOpKind::And, .. }, lhs, rhs) => {
+                // `is` expressions in chains of `&&` operators can lower to `let`, so we lower the
+                // operands using `self.lower_cond` rather than `self.lower_expr`.
+                ensure_sufficient_stack(|| {
+                    let hir_id = lower_id_and_attrs(self);
+                    let binop = self.lower_binop(*binop);
+                    let lhs = self.lower_cond(lhs);
+                    let rhs = self.lower_cond(rhs);
+                    let kind = hir::ExprKind::Binary(binop, lhs, rhs);
+                    hir::Expr { hir_id, kind, span: self.lower_span(e.span) }
+                })
+            }
+            _ => return self.lower_expr_mut(e),
+        }
+    }
+
+    /// Lower `cond`, wrapped in an `if` expression's condition: `if cond { true } else { false }`.
+    /// This allows `is` expressions in `cond` to lower to `let` expressions.
+    fn lower_wrapped_cond_for_expr_is(&mut self, cond: &Expr) -> hir::Expr<'hir> {
+        let span =
+            self.mark_span_with_reason(DesugaringKind::IsExpr, self.lower_span(cond.span), None);
+        let hir_id = self.next_id();
+        let lowered_cond = self.arena.alloc(self.lower_cond_inner(cond, Some((hir_id, span))));
+        let mut bool_block = |b| {
+            let lit = hir::Lit { span, node: ast::LitKind::Bool(b) };
+            let expr_lit = self.arena.alloc(self.expr(span, hir::ExprKind::Lit(lit)));
+            let block = self.block_expr(expr_lit);
+            self.arena.alloc(self.expr_block(block))
+        };
+        let expr_true = bool_block(true);
+        let expr_false = bool_block(false);
+        let kind = hir::ExprKind::If(lowered_cond, expr_true, Some(expr_false));
+        hir::Expr { span, kind, hir_id }
+    }
+
     fn lower_expr_if(
         &mut self,
         cond: &Expr,
         then: &Block,
         else_opt: Option<&Expr>,
     ) -> hir::ExprKind<'hir> {
-        let lowered_cond = self.lower_expr(cond);
+        let lowered_cond = self.lower_cond(cond);
         let then_expr = self.lower_block_expr(then);
         if let Some(rslt) = else_opt {
             hir::ExprKind::If(
@@ -564,7 +648,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         body: &Block,
         opt_label: Option<Label>,
     ) -> hir::ExprKind<'hir> {
-        let lowered_cond = self.with_loop_condition_scope(|t| t.lower_expr(cond));
+        let lowered_cond = self.with_loop_condition_scope(|t| t.lower_cond(cond));
         let then = self.lower_block_expr(body);
         let expr_break = self.expr_break(span);
         let stmt_break = self.stmt_expr(span, expr_break);
@@ -633,7 +717,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
     fn lower_arm(&mut self, arm: &Arm) -> hir::Arm<'hir> {
         let pat = self.lower_pat(&arm.pat);
-        let guard = arm.guard.as_ref().map(|cond| self.lower_expr(cond));
+        let guard = arm.guard.as_ref().map(|cond| self.lower_cond(cond));
         let hir_id = self.next_id();
         let span = self.lower_span(arm.span);
         self.lower_attrs(hir_id, &arm.attrs, arm.span);
diff --git a/compiler/rustc_ast_lowering/src/pat.rs b/compiler/rustc_ast_lowering/src/pat.rs
index e444062104813..a835c7ca3f731 100644
--- a/compiler/rustc_ast_lowering/src/pat.rs
+++ b/compiler/rustc_ast_lowering/src/pat.rs
@@ -134,6 +134,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                         );
                     }
                     PatKind::Guard(inner, cond) => {
+                        // FIXME(is, guard_patterns): use `self.lower_cond` to support `is` bindings
                         break hir::PatKind::Guard(self.lower_pat(inner), self.lower_expr(cond));
                     }
                     PatKind::Slice(pats) => break self.lower_pat_slice(pats),
diff --git a/compiler/rustc_ast_pretty/src/pprust/state/expr.rs b/compiler/rustc_ast_pretty/src/pprust/state/expr.rs
index 8a2cb64b2a084..d85da3fcf2912 100644
--- a/compiler/rustc_ast_pretty/src/pprust/state/expr.rs
+++ b/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 {
diff --git a/compiler/rustc_builtin_macros/src/assert/context.rs b/compiler/rustc_builtin_macros/src/assert/context.rs
index ea7248ca5393a..9b6cc2ada5aa5 100644
--- a/compiler/rustc_builtin_macros/src/assert/context.rs
+++ b/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);
             }
diff --git a/compiler/rustc_parse/src/parser/expr.rs b/compiler/rustc_parse/src/parser/expr.rs
index 3d89530f91435..8abeb2d3e0a31 100644
--- a/compiler/rustc_parse/src/parser/expr.rs
+++ b/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);
             }
diff --git a/compiler/rustc_passes/src/input_stats.rs b/compiler/rustc_passes/src/input_stats.rs
index 6ee325dce0326..def22c1105088 100644
--- a/compiler/rustc_passes/src/input_stats.rs
+++ b/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,
diff --git a/compiler/rustc_resolve/src/late.rs b/compiler/rustc_resolve/src/late.rs
index a3a770502ded1..0a57e1a0ba627 100644
--- a/compiler/rustc_resolve/src/late.rs
+++ b/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",
         }
@@ -124,6 +126,18 @@ enum PatBoundCtx {
 /// Each identifier must map to at most one distinct [`Res`].
 type PatternBindings = SmallVec<[(PatBoundCtx, FxIndexMap<Ident, Res>); 1]>;
 
+/// In what scope should `is` expressions introduce bindings? See RFC 3573 for more details.
+enum IsBindingScope {
+    /// `is` expressions at the top-level of an `if` or `while` condition introduce their bindings
+    /// within the condition's rib, so that they are in scope in the expression's success block.
+    /// Likewise, within an `&&`-chain outside of an `if` or `while`, `is` expressions' bindings are
+    /// in scope for the remainder of the `&&`-chain.
+    InCurrentRib,
+    /// Indicates that an `&&` or `is` expression will need to introduce a new rib for `is`
+    /// expressions' bindings.
+    InNewRib,
+}
+
 /// Does this the item (from the item rib scope) allow generic parameters?
 #[derive(Copy, Clone, Debug)]
 pub(crate) enum HasGenericParams {
@@ -798,7 +812,7 @@ impl<'ast, 'ra, 'tcx> Visitor<'ast> for LateResolutionVisitor<'_, 'ast, 'ra, 'tc
         bug!("encountered anon const without a manual call to `resolve_anon_const`: {constant:#?}");
     }
     fn visit_expr(&mut self, expr: &'ast Expr) {
-        self.resolve_expr(expr, None);
+        self.resolve_expr(expr, None, IsBindingScope::InNewRib);
     }
     fn visit_pat(&mut self, p: &'ast Pat) {
         let prev = self.diag_metadata.current_pat;
@@ -3789,7 +3803,9 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
     fn resolve_arm(&mut self, arm: &'ast Arm) {
         self.with_rib(ValueNS, RibKind::Normal, |this| {
             this.resolve_pattern_top(&arm.pat, PatternSource::Match);
-            visit_opt!(this, visit_expr, &arm.guard);
+            if let Some(guard) = &arm.guard {
+                this.resolve_expr(guard, None, IsBindingScope::InCurrentRib)
+            }
             visit_opt!(this, visit_expr, &arm.body);
         });
     }
@@ -3931,7 +3947,9 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
                     let subpat_bindings = bindings.pop().unwrap().1;
                     self.with_rib(ValueNS, RibKind::Normal, |this| {
                         *this.innermost_rib_bindings(ValueNS) = subpat_bindings.clone();
-                        this.resolve_expr(guard, None);
+                        // FIXME(guard_patterns): For `is` guards, we'll want to call `resolve_expr`
+                        // with `IsBindingScope::InCurrentRib`.
+                        this.resolve_expr(guard, None, IsBindingScope::InNewRib);
                     });
                     // Propagate the subpattern's bindings upwards.
                     // FIXME(guard_patterns): For `if let` guards, we'll also need to get the
@@ -4721,7 +4739,7 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
             .value
             .is_potential_trivial_const_arg(self.r.tcx.features().min_generic_const_args());
         self.resolve_anon_const_manual(is_trivial_const_arg, anon_const_kind, |this| {
-            this.resolve_expr(&constant.value, None)
+            this.visit_expr(&constant.value)
         })
     }
 
@@ -4765,12 +4783,17 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
     }
 
     fn resolve_expr_field(&mut self, f: &'ast ExprField, e: &'ast Expr) {
-        self.resolve_expr(&f.expr, Some(e));
+        self.resolve_expr(&f.expr, Some(e), IsBindingScope::InNewRib);
         self.visit_ident(&f.ident);
         walk_list!(self, visit_attribute, f.attrs.iter());
     }
 
-    fn resolve_expr(&mut self, expr: &'ast Expr, parent: Option<&'ast Expr>) {
+    fn resolve_expr(
+        &mut self,
+        expr: &'ast Expr,
+        parent: Option<&'ast Expr>,
+        is_binding_scope: IsBindingScope,
+    ) {
         // First, record candidate traits for this expression if it could
         // result in the invocation of a method call.
 
@@ -4819,7 +4842,7 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
             ExprKind::Break(None, Some(ref e)) => {
                 // We use this instead of `visit::walk_expr` to keep the parent expr around for
                 // better diagnostics.
-                self.resolve_expr(e, Some(expr));
+                self.resolve_expr(e, Some(expr), IsBindingScope::InNewRib);
             }
 
             ExprKind::Let(ref pat, ref scrutinee, _, Recovered::No) => {
@@ -4844,10 +4867,22 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
                 self.apply_pattern_bindings(bindings);
             }
 
+            ExprKind::Is(ref scrutinee, ref pat) => {
+                self.visit_expr(scrutinee);
+                match is_binding_scope {
+                    IsBindingScope::InCurrentRib => {
+                        self.resolve_pattern_top(pat, PatternSource::Is)
+                    }
+                    IsBindingScope::InNewRib => self.with_rib(ValueNS, RibKind::Normal, |this| {
+                        this.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);
-                    this.visit_expr(cond);
+                    this.resolve_expr(cond, None, IsBindingScope::InCurrentRib);
                     this.diag_metadata.in_if_condition = old;
                     this.visit_block(then);
                 });
@@ -4864,7 +4899,7 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
                 self.with_resolved_label(label, expr.id, |this| {
                     this.with_rib(ValueNS, RibKind::Normal, |this| {
                         let old = this.diag_metadata.in_if_condition.replace(cond);
-                        this.visit_expr(cond);
+                        this.resolve_expr(cond, None, IsBindingScope::InCurrentRib);
                         this.diag_metadata.in_if_condition = old;
                         this.visit_block(block);
                     })
@@ -4879,22 +4914,42 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
                 });
             }
 
+            ExprKind::Binary(BinOp { node: BinOpKind::And, .. }, ref lhs, ref rhs) => {
+                match is_binding_scope {
+                    // At the top level of an `&&`-chain, we introduce a new rib to restrict `is`
+                    // expressions' bindings' lexical scope to that `&&`-chain.
+                    IsBindingScope::InNewRib if lhs.has_expr_is() || rhs.has_expr_is() => self
+                        .with_rib(ValueNS, RibKind::Normal, |this| {
+                            this.resolve_expr(lhs, None, IsBindingScope::InCurrentRib);
+                            this.resolve_expr(rhs, None, IsBindingScope::InCurrentRib);
+                        }),
+                    // Inside an `&&`-chain, we use the `&&`-chain's rib.
+                    // We also avoid introducing a new rib if the `&&`-chain has no `is`
+                    // expressions, to reduce the number of diagnostics emitted for malformed
+                    // `let` chains such as `(let x = true) && x`.
+                    IsBindingScope::InCurrentRib | IsBindingScope::InNewRib => {
+                        self.resolve_expr(lhs, None, IsBindingScope::InCurrentRib);
+                        self.resolve_expr(rhs, None, IsBindingScope::InCurrentRib);
+                    }
+                }
+            }
+
             ExprKind::Block(ref block, label) => self.resolve_labeled_block(label, block.id, block),
 
             // Equivalent to `visit::walk_expr` + passing some context to children.
             ExprKind::Field(ref subexpression, _) => {
-                self.resolve_expr(subexpression, Some(expr));
+                self.resolve_expr(subexpression, Some(expr), IsBindingScope::InNewRib);
             }
             ExprKind::MethodCall(box MethodCall { ref seg, ref receiver, ref args, .. }) => {
-                self.resolve_expr(receiver, Some(expr));
+                self.resolve_expr(receiver, Some(expr), IsBindingScope::InNewRib);
                 for arg in args {
-                    self.resolve_expr(arg, None);
+                    self.resolve_expr(arg, None, IsBindingScope::InNewRib);
                 }
                 self.visit_path_segment(seg);
             }
 
             ExprKind::Call(ref callee, ref arguments) => {
-                self.resolve_expr(callee, Some(expr));
+                self.resolve_expr(callee, Some(expr), IsBindingScope::InNewRib);
                 let const_args = self.r.legacy_const_generic_args(callee).unwrap_or_default();
                 for (idx, argument) in arguments.iter().enumerate() {
                     // Constant arguments need to be treated as AnonConst since
@@ -4906,10 +4961,10 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
                         self.resolve_anon_const_manual(
                             is_trivial_const_arg,
                             AnonConstKind::ConstArg(IsRepeatExpr::No),
-                            |this| this.resolve_expr(argument, None),
+                            |this| this.visit_expr(argument),
                         );
                     } else {
-                        self.resolve_expr(argument, None);
+                        self.visit_expr(argument);
                     }
                 }
             }
@@ -4942,7 +4997,7 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
                 self.resolve_anon_const(ct, AnonConstKind::InlineConst);
             }
             ExprKind::Index(ref elem, ref idx, _) => {
-                self.resolve_expr(elem, Some(expr));
+                self.resolve_expr(elem, Some(expr), IsBindingScope::InNewRib);
                 self.visit_expr(idx);
             }
             ExprKind::Assign(ref lhs, ref rhs, _) => {
@@ -4957,8 +5012,8 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
             }
             ExprKind::Range(Some(ref start), Some(ref end), RangeLimits::HalfOpen) => {
                 self.diag_metadata.in_range = Some((start, end));
-                self.resolve_expr(start, Some(expr));
-                self.resolve_expr(end, Some(expr));
+                self.resolve_expr(start, Some(expr), IsBindingScope::InNewRib);
+                self.resolve_expr(end, Some(expr), IsBindingScope::InNewRib);
                 self.diag_metadata.in_range = None;
             }
             _ => {
diff --git a/compiler/rustc_span/src/hygiene.rs b/compiler/rustc_span/src/hygiene.rs
index c3080875da803..c64d32ad01b71 100644
--- a/compiler/rustc_span/src/hygiene.rs
+++ b/compiler/rustc_span/src/hygiene.rs
@@ -1219,6 +1219,8 @@ pub enum DesugaringKind {
         /// rewriting it.
         source: bool,
     },
+    /// Desugaring of an `expr is pat` expression
+    IsExpr,
 }
 
 impl DesugaringKind {
@@ -1240,6 +1242,7 @@ impl DesugaringKind {
             DesugaringKind::FormatLiteral { source: false } => {
                 "expression that expanded into a format string literal"
             }
+            DesugaringKind::IsExpr => "`is` expression",
         }
     }
 
@@ -1259,6 +1262,7 @@ impl DesugaringKind {
             DesugaringKind::Contract => value == "Contract",
             DesugaringKind::PatTyRange => value == "PatTyRange",
             DesugaringKind::FormatLiteral { .. } => value == "FormatLiteral",
+            DesugaringKind::IsExpr => value == "IsExpr",
         }
     }
 }
diff --git a/src/tools/clippy/clippy_utils/src/sugg.rs b/src/tools/clippy/clippy_utils/src/sugg.rs
index 7a24d07fa1dfb..67edea620baf1 100644
--- a/src/tools/clippy/clippy_utils/src/sugg.rs
+++ b/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),
diff --git a/src/tools/rustfmt/src/expr.rs b/src/tools/rustfmt/src/expr.rs
index 08aedff2b20da..0d833061b97ee 100644
--- a/src/tools/rustfmt/src/expr.rs
+++ b/src/tools/rustfmt/src/expr.rs
@@ -426,6 +426,10 @@ pub(crate) fn format_expr(
             // Also, rustfmt might get passed the output from `-Zunpretty=expanded`.
             Err(RewriteError::Unknown)
         }
+        ast::ExprKind::Is(..) => {
+            // FIXME(is): add formatting for `expr is pat` expressions.
+            Err(RewriteError::Unknown)
+        }
         ast::ExprKind::Err(_) | ast::ExprKind::Dummy => Err(RewriteError::Unknown),
     };
 
diff --git a/src/tools/rustfmt/src/utils.rs b/src/tools/rustfmt/src/utils.rs
index fcd475b1784f5..a9f349b5007fa 100644
--- a/src/tools/rustfmt/src/utils.rs
+++ b/src/tools/rustfmt/src/utils.rs
@@ -505,6 +505,7 @@ pub(crate) fn is_block_expr(context: &RewriteContext<'_>, expr: &ast::Expr, repr
         | ast::ExprKind::Field(..)
         | ast::ExprKind::IncludedBytes(..)
         | ast::ExprKind::InlineAsm(..)
+        | ast::ExprKind::Is(..)
         | ast::ExprKind::OffsetOf(..)
         | ast::ExprKind::UnsafeBinderCast(..)
         | ast::ExprKind::Let(..)
diff --git a/tests/ui/rfcs/rfc-3573-is/auxiliary/is-macro.rs b/tests/ui/rfcs/rfc-3573-is/auxiliary/is-macro.rs
new file mode 100644
index 0000000000000..201001bf7932f
--- /dev/null
+++ b/tests/ui/rfcs/rfc-3573-is/auxiliary/is-macro.rs
@@ -0,0 +1,7 @@
+// FIXME(is): This syntax is a placeholder.
+#[macro_export]
+macro_rules! is {
+    ($($args:tt)*) => {
+        builtin # is($($args)*)
+    }
+}
diff --git a/tests/ui/rfcs/rfc-3573-is/desugaring.rs b/tests/ui/rfcs/rfc-3573-is/desugaring.rs
new file mode 100644
index 0000000000000..05325d4176202
--- /dev/null
+++ b/tests/ui/rfcs/rfc-3573-is/desugaring.rs
@@ -0,0 +1,21 @@
+//! Test desugaring of `is` expressions to `let` and `if`.
+//@ check-pass
+//@ compile-flags: -Z unpretty=hir
+//@ edition: 2024
+#![feature(builtin_syntax)]
+
+fn main() {
+    // At the top level of an `if` or `while` condition, `is` desugars directly to `let`.
+    if true && builtin # is(0 is 0) && true {}
+    while true && builtin # is(0 is 0) && true {}
+
+    // Otherwise, an `&&`-chain with `is` in it is wrapped in an `if` expression.
+    builtin # is(0 is 0);
+    true && builtin # is(0 is 0) && true;
+
+    // `let` isn't allowed under parentheses or other operators.
+    // `is` anywhere other than the top level `&&`-chain of a condition is wrapped in an `if`.
+    if (builtin # is(0 is 0)) {}
+    if (true && builtin # is(0 is 0) && true) {}
+    if builtin # is(0 is 0) || true && builtin # is(0 is 0) && true {}
+}
diff --git a/tests/ui/rfcs/rfc-3573-is/desugaring.stdout b/tests/ui/rfcs/rfc-3573-is/desugaring.stdout
new file mode 100644
index 0000000000000..852a4f3bcf45d
--- /dev/null
+++ b/tests/ui/rfcs/rfc-3573-is/desugaring.stdout
@@ -0,0 +1,27 @@
+//! Test desugaring of `is` expressions to `let` and `if`.
+//@ check-pass
+//@ compile-flags: -Z unpretty=hir
+//@ edition: 2024
+#![feature(builtin_syntax)]
+#[prelude_import]
+use std::prelude::rust_2024::*;
+#[attr = MacroUse {arguments: UseAll}]
+extern crate std;
+
+fn main() {
+    // At the top level of an `if` or `while` condition, `is` desugars directly to `let`.
+    if true && let 0 = 0 && true { }
+    loop { if true && let 0 = 0 && true { } else { break; } }
+
+    // Otherwise, an `&&`-chain with `is` in it is wrapped in an `if` expression.
+    if let 0 = 0 { true } else { false };
+    if true && let 0 = 0 && true { true } else { false };
+
+    // `let` isn't allowed under parentheses or other operators.
+    // `is` anywhere other than the top level `&&`-chain of a condition is wrapped in an `if`.
+    if if let 0 = 0 { true } else { false } { }
+    if if true && let 0 = 0 && true { true } else { false } { }
+    if if let 0 = 0 { true } else { false } ||
+            if true && let 0 = 0 && true { true } else { false } {
+    }
+}
diff --git a/tests/ui/rfcs/rfc-3573-is/drop-scopes.rs b/tests/ui/rfcs/rfc-3573-is/drop-scopes.rs
new file mode 100644
index 0000000000000..11f935307655a
--- /dev/null
+++ b/tests/ui/rfcs/rfc-3573-is/drop-scopes.rs
@@ -0,0 +1,76 @@
+//! Demonstrates where temporaries and bindings for `is` expressions are dropped.
+//@ edition: 2024
+//@ run-pass
+//@ aux-crate: is_macro=is-macro.rs
+#![feature(builtin_syntax)]
+use is_macro::is;
+
+use core::{cell::RefCell, ops::Drop};
+
+#[expect(irrefutable_let_patterns)]
+fn main() {
+    // `is` used where a `let` expression is allowed desugars directly to `let`, using the scope of
+    // the enclosing condition. As such, its temporaries and bindings behave the same as `let`'s.
+    assert_drop_order(1..=6, |o| {
+        if is!(o.log(5).ignore_temp().log(4) is _v)
+            && is!(o.log(3).ignore_temp().log(2) is _v)
+        {
+            // The bindings and temporaries are all dropped after locals declared within the block.
+            let _v = o.log(1);
+        }
+        // Everything is dropped before leaving the success block.
+        o.log(6);
+    });
+
+    // `is` used elsewhere introduces a new scope.
+    assert_drop_order(1..=9, |o| {
+        // `let` isn't allowed through parentheses; the `is`'s bindings and temporaries only live to
+        // the end of the `&&`-chain they're in.
+        if (
+            is!(o.log(4).ignore_temp().log(3) is _v)
+                && is!(o.log(2).ignore_temp().log(1) is _v)
+        ) && (
+            is!(o.log(8).ignore_temp().log(7) is _v)
+                && is!(o.log(6).ignore_temp().log(5) is _v)
+        ) {
+            o.log(9);
+        }
+    });
+}
+
+// # Test scaffolding...
+
+struct DropOrder(RefCell<Vec<u64>>);
+struct LogDrop<'o>(&'o DropOrder, u64);
+
+impl DropOrder {
+    fn log(&self, n: u64) -> LogDrop<'_> {
+        LogDrop(self, n)
+    }
+    fn push(&self, n: u64) {
+        self.0.borrow_mut().push(n);
+    }
+}
+
+impl<'o> Drop for LogDrop<'o> {
+    fn drop(&mut self) {
+        self.0.push(self.1);
+    }
+}
+impl<'o> LogDrop<'o> {
+    fn ignore_temp(&self) -> &'o DropOrder {
+        self.0
+    }
+}
+
+#[track_caller]
+fn assert_drop_order(
+    ex: impl IntoIterator<Item = u64>,
+    f: impl Fn(&DropOrder),
+) {
+    let order = DropOrder(RefCell::new(Vec::new()));
+    f(&order);
+    let order = order.0.into_inner();
+    let expected: Vec<u64> = ex.into_iter().collect();
+    assert_eq!(order, expected);
+}
diff --git a/tests/ui/rfcs/rfc-3573-is/name-resolution-errors.rs b/tests/ui/rfcs/rfc-3573-is/name-resolution-errors.rs
new file mode 100644
index 0000000000000..5e448f2f598d6
--- /dev/null
+++ b/tests/ui/rfcs/rfc-3573-is/name-resolution-errors.rs
@@ -0,0 +1,73 @@
+//! Test that the lexical scope for `is`'s bindings doesn't extend farther than it should.
+//@ edition: 2024
+//@ aux-crate: is_macro=is-macro.rs
+#![feature(builtin_syntax)]
+use is_macro::is;
+
+fn main() {
+    // `is` used where `let` expressions can be used behaves like a `let` expression.
+    if x //~ ERROR cannot find value `x` in this scope
+        && is!(true is x)
+        && x
+    {
+        x;
+    } else {
+        x; //~ ERROR cannot find value `x` in this scope
+    }
+    x; //~ ERROR cannot find value `x` in this scope
+
+    // Elsewhere, `is`'s bindings only extend to the end of its `&&`-chain.
+    if x //~ ERROR cannot find value `x` in this scope
+        && (is!(true is x) && x && { x })
+        && x //~ ERROR cannot find value `x` in this scope
+        && (is!(true is x) || x) //~ ERROR cannot find value `x` in this scope
+        && (!is!(true is x) || x) //~ ERROR cannot find value `x` in this scope
+        && (is!(true is x) & x) //~ ERROR cannot find value `x` in this scope
+    {
+        x; //~ ERROR cannot find value `x` in this scope
+    }
+
+    match is!(true is x) {
+        _ => { x; } //~ ERROR cannot find value `x` in this scope
+    }
+
+    match () {
+        () if is!(true is x) && x => { x; }
+        () if x => {} //~ ERROR cannot find value `x` in this scope
+    }
+
+    match () {
+        () if is!(true is x) && x => { x; }
+        () => { x; } //~ ERROR cannot find value `x` in this scope
+    }
+
+    fn f(_a: bool, _b: bool) {}
+    f(is!(true is x) && x, true);
+    f(is!(true is x), x); //~ ERROR cannot find value `x` in this scope
+    f(is!(true is x) && x, x); //~ ERROR cannot find value `x` in this scope
+
+    if !is!(true is x) {
+        x; //~ ERROR cannot find value `x` in this scope
+    } else {
+        x; //~ ERROR cannot find value `x` in this scope
+    }
+
+    if true
+        && if is!(true is x) && x { x } else { false }
+        && x //~ ERROR cannot find value `x` in this scope
+    {
+        x; //~ ERROR cannot find value `x` in this scope
+    }
+
+    while is!(true is x) {
+        x;
+        break;
+    }
+    x; //~ ERROR cannot find value `x` in this scope
+
+    is!(true is x);
+    x; //~ ERROR cannot find value `x` in this scope
+
+    is!(true is x);
+    x; //~ ERROR cannot find value `x` in this scope
+}
diff --git a/tests/ui/rfcs/rfc-3573-is/name-resolution-errors.stderr b/tests/ui/rfcs/rfc-3573-is/name-resolution-errors.stderr
new file mode 100644
index 0000000000000..5de4ae9e3a4dd
--- /dev/null
+++ b/tests/ui/rfcs/rfc-3573-is/name-resolution-errors.stderr
@@ -0,0 +1,192 @@
+error[E0425]: cannot find value `x` in this scope
+  --> $DIR/name-resolution-errors.rs:9:8
+   |
+LL |     if x
+   |        ^ help: a function with a similar name exists: `f`
+...
+LL |     fn f(_a: bool, _b: bool) {}
+   |     ------------------------ similarly named function `f` defined here
+
+error[E0425]: cannot find value `x` in this scope
+  --> $DIR/name-resolution-errors.rs:15:9
+   |
+LL |         x;
+   |         ^ help: a function with a similar name exists: `f`
+...
+LL |     fn f(_a: bool, _b: bool) {}
+   |     ------------------------ similarly named function `f` defined here
+
+error[E0425]: cannot find value `x` in this scope
+  --> $DIR/name-resolution-errors.rs:17:5
+   |
+LL |     x;
+   |     ^ help: a function with a similar name exists: `f`
+...
+LL |     fn f(_a: bool, _b: bool) {}
+   |     ------------------------ similarly named function `f` defined here
+
+error[E0425]: cannot find value `x` in this scope
+  --> $DIR/name-resolution-errors.rs:20:8
+   |
+LL |     if x
+   |        ^ help: a function with a similar name exists: `f`
+...
+LL |     fn f(_a: bool, _b: bool) {}
+   |     ------------------------ similarly named function `f` defined here
+
+error[E0425]: cannot find value `x` in this scope
+  --> $DIR/name-resolution-errors.rs:22:12
+   |
+LL |         && x
+   |            ^ help: a function with a similar name exists: `f`
+...
+LL |     fn f(_a: bool, _b: bool) {}
+   |     ------------------------ similarly named function `f` defined here
+
+error[E0425]: cannot find value `x` in this scope
+  --> $DIR/name-resolution-errors.rs:23:31
+   |
+LL |         && (is!(true is x) || x)
+   |                               ^ help: a function with a similar name exists: `f`
+...
+LL |     fn f(_a: bool, _b: bool) {}
+   |     ------------------------ similarly named function `f` defined here
+
+error[E0425]: cannot find value `x` in this scope
+  --> $DIR/name-resolution-errors.rs:24:32
+   |
+LL |         && (!is!(true is x) || x)
+   |                                ^ help: a function with a similar name exists: `f`
+...
+LL |     fn f(_a: bool, _b: bool) {}
+   |     ------------------------ similarly named function `f` defined here
+
+error[E0425]: cannot find value `x` in this scope
+  --> $DIR/name-resolution-errors.rs:25:30
+   |
+LL |         && (is!(true is x) & x)
+   |                              ^ help: a function with a similar name exists: `f`
+...
+LL |     fn f(_a: bool, _b: bool) {}
+   |     ------------------------ similarly named function `f` defined here
+
+error[E0425]: cannot find value `x` in this scope
+  --> $DIR/name-resolution-errors.rs:27:9
+   |
+LL |         x;
+   |         ^ help: a function with a similar name exists: `f`
+...
+LL |     fn f(_a: bool, _b: bool) {}
+   |     ------------------------ similarly named function `f` defined here
+
+error[E0425]: cannot find value `x` in this scope
+  --> $DIR/name-resolution-errors.rs:31:16
+   |
+LL |         _ => { x; }
+   |                ^ help: a function with a similar name exists: `f`
+...
+LL |     fn f(_a: bool, _b: bool) {}
+   |     ------------------------ similarly named function `f` defined here
+
+error[E0425]: cannot find value `x` in this scope
+  --> $DIR/name-resolution-errors.rs:36:15
+   |
+LL |         () if x => {}
+   |               ^ help: a function with a similar name exists: `f`
+...
+LL |     fn f(_a: bool, _b: bool) {}
+   |     ------------------------ similarly named function `f` defined here
+
+error[E0425]: cannot find value `x` in this scope
+  --> $DIR/name-resolution-errors.rs:41:17
+   |
+LL |         () => { x; }
+   |                 ^ help: a function with a similar name exists: `f`
+...
+LL |     fn f(_a: bool, _b: bool) {}
+   |     ------------------------ similarly named function `f` defined here
+
+error[E0425]: cannot find value `x` in this scope
+  --> $DIR/name-resolution-errors.rs:46:23
+   |
+LL |     fn f(_a: bool, _b: bool) {}
+   |     ------------------------ similarly named function `f` defined here
+LL |     f(is!(true is x) && x, true);
+LL |     f(is!(true is x), x);
+   |                       ^ help: a function with a similar name exists: `f`
+
+error[E0425]: cannot find value `x` in this scope
+  --> $DIR/name-resolution-errors.rs:47:28
+   |
+LL |     fn f(_a: bool, _b: bool) {}
+   |     ------------------------ similarly named function `f` defined here
+...
+LL |     f(is!(true is x) && x, x);
+   |                            ^ help: a function with a similar name exists: `f`
+
+error[E0425]: cannot find value `x` in this scope
+  --> $DIR/name-resolution-errors.rs:50:9
+   |
+LL |     fn f(_a: bool, _b: bool) {}
+   |     ------------------------ similarly named function `f` defined here
+...
+LL |         x;
+   |         ^ help: a function with a similar name exists: `f`
+
+error[E0425]: cannot find value `x` in this scope
+  --> $DIR/name-resolution-errors.rs:52:9
+   |
+LL |     fn f(_a: bool, _b: bool) {}
+   |     ------------------------ similarly named function `f` defined here
+...
+LL |         x;
+   |         ^ help: a function with a similar name exists: `f`
+
+error[E0425]: cannot find value `x` in this scope
+  --> $DIR/name-resolution-errors.rs:57:12
+   |
+LL |     fn f(_a: bool, _b: bool) {}
+   |     ------------------------ similarly named function `f` defined here
+...
+LL |         && x
+   |            ^ help: a function with a similar name exists: `f`
+
+error[E0425]: cannot find value `x` in this scope
+  --> $DIR/name-resolution-errors.rs:59:9
+   |
+LL |     fn f(_a: bool, _b: bool) {}
+   |     ------------------------ similarly named function `f` defined here
+...
+LL |         x;
+   |         ^ help: a function with a similar name exists: `f`
+
+error[E0425]: cannot find value `x` in this scope
+  --> $DIR/name-resolution-errors.rs:66:5
+   |
+LL |     fn f(_a: bool, _b: bool) {}
+   |     ------------------------ similarly named function `f` defined here
+...
+LL |     x;
+   |     ^ help: a function with a similar name exists: `f`
+
+error[E0425]: cannot find value `x` in this scope
+  --> $DIR/name-resolution-errors.rs:69:5
+   |
+LL |     fn f(_a: bool, _b: bool) {}
+   |     ------------------------ similarly named function `f` defined here
+...
+LL |     x;
+   |     ^ help: a function with a similar name exists: `f`
+
+error[E0425]: cannot find value `x` in this scope
+  --> $DIR/name-resolution-errors.rs:72:5
+   |
+LL |     fn f(_a: bool, _b: bool) {}
+   |     ------------------------ similarly named function `f` defined here
+...
+LL |     x;
+   |     ^ help: a function with a similar name exists: `f`
+
+error: aborting due to 21 previous errors
+
+For more information about this error, try `rustc --explain E0425`.
diff --git a/tests/ui/rfcs/rfc-3573-is/run-pass-simple.rs b/tests/ui/rfcs/rfc-3573-is/run-pass-simple.rs
new file mode 100644
index 0000000000000..bbdf7327f6799
--- /dev/null
+++ b/tests/ui/rfcs/rfc-3573-is/run-pass-simple.rs
@@ -0,0 +1,60 @@
+//! Simple tests for matching and binding with `is` expressions.
+//@ run-pass
+//@ edition: 2024
+//@ aux-crate: is_macro=is-macro.rs
+#![feature(builtin_syntax)]
+use is_macro::is;
+
+// Test `is` used as `let` in `if` conditions.
+fn test_if() {
+    for test_in in [None, Some(3), Some(4)] {
+        let test_if_expr = if is!(test_in is Some(x)) && x > 3 {
+            // `x` is bound in the success block
+            x
+        } else {
+            0
+        };
+        let test_guard = match test_in {
+            x if is!(x is Some(y)) && y > 3 => {
+                // `y` is bound in the arm body
+                y
+            }
+            _ => 0,
+        };
+        let test_expected = if let Some(x) = test_in && x > 3 {
+            x
+        } else {
+            0
+        };
+        assert_eq!(test_if_expr, test_expected);
+        assert_eq!(test_guard, test_expected);
+    }
+}
+
+// Test `is` used as `let` in `while` conditions.
+fn test_while() {
+    let mut count = 0;
+    let mut opt = Some(3u8);
+    while is!(opt is Some(x)) {
+        // `x` is bound in the loop body
+        count += 1;
+        opt = x.checked_sub(1);
+    }
+    assert_eq!(count, 4);
+}
+
+// Test `is` not directly in an `if` or `while` condition.
+fn test_elsewhere() {
+    for test_in in [None, Some(None), Some(Some(3)), Some(Some(4))] {
+        let test_is = is!(test_in is Some(x)) && is!(x is Some(y)) && y > 3;
+        let test_expected =
+            if let Some(x) = test_in && let Some(y) = x && y > 3 { true } else { false };
+        assert_eq!(test_is, test_expected);
+    }
+}
+
+fn main() {
+    test_if();
+    test_while();
+    test_elsewhere();
+}