rust-lang · c410-f3r · Jan 28, 2022
diff --git a/compiler/rustc_ast/src/ast.rs b/compiler/rustc_ast/src/ast.rs
@@ -930,6 +930,7 @@ pub struct Stmt {
 impl Stmt {
     pub fn tokens(&self) -> Option<&LazyTokenStream> {
         match self.kind {
+            StmtKind::LetElse(ref let_else) => let_else.tokens.as_ref(),
             StmtKind::Local(ref local) => local.tokens.as_ref(),
             StmtKind::Item(ref item) => item.tokens.as_ref(),
             StmtKind::Expr(ref expr) | StmtKind::Semi(ref expr) => expr.tokens.as_ref(),
@@ -978,6 +979,8 @@ impl Stmt {
 
 #[derive(Clone, Encodable, Decodable, Debug)]
 pub enum StmtKind {
+    /// See [`LetElse`].
+    LetElse(P<LetElse>),
     /// A local (let) binding.
     Local(P<Local>),
     /// An item definition.
@@ -1013,6 +1016,17 @@ pub enum MacStmtStyle {
     NoBraces,
 }
 
+/// A `let .. && let && .. else { .. }` declaration.
+#[derive(Clone, Encodable, Decodable, Debug)]
+pub struct LetElse {
+    pub attrs: AttrVec,
+    pub expr: P<Expr>,
+    pub id: NodeId,
+    pub r#else: P<Block>,
+    pub span: Span,
+    pub tokens: Option<LazyTokenStream>,
+}
+
 /// Local represents a `let` statement, e.g., `let <pat>:<ty> = <expr>;`.
 #[derive(Clone, Encodable, Decodable, Debug)]
 pub struct Local {
@@ -1033,24 +1047,13 @@ pub enum LocalKind {
     /// Local declaration with an initializer.
     /// Example: `let x = y;`
     Init(P<Expr>),
-    /// Local declaration with an initializer and an `else` clause.
-    /// Example: `let Some(x) = y else { return };`
-    InitElse(P<Expr>, P<Block>),
 }
 
 impl LocalKind {
     pub fn init(&self) -> Option<&Expr> {
         match self {
             Self::Decl => None,
-            Self::Init(i) | Self::InitElse(i, _) => Some(i),
-        }
-    }
-
-    pub fn init_else_opt(&self) -> Option<(&Expr, Option<&Block>)> {
-        match self {
-            Self::Decl => None,
-            Self::Init(init) => Some((init, None)),
-            Self::InitElse(init, els) => Some((init, Some(els))),
+            Self::Init(i) => Some(i),
         }
     }
 }

diff --git a/compiler/rustc_ast/src/ast_like.rs b/compiler/rustc_ast/src/ast_like.rs
@@ -2,7 +2,7 @@ use super::ptr::P;
 use super::token::Nonterminal;
 use super::tokenstream::LazyTokenStream;
 use super::{Arm, Crate, ExprField, FieldDef, GenericParam, Param, PatField, Variant};
-use super::{AssocItem, Expr, ForeignItem, Item, Local, MacCallStmt};
+use super::{AssocItem, Expr, ForeignItem, Item, LetElse, Local, MacCallStmt};
 use super::{AttrItem, AttrKind, Block, Pat, Path, Ty, Visibility};
 use super::{AttrVec, Attribute, Stmt, StmtKind};
 
@@ -104,6 +104,7 @@ impl AstLike for StmtKind {
 
     fn attrs(&self) -> &[Attribute] {
         match self {
+            StmtKind::LetElse(let_else) => let_else.attrs(),
             StmtKind::Local(local) => local.attrs(),
             StmtKind::Expr(expr) | StmtKind::Semi(expr) => expr.attrs(),
             StmtKind::Item(item) => item.attrs(),
@@ -114,6 +115,7 @@ impl AstLike for StmtKind {
 
     fn visit_attrs(&mut self, f: impl FnOnce(&mut Vec<Attribute>)) {
         match self {
+            StmtKind::LetElse(let_else) => let_else.visit_attrs(f),
             StmtKind::Local(local) => local.visit_attrs(f),
             StmtKind::Expr(expr) | StmtKind::Semi(expr) => expr.visit_attrs(f),
             StmtKind::Item(item) => item.visit_attrs(f),
@@ -123,6 +125,7 @@ impl AstLike for StmtKind {
     }
     fn tokens_mut(&mut self) -> Option<&mut Option<LazyTokenStream>> {
         Some(match self {
+            StmtKind::LetElse(let_else) => &mut let_else.tokens,
             StmtKind::Local(local) => &mut local.tokens,
             StmtKind::Item(item) => &mut item.tokens,
             StmtKind::Expr(expr) | StmtKind::Semi(expr) => &mut expr.tokens,
@@ -271,7 +274,7 @@ derive_has_tokens_and_attrs! {
 
 derive_has_tokens_and_attrs! {
     const SUPPORTS_CUSTOM_INNER_ATTRS: bool = false;
-    Local, MacCallStmt, Expr
+    LetElse, Local, MacCallStmt, Expr
 }
 
 // These ast nodes only support inert attributes, so they don't

diff --git a/compiler/rustc_ast/src/mut_visit.rs b/compiler/rustc_ast/src/mut_visit.rs
@@ -201,6 +201,10 @@ pub trait MutVisitor: Sized {
         noop_visit_parenthesized_parameter_data(p, self);
     }
 
+    fn visit_let_else(&mut self, let_else: &mut P<LetElse>) {
+        noop_visit_let_else(let_else, self);
+    }
+
     fn visit_local(&mut self, l: &mut P<Local>) {
         noop_visit_local(l, self);
     }
@@ -569,6 +573,16 @@ pub fn noop_visit_parenthesized_parameter_data<T: MutVisitor>(
     vis.visit_span(span);
 }
 
+pub fn noop_visit_let_else<T: MutVisitor>(let_else: &mut P<LetElse>, vis: &mut T) {
+    let LetElse { attrs, expr, id, r#else, span, tokens } = let_else.deref_mut();
+    visit_thin_attrs(attrs, vis);
+    vis.visit_expr(expr);
+    vis.visit_id(id);
+    vis.visit_block(r#else);
+    vis.visit_span(span);
+    visit_lazy_tts(tokens, vis);
+}
+
 pub fn noop_visit_local<T: MutVisitor>(local: &mut P<Local>, vis: &mut T) {
     let Local { id, pat, ty, kind, span, attrs, tokens } = local.deref_mut();
     vis.visit_id(id);
@@ -579,10 +593,6 @@ pub fn noop_visit_local<T: MutVisitor>(local: &mut P<Local>, vis: &mut T) {
         LocalKind::Init(init) => {
             vis.visit_expr(init);
         }
-        LocalKind::InitElse(init, els) => {
-            vis.visit_expr(init);
-            vis.visit_block(els);
-        }
     }
     vis.visit_span(span);
     visit_thin_attrs(attrs, vis);
@@ -1408,6 +1418,10 @@ pub fn noop_flat_map_stmt_kind<T: MutVisitor>(
     vis: &mut T,
 ) -> SmallVec<[StmtKind; 1]> {
     match kind {
+        StmtKind::LetElse(mut let_else) => smallvec![StmtKind::LetElse({
+            vis.visit_let_else(&mut let_else);
+            let_else
+        })],
         StmtKind::Local(mut local) => smallvec![StmtKind::Local({
             vis.visit_local(&mut local);
             local

diff --git a/compiler/rustc_ast/src/visit.rs b/compiler/rustc_ast/src/visit.rs
@@ -93,6 +93,9 @@ pub trait Visitor<'ast>: Sized {
     fn visit_item(&mut self, i: &'ast Item) {
         walk_item(self, i)
     }
+    fn visit_let_else(&mut self, let_else: &'ast LetElse) {
+        walk_let_else(self, let_else)
+    }
     fn visit_local(&mut self, l: &'ast Local) {
         walk_local(self, l)
     }
@@ -239,16 +242,20 @@ pub fn walk_crate<'a, V: Visitor<'a>>(visitor: &mut V, krate: &'a Crate) {
     walk_list!(visitor, visit_attribute, &krate.attrs);
 }
 
+pub fn walk_let_else<'a, V: Visitor<'a>>(visitor: &mut V, let_else: &'a LetElse) {
+    for attr in let_else.attrs.iter() {
+        visitor.visit_attribute(attr);
+    }
+    visitor.visit_expr(&let_else.expr);
+    visitor.visit_block(&let_else.r#else);
+}
+
 pub fn walk_local<'a, V: Visitor<'a>>(visitor: &mut V, local: &'a Local) {
     for attr in local.attrs.iter() {
         visitor.visit_attribute(attr);
     }
     visitor.visit_pat(&local.pat);
     walk_list!(visitor, visit_ty, &local.ty);
-    if let Some((init, els)) = local.kind.init_else_opt() {
-        visitor.visit_expr(init);
-        walk_list!(visitor, visit_block, els);
-    }
 }
 
 pub fn walk_label<'a, V: Visitor<'a>>(visitor: &mut V, label: &'a Label) {
@@ -695,6 +702,7 @@ pub fn walk_block<'a, V: Visitor<'a>>(visitor: &mut V, block: &'a Block) {
 
 pub fn walk_stmt<'a, V: Visitor<'a>>(visitor: &mut V, statement: &'a Stmt) {
     match statement.kind {
+        StmtKind::LetElse(ref let_else) => visitor.visit_let_else(let_else),
         StmtKind::Local(ref local) => visitor.visit_local(local),
         StmtKind::Item(ref item) => visitor.visit_item(item),
         StmtKind::Expr(ref expr) | StmtKind::Semi(ref expr) => visitor.visit_expr(expr),

diff --git a/compiler/rustc_ast_lowering/src/block.rs b/compiler/rustc_ast_lowering/src/block.rs
@@ -1,5 +1,5 @@
 use crate::{ImplTraitContext, ImplTraitPosition, LoweringContext};
-use rustc_ast::{AttrVec, Block, BlockCheckMode, Expr, Local, LocalKind, Stmt, StmtKind};
+use rustc_ast::{AttrVec, Block, BlockCheckMode, LetElse, Local, Stmt, StmtKind};
 use rustc_hir as hir;
 use rustc_session::parse::feature_err;
 use rustc_span::{sym, DesugaringKind};
@@ -34,23 +34,18 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         let mut expr = None;
         while let [s, tail @ ..] = ast_stmts {
             match s.kind {
+                StmtKind::LetElse(ref let_else) => {
+                    expr = Some(self.lower_let_else(let_else, tail));
+                    // remaining statements are in let-else expression
+                    break;
+                }
                 StmtKind::Local(ref local) => {
                     let hir_id = self.lower_node_id(s.id);
-                    match &local.kind {
-                        LocalKind::InitElse(init, els) => {
-                            let e = self.lower_let_else(hir_id, local, init, els, tail);
-                            expr = Some(e);
-                            // remaining statements are in let-else expression
-                            break;
-                        }
-                        _ => {
-                            let local = self.lower_local(local);
-                            self.alias_attrs(hir_id, local.hir_id);
-                            let kind = hir::StmtKind::Local(local);
-                            let span = self.lower_span(s.span);
-                            stmts.push(hir::Stmt { hir_id, kind, span });
-                        }
-                    }
+                    let local = self.lower_local(local);
+                    self.alias_attrs(hir_id, local.hir_id);
+                    let kind = hir::StmtKind::Local(local);
+                    let span = self.lower_span(s.span);
+                    stmts.push(hir::Stmt { hir_id, kind, span });
                 }
                 StmtKind::Item(ref it) => {
                     stmts.extend(self.lower_item_ref(it).into_iter().enumerate().map(
@@ -116,54 +111,32 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         }
     }
 
-    fn lower_let_else(
-        &mut self,
-        stmt_hir_id: hir::HirId,
-        local: &Local,
-        init: &Expr,
-        els: &Block,
-        tail: &[Stmt],
-    ) -> &'hir hir::Expr<'hir> {
-        let ty = local
-            .ty
-            .as_ref()
-            .map(|t| self.lower_ty(t, ImplTraitContext::Disallowed(ImplTraitPosition::Binding)));
-        let span = self.lower_span(local.span);
-        let span = self.mark_span_with_reason(DesugaringKind::LetElse, span, None);
-        let init = self.lower_expr(init);
-        let local_hir_id = self.lower_node_id(local.id);
-        self.lower_attrs(local_hir_id, &local.attrs);
-        let let_expr = {
-            let lex = self.arena.alloc(hir::Let {
-                hir_id: local_hir_id,
-                pat: self.lower_pat(&local.pat),
-                ty,
-                init,
-                span,
-            });
-            self.arena.alloc(self.expr(span, hir::ExprKind::Let(lex), AttrVec::new()))
-        };
+    fn lower_let_else(&mut self, let_else: &LetElse, tail: &[Stmt]) -> &'hir hir::Expr<'hir> {
+        let span = self.mark_span_with_reason(DesugaringKind::LetElse, let_else.span, None);
+        let local_hir_id = self.lower_node_id(let_else.id);
+        self.lower_attrs(local_hir_id, &let_else.attrs);
+        let cond = self.lower_expr(&let_else.expr);
         let then_expr = {
             let (stmts, expr) = self.lower_stmts(tail);
             let block = self.block_all(span, stmts, expr);
             self.arena.alloc(self.expr_block(block, AttrVec::new()))
         };
         let else_expr = {
-            let block = self.lower_block(els, false);
+            let block = self.lower_block(&let_else.r#else, false);
             self.arena.alloc(self.expr_block(block, AttrVec::new()))
         };
-        self.alias_attrs(let_expr.hir_id, local_hir_id);
+        self.alias_attrs(cond.hir_id, local_hir_id);
         self.alias_attrs(else_expr.hir_id, local_hir_id);
         let if_expr = self.arena.alloc(hir::Expr {
-            hir_id: stmt_hir_id,
+            hir_id: local_hir_id,
             span,
-            kind: hir::ExprKind::If(let_expr, then_expr, Some(else_expr)),
+            kind: hir::ExprKind::If(cond, then_expr, Some(else_expr)),
         });
         if !self.sess.features_untracked().let_else {
             feature_err(
                 &self.sess.parse_sess,
                 sym::let_else,
-                local.span,
+                let_else.span,
                 "`let...else` statements are unstable",
             )
             .emit();

diff --git a/compiler/rustc_ast_pretty/src/pprust/state.rs b/compiler/rustc_ast_pretty/src/pprust/state.rs
@@ -1073,26 +1073,27 @@ impl<'a> State<'a> {
     crate fn print_stmt(&mut self, st: &ast::Stmt) {
         self.maybe_print_comment(st.span.lo());
         match st.kind {
+            ast::StmtKind::LetElse(ref let_else) => {
+                self.print_outer_attributes(&let_else.attrs);
+                self.space_if_not_bol();
+                self.ibox(INDENT_UNIT);
+                self.word_nbsp("let");
+                self.print_expr(&let_else.expr);
+                self.cbox(INDENT_UNIT);
+                self.ibox(INDENT_UNIT);
+                self.word(" else ");
+                self.print_block(&let_else.r#else);
+                self.word(";");
+                self.end(); // `let` ibox
+            }
             ast::StmtKind::Local(ref loc) => {
                 self.print_outer_attributes(&loc.attrs);
                 self.space_if_not_bol();
                 self.ibox(INDENT_UNIT);
                 self.word_nbsp("let");
-
                 self.ibox(INDENT_UNIT);
                 self.print_local_decl(loc);
                 self.end();
-                if let Some((init, els)) = loc.kind.init_else_opt() {
-                    self.nbsp();
-                    self.word_space("=");
-                    self.print_expr(init);
-                    if let Some(els) = els {
-                        self.cbox(INDENT_UNIT);
-                        self.ibox(INDENT_UNIT);
-                        self.word(" else ");
-                        self.print_block(els);
-                    }
-                }
                 self.word(";");
                 self.end(); // `let` ibox
             }

diff --git a/compiler/rustc_expand/src/expand.rs b/compiler/rustc_expand/src/expand.rs
@@ -1364,7 +1364,7 @@ impl InvocationCollectorNode for ast::Stmt {
             StmtKind::Item(item) => matches!(item.kind, ItemKind::MacCall(..)),
             StmtKind::Semi(expr) => matches!(expr.kind, ExprKind::MacCall(..)),
             StmtKind::Expr(..) => unreachable!(),
-            StmtKind::Local(..) | StmtKind::Empty => false,
+            StmtKind::LetElse(..) | StmtKind::Local(..) | StmtKind::Empty => false,
         }
     }
     fn take_mac_call(self) -> (ast::MacCall, Self::AttrsTy, AddSemicolon) {

diff --git a/compiler/rustc_lint/src/builtin.rs b/compiler/rustc_lint/src/builtin.rs
@@ -1054,7 +1054,7 @@ fn warn_if_doc(cx: &EarlyContext<'_>, node_span: Span, node_kind: &str, attrs: &
 impl EarlyLintPass for UnusedDocComment {
     fn check_stmt(&mut self, cx: &EarlyContext<'_>, stmt: &ast::Stmt) {
         let kind = match stmt.kind {
-            ast::StmtKind::Local(..) => "statements",
+            ast::StmtKind::LetElse(..) | ast::StmtKind::Local(..) => "statements",
             // Disabled pending discussion in #78306
             ast::StmtKind::Item(..) => return,
             // expressions will be reported by `check_expr`.

diff --git a/compiler/rustc_lint/src/unused.rs b/compiler/rustc_lint/src/unused.rs
@@ -623,11 +623,8 @@ trait UnusedDelimLint {
     fn check_stmt(&mut self, cx: &EarlyContext<'_>, s: &ast::Stmt) {
         match s.kind {
             StmtKind::Local(ref local) if Self::LINT_EXPR_IN_PATTERN_MATCHING_CTX => {
-                if let Some((init, els)) = local.kind.init_else_opt() {
-                    let ctx = match els {
-                        None => UnusedDelimsCtx::AssignedValue,
-                        Some(_) => UnusedDelimsCtx::AssignedValueLetElse,
-                    };
+                if let Some(init) = local.kind.init() {
+                    let ctx = UnusedDelimsCtx::AssignedValue;
                     self.check_unused_delims_expr(cx, init, ctx, false, None, None);
                 }
             }