nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-25 16:24:46 +00:00
Code Issues Packages Projects Releases Wiki Activity

Rollup merge of #122487 - GuillaumeGomez:rename-stmtkind-local, r=oli-obk

Browse Source 
Rename `StmtKind::Local` variant into `StmtKind::Let`

It comes from this [discussion](https://rust-lang.zulipchat.com/#narrow/stream/131828-t-compiler/topic/Improve.20naming.20of.20.60ExprKind.3A.3ALet.60.3F).

Starting point was:

> I often end up looking at [ExprKind::Let](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_hir/enum.ExprKind.html#variant.Let) instead of Local because of the name. I think renaming it (both the `ExprKind` variant and the Let struct) to `LetPattern` or LetPat could improve the situation as I'm not sure I'm not the only one encountering this issue.

And then it evolved into:

> It's already `Expr::Let` instead of `StmtKind::Local`. Counterproposal: rename `StmtKind::Local` to `StmtKind::Let`.

The goal here is to clear this confusion.

r? `@oli-obk`
This commit is contained in:
Matthias Krüger 2024-03-14 20:00:21 +01:00 committed by GitHub
commit 1f4aff7d2b
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
74 changed files with 103 additions and 103 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
compiler/rustc_ast/src/ast.rs
View File

@ -1021,7 +1021,7 @@ impl Stmt {
#[derive(Clone, Encodable, Decodable, Debug)] #[derive(Clone, Encodable, Decodable, Debug)]
pub enum StmtKind { pub enum StmtKind {
/// A local (let) binding. /// A local (let) binding.
Local(P<Local>), Let(P<Local>),
/// An item definition. /// An item definition.
Item(P<Item>), Item(P<Item>),
/// Expr without trailing semi-colon. /// Expr without trailing semi-colon.

8
compiler/rustc_ast/src/ast_traits.rs
View File

@ -182,7 +182,7 @@ impl<T: HasTokens> HasTokens for Option<T> {
impl HasTokens for StmtKind { impl HasTokens for StmtKind {
fn tokens(&self) -> Option<&LazyAttrTokenStream> { fn tokens(&self) -> Option<&LazyAttrTokenStream> {
match self { match self {
StmtKind::Local(local) => local.tokens.as_ref(), StmtKind::Let(local) => local.tokens.as_ref(),
StmtKind::Item(item) => item.tokens(), StmtKind::Item(item) => item.tokens(),
StmtKind::Expr(expr) | StmtKind::Semi(expr) => expr.tokens(), StmtKind::Expr(expr) | StmtKind::Semi(expr) => expr.tokens(),
StmtKind::Empty => return None, StmtKind::Empty => return None,
@ -191,7 +191,7 @@ impl HasTokens for StmtKind {
} }
fn tokens_mut(&mut self) -> Option<&mut Option<LazyAttrTokenStream>> { fn tokens_mut(&mut self) -> Option<&mut Option<LazyAttrTokenStream>> {
match self { match self {
StmtKind::Local(local) => Some(&mut local.tokens), StmtKind::Let(local) => Some(&mut local.tokens),
StmtKind::Item(item) => item.tokens_mut(), StmtKind::Item(item) => item.tokens_mut(),
StmtKind::Expr(expr) | StmtKind::Semi(expr) => expr.tokens_mut(), StmtKind::Expr(expr) | StmtKind::Semi(expr) => expr.tokens_mut(),
StmtKind::Empty => return None, StmtKind::Empty => return None,
@ -355,7 +355,7 @@ impl HasAttrs for StmtKind {
fn attrs(&self) -> &[Attribute] { fn attrs(&self) -> &[Attribute] {
match self { match self {
StmtKind::Local(local) => &local.attrs, StmtKind::Let(local) => &local.attrs,
StmtKind::Expr(expr) | StmtKind::Semi(expr) => expr.attrs(), StmtKind::Expr(expr) | StmtKind::Semi(expr) => expr.attrs(),
StmtKind::Item(item) => item.attrs(), StmtKind::Item(item) => item.attrs(),
StmtKind::Empty => &[], StmtKind::Empty => &[],
@ -365,7 +365,7 @@ impl HasAttrs for StmtKind {
fn visit_attrs(&mut self, f: impl FnOnce(&mut AttrVec)) { fn visit_attrs(&mut self, f: impl FnOnce(&mut AttrVec)) {
match self { match self {
StmtKind::Local(local) => f(&mut local.attrs), StmtKind::Let(local) => f(&mut local.attrs),
StmtKind::Expr(expr) | StmtKind::Semi(expr) => expr.visit_attrs(f), StmtKind::Expr(expr) | StmtKind::Semi(expr) => expr.visit_attrs(f),
StmtKind::Item(item) => item.visit_attrs(f), StmtKind::Item(item) => item.visit_attrs(f),
StmtKind::Empty => {} StmtKind::Empty => {}

2
compiler/rustc_ast/src/mut_visit.rs
View File

@ -1567,7 +1567,7 @@ pub fn noop_flat_map_stmt_kind<T: MutVisitor>(
vis: &mut T, vis: &mut T,
) -> SmallVec<[StmtKind; 1]> { ) -> SmallVec<[StmtKind; 1]> {
match kind { match kind {
StmtKind::Local(mut local) => smallvec![StmtKind::Local({ StmtKind::Let(mut local) => smallvec![StmtKind::Let({
vis.visit_local(&mut local); vis.visit_local(&mut local);
local local
})], })],

2
compiler/rustc_ast/src/visit.rs
View File

@ -787,7 +787,7 @@ pub fn walk_block<'a, V: Visitor<'a>>(visitor: &mut V, block: &'a Block) -> V::R
pub fn walk_stmt<'a, V: Visitor<'a>>(visitor: &mut V, statement: &'a Stmt) -> V::Result { pub fn walk_stmt<'a, V: Visitor<'a>>(visitor: &mut V, statement: &'a Stmt) -> V::Result {
match &statement.kind { match &statement.kind {
StmtKind::Local(local) => try_visit!(visitor.visit_local(local)), StmtKind::Let(local) => try_visit!(visitor.visit_local(local)),
StmtKind::Item(item) => try_visit!(visitor.visit_item(item)), StmtKind::Item(item) => try_visit!(visitor.visit_item(item)),
StmtKind::Expr(expr) | StmtKind::Semi(expr) => try_visit!(visitor.visit_expr(expr)), StmtKind::Expr(expr) | StmtKind::Semi(expr) => try_visit!(visitor.visit_expr(expr)),
StmtKind::Empty => {} StmtKind::Empty => {}

4
compiler/rustc_ast_lowering/src/block.rs
View File

@ -32,11 +32,11 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
let mut expr = None; let mut expr = None;
while let [s, tail @ ..] = ast_stmts { while let [s, tail @ ..] = ast_stmts {
match &s.kind { match &s.kind {
StmtKind::Local(local) => { StmtKind::Let(local) => {
let hir_id = self.lower_node_id(s.id); let hir_id = self.lower_node_id(s.id);
let local = self.lower_local(local); let local = self.lower_local(local);
self.alias_attrs(hir_id, local.hir_id); self.alias_attrs(hir_id, local.hir_id);
let kind = hir::StmtKind::Local(local); let kind = hir::StmtKind::Let(local);
let span = self.lower_span(s.span); let span = self.lower_span(s.span);
stmts.push(hir::Stmt { hir_id, kind, span }); stmts.push(hir::Stmt { hir_id, kind, span });
} }

2
compiler/rustc_ast_lowering/src/lib.rs
View File

@ -2356,7 +2356,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
span: self.lower_span(span), span: self.lower_span(span),
ty: None, ty: None,
}; };
self.stmt(span, hir::StmtKind::Local(self.arena.alloc(local))) self.stmt(span, hir::StmtKind::Let(self.arena.alloc(local)))
} }
fn block_expr(&mut self, expr: &'hir hir::Expr<'hir>) -> &'hir hir::Block<'hir> { fn block_expr(&mut self, expr: &'hir hir::Expr<'hir>) -> &'hir hir::Block<'hir> {

2
compiler/rustc_ast_pretty/src/pprust/state.rs
View File

@ -1212,7 +1212,7 @@ impl<'a> State<'a> {
fn print_stmt(&mut self, st: &ast::Stmt) { fn print_stmt(&mut self, st: &ast::Stmt) {
self.maybe_print_comment(st.span.lo()); self.maybe_print_comment(st.span.lo());
match &st.kind { match &st.kind {
ast::StmtKind::Local(loc) => { ast::StmtKind::Let(loc) => {
self.print_outer_attributes(&loc.attrs); self.print_outer_attributes(&loc.attrs);
self.space_if_not_bol(); self.space_if_not_bol();
self.ibox(INDENT_UNIT); self.ibox(INDENT_UNIT);

2
compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
View File

@ -616,7 +616,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
// FIXME: We make sure that this is a normal top-level binding, // FIXME: We make sure that this is a normal top-level binding,
// but we could suggest `todo!()` for all uninitalized bindings in the pattern pattern // but we could suggest `todo!()` for all uninitalized bindings in the pattern pattern
if let hir::StmtKind::Local(hir::Local { span, ty, init: None, pat, .. }) = if let hir::StmtKind::Let(hir::Local { span, ty, init: None, pat, .. }) =
&ex.kind &ex.kind
&& let hir::PatKind::Binding(..) = pat.kind && let hir::PatKind::Binding(..) = pat.kind
&& span.contains(self.decl_span) && span.contains(self.decl_span)

4
compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs
View File

@ -558,7 +558,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
hir::intravisit::walk_stmt(self, stmt); hir::intravisit::walk_stmt(self, stmt);
let expr = match stmt.kind { let expr = match stmt.kind {
hir::StmtKind::Semi(expr) | hir::StmtKind::Expr(expr) => expr, hir::StmtKind::Semi(expr) | hir::StmtKind::Expr(expr) => expr,
hir::StmtKind::Local(hir::Local { init: Some(expr), .. }) => expr, hir::StmtKind::Let(hir::Local { init: Some(expr), .. }) => expr,
_ => { _ => {
return; return;
} }
@ -1305,7 +1305,7 @@ struct BindingFinder {
impl<'tcx> Visitor<'tcx> for BindingFinder { impl<'tcx> Visitor<'tcx> for BindingFinder {
type Result = ControlFlow<hir::HirId>; type Result = ControlFlow<hir::HirId>;
fn visit_stmt(&mut self, s: &'tcx hir::Stmt<'tcx>) -> Self::Result { fn visit_stmt(&mut self, s: &'tcx hir::Stmt<'tcx>) -> Self::Result {
if let hir::StmtKind::Local(local) = s.kind if let hir::StmtKind::Let(local) = s.kind
&& local.pat.span == self.span && local.pat.span == self.span
{ {
ControlFlow::Break(local.hir_id) ControlFlow::Break(local.hir_id)

2
compiler/rustc_expand/src/build.rs
View File

@ -218,7 +218,7 @@ impl<'a> ExtCtxt<'a> {
} }
pub fn stmt_local(&self, local: P<ast::Local>, span: Span) -> ast::Stmt { pub fn stmt_local(&self, local: P<ast::Local>, span: Span) -> ast::Stmt {
ast::Stmt { id: ast::DUMMY_NODE_ID, kind: ast::StmtKind::Local(local), span } ast::Stmt { id: ast::DUMMY_NODE_ID, kind: ast::StmtKind::Let(local), span }
} }
pub fn stmt_item(&self, sp: Span, item: P<ast::Item>) -> ast::Stmt { pub fn stmt_item(&self, sp: Span, item: P<ast::Item>) -> ast::Stmt {

2
compiler/rustc_expand/src/expand.rs
View File

@ -1389,7 +1389,7 @@ impl InvocationCollectorNode for ast::Stmt {
StmtKind::Item(item) => matches!(item.kind, ItemKind::MacCall(..)), StmtKind::Item(item) => matches!(item.kind, ItemKind::MacCall(..)),
StmtKind::Semi(expr) => matches!(expr.kind, ExprKind::MacCall(..)), StmtKind::Semi(expr) => matches!(expr.kind, ExprKind::MacCall(..)),
StmtKind::Expr(..) => unreachable!(), StmtKind::Expr(..) => unreachable!(),
StmtKind::Local(..) | StmtKind::Empty => false, StmtKind::Let(..) | StmtKind::Empty => false,
} }
} }
fn take_mac_call(self) -> (P<ast::MacCall>, Self::AttrsTy, AddSemicolon) { fn take_mac_call(self) -> (P<ast::MacCall>, Self::AttrsTy, AddSemicolon) {

2
compiler/rustc_hir/src/hir.rs
View File

@ -1209,7 +1209,7 @@ pub struct Stmt<'hir> {
#[derive(Debug, Clone, Copy, HashStable_Generic)] #[derive(Debug, Clone, Copy, HashStable_Generic)]
pub enum StmtKind<'hir> { pub enum StmtKind<'hir> {
/// A local (`let`) binding. /// A local (`let`) binding.
Local(&'hir Local<'hir>), Let(&'hir Local<'hir>),
/// An item binding. /// An item binding.
Item(ItemId), Item(ItemId),

2
compiler/rustc_hir/src/intravisit.rs
View File

@ -627,7 +627,7 @@ pub fn walk_block<'v, V: Visitor<'v>>(visitor: &mut V, block: &'v Block<'v>) ->
pub fn walk_stmt<'v, V: Visitor<'v>>(visitor: &mut V, statement: &'v Stmt<'v>) -> V::Result { pub fn walk_stmt<'v, V: Visitor<'v>>(visitor: &mut V, statement: &'v Stmt<'v>) -> V::Result {
try_visit!(visitor.visit_id(statement.hir_id)); try_visit!(visitor.visit_id(statement.hir_id));
match statement.kind { match statement.kind {
StmtKind::Local(ref local) => visitor.visit_local(local), StmtKind::Let(ref local) => visitor.visit_local(local),
StmtKind::Item(item) => visitor.visit_nested_item(item), StmtKind::Item(item) => visitor.visit_nested_item(item),
StmtKind::Expr(ref expression) | StmtKind::Semi(ref expression) => { StmtKind::Expr(ref expression) | StmtKind::Semi(ref expression) => {
visitor.visit_expr(expression) visitor.visit_expr(expression)

2
compiler/rustc_hir_analysis/src/check/errs.rs
View File

@ -27,7 +27,7 @@ pub fn maybe_expr_static_mut(tcx: TyCtxt<'_>, expr: hir::Expr<'_>) {
/// Check for shared or mutable references of `static mut` inside statement /// Check for shared or mutable references of `static mut` inside statement
pub fn maybe_stmt_static_mut(tcx: TyCtxt<'_>, stmt: hir::Stmt<'_>) { pub fn maybe_stmt_static_mut(tcx: TyCtxt<'_>, stmt: hir::Stmt<'_>) {
if let hir::StmtKind::Local(loc) = stmt.kind if let hir::StmtKind::Let(loc) = stmt.kind
&& let hir::PatKind::Binding(ba, _, _, _) = loc.pat.kind && let hir::PatKind::Binding(ba, _, _, _) = loc.pat.kind
&& matches!(ba.0, rustc_ast::ByRef::Yes) && matches!(ba.0, rustc_ast::ByRef::Yes)
&& let Some(init) = loc.init && let Some(init) = loc.init

4
compiler/rustc_hir_analysis/src/check/region.rs
View File

@ -123,7 +123,7 @@ fn resolve_block<'tcx>(visitor: &mut RegionResolutionVisitor<'tcx>, blk: &'tcx h
for (i, statement) in blk.stmts.iter().enumerate() { for (i, statement) in blk.stmts.iter().enumerate() {
match statement.kind { match statement.kind {
hir::StmtKind::Local(hir::Local { els: Some(els), .. }) => { hir::StmtKind::Let(hir::Local { els: Some(els), .. }) => {
// Let-else has a special lexical structure for variables. // Let-else has a special lexical structure for variables.
// First we take a checkpoint of the current scope context here. // First we take a checkpoint of the current scope context here.
let mut prev_cx = visitor.cx; let mut prev_cx = visitor.cx;
@ -146,7 +146,7 @@ fn resolve_block<'tcx>(visitor: &mut RegionResolutionVisitor<'tcx>, blk: &'tcx h
// From now on, we continue normally. // From now on, we continue normally.
visitor.cx = prev_cx; visitor.cx = prev_cx;
} }
hir::StmtKind::Local(..) => { hir::StmtKind::Let(..) => {
// Each declaration introduces a subscope for bindings // Each declaration introduces a subscope for bindings
// introduced by the declaration; this subscope covers a // introduced by the declaration; this subscope covers a
// suffix of the block. Each subscope in a block has the // suffix of the block. Each subscope in a block has the

4
compiler/rustc_hir_pretty/src/lib.rs
View File

@ -864,7 +864,7 @@ impl<'a> State<'a> {
fn print_stmt(&mut self, st: &hir::Stmt<'_>) { fn print_stmt(&mut self, st: &hir::Stmt<'_>) {
self.maybe_print_comment(st.span.lo()); self.maybe_print_comment(st.span.lo());
match st.kind { match st.kind {
hir::StmtKind::Local(loc) => { hir::StmtKind::Let(loc) => {
self.print_local(loc.init, loc.els, |this| this.print_local_decl(loc)); self.print_local(loc.init, loc.els, |this| this.print_local_decl(loc));
} }
hir::StmtKind::Item(item) => self.ann.nested(self, Nested::Item(item)), hir::StmtKind::Item(item) => self.ann.nested(self, Nested::Item(item)),
@ -2307,7 +2307,7 @@ fn expr_requires_semi_to_be_stmt(e: &hir::Expr<'_>) -> bool {
/// seen the semicolon, and thus don't need another. /// seen the semicolon, and thus don't need another.
fn stmt_ends_with_semi(stmt: &hir::StmtKind<'_>) -> bool { fn stmt_ends_with_semi(stmt: &hir::StmtKind<'_>) -> bool {
match *stmt { match *stmt {
hir::StmtKind::Local(_) => true, hir::StmtKind::Let(_) => true,
hir::StmtKind::Item(_) => false, hir::StmtKind::Item(_) => false,
hir::StmtKind::Expr(e) => expr_requires_semi_to_be_stmt(e), hir::StmtKind::Expr(e) => expr_requires_semi_to_be_stmt(e),
hir::StmtKind::Semi(..) => false, hir::StmtKind::Semi(..) => false,

4
compiler/rustc_hir_typeck/src/expr_use_visitor.rs
View File

@ -371,11 +371,11 @@ impl<'a, 'tcx> ExprUseVisitor<'a, 'tcx> {
fn walk_stmt(&mut self, stmt: &hir::Stmt<'_>) { fn walk_stmt(&mut self, stmt: &hir::Stmt<'_>) {
match stmt.kind { match stmt.kind {
hir::StmtKind::Local(hir::Local { pat, init: Some(expr), els, .. }) => { hir::StmtKind::Let(hir::Local { pat, init: Some(expr), els, .. }) => {
self.walk_local(expr, pat, *els, |_| {}) self.walk_local(expr, pat, *els, |_| {})
} }
hir::StmtKind::Local(_) => {} hir::StmtKind::Let(_) => {}
hir::StmtKind::Item(_) => { hir::StmtKind::Item(_) => {
// We don't visit nested items in this visitor, // We don't visit nested items in this visitor,

6
compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
View File

@ -1593,7 +1593,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
// Don't do all the complex logic below for `DeclItem`. // Don't do all the complex logic below for `DeclItem`.
match stmt.kind { match stmt.kind {
hir::StmtKind::Item(..) => return, hir::StmtKind::Item(..) => return,
hir::StmtKind::Local(..) | hir::StmtKind::Expr(..) | hir::StmtKind::Semi(..) => {} hir::StmtKind::Let(..) | hir::StmtKind::Expr(..) | hir::StmtKind::Semi(..) => {}
} }
self.warn_if_unreachable(stmt.hir_id, stmt.span, "statement"); self.warn_if_unreachable(stmt.hir_id, stmt.span, "statement");
@ -1602,7 +1602,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
let old_diverges = self.diverges.replace(Diverges::Maybe); let old_diverges = self.diverges.replace(Diverges::Maybe);
match stmt.kind { match stmt.kind {
hir::StmtKind::Local(l) => { hir::StmtKind::Let(l) => {
self.check_decl_local(l); self.check_decl_local(l);
} }
// Ignore for now. // Ignore for now.
@ -1765,7 +1765,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
[ [
hir::Stmt { hir::Stmt {
kind: kind:
hir::StmtKind::Local(hir::Local { hir::StmtKind::Let(hir::Local {
source: source:
hir::LocalSource::AssignDesugar(_), hir::LocalSource::AssignDesugar(_),
.. ..

2
compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs
View File

@ -1599,7 +1599,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
fn is_local_statement(&self, id: hir::HirId) -> bool { fn is_local_statement(&self, id: hir::HirId) -> bool {
let node = self.tcx.hir_node(id); let node = self.tcx.hir_node(id);
matches!(node, Node::Stmt(Stmt { kind: StmtKind::Local(..), .. })) matches!(node, Node::Stmt(Stmt { kind: StmtKind::Let(..), .. }))
} }
/// Suggest that `&T` was cloned instead of `T` because `T` does not implement `Clone`, /// Suggest that `&T` was cloned instead of `T` because `T` does not implement `Clone`,

2
compiler/rustc_hir_typeck/src/method/suggest.rs
View File

@ -2221,7 +2221,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
impl<'v> Visitor<'v> for LetVisitor { impl<'v> Visitor<'v> for LetVisitor {
type Result = ControlFlow<Option<&'v hir::Expr<'v>>>; type Result = ControlFlow<Option<&'v hir::Expr<'v>>>;
fn visit_stmt(&mut self, ex: &'v hir::Stmt<'v>) -> Self::Result { fn visit_stmt(&mut self, ex: &'v hir::Stmt<'v>) -> Self::Result {
if let hir::StmtKind::Local(&hir::Local { pat, init, .. }) = ex.kind if let hir::StmtKind::Let(&hir::Local { pat, init, .. }) = ex.kind
&& let Binding(_, _, ident, ..) = pat.kind && let Binding(_, _, ident, ..) = pat.kind
&& ident.name == self.ident_name && ident.name == self.ident_name
{ {

2
compiler/rustc_hir_typeck/src/upvar.rs
View File

@ -217,7 +217,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
bug!(); bug!();
}; };
for stmt in block.stmts { for stmt in block.stmts {
let hir::StmtKind::Local(hir::Local { let hir::StmtKind::Let(hir::Local {
init: Some(init), init: Some(init),
source: hir::LocalSource::AsyncFn, source: hir::LocalSource::AsyncFn,
pat, pat,

2
compiler/rustc_infer/src/infer/error_reporting/mod.rs
View File

@ -2139,7 +2139,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
// the same span as the error and the type is specified. // the same span as the error and the type is specified.
if let hir::Stmt { if let hir::Stmt {
kind: kind:
hir::StmtKind::Local(hir::Local { hir::StmtKind::Let(hir::Local {
init: Some(hir::Expr { span: init_span, .. }), init: Some(hir::Expr { span: init_span, .. }),
ty: Some(array_ty), ty: Some(array_ty),
.. ..

4
compiler/rustc_infer/src/infer/error_reporting/suggest.rs
View File

@ -585,7 +585,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
} }
fn visit_stmt(&mut self, ex: &'v hir::Stmt<'v>) -> Self::Result { fn visit_stmt(&mut self, ex: &'v hir::Stmt<'v>) -> Self::Result {
if let hir::StmtKind::Local(hir::Local { if let hir::StmtKind::Let(hir::Local {
span, span,
pat: hir::Pat { .. }, pat: hir::Pat { .. },
ty: None, ty: None,
@ -824,7 +824,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
let hir = self.tcx.hir(); let hir = self.tcx.hir();
for stmt in blk.stmts.iter().rev() { for stmt in blk.stmts.iter().rev() {
let hir::StmtKind::Local(local) = &stmt.kind else { let hir::StmtKind::Let(local) = &stmt.kind else {
continue; continue;
}; };
local.pat.walk(&mut find_compatible_candidates); local.pat.walk(&mut find_compatible_candidates);

2
compiler/rustc_lint/src/builtin.rs
View File

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

4
compiler/rustc_lint/src/unused.rs
View File

@ -914,7 +914,7 @@ trait UnusedDelimLint {
fn check_stmt(&mut self, cx: &EarlyContext<'_>, s: &ast::Stmt) { fn check_stmt(&mut self, cx: &EarlyContext<'_>, s: &ast::Stmt) {
match s.kind { match s.kind {
StmtKind::Local(ref local) if Self::LINT_EXPR_IN_PATTERN_MATCHING_CTX => { StmtKind::Let(ref local) if Self::LINT_EXPR_IN_PATTERN_MATCHING_CTX => {
if let Some((init, els)) = local.kind.init_else_opt() { if let Some((init, els)) = local.kind.init_else_opt() {
let ctx = match els { let ctx = match els {
None => UnusedDelimsCtx::AssignedValue, None => UnusedDelimsCtx::AssignedValue,
@ -1189,7 +1189,7 @@ impl EarlyLintPass for UnusedParens {
} }
fn check_stmt(&mut self, cx: &EarlyContext<'_>, s: &ast::Stmt) { fn check_stmt(&mut self, cx: &EarlyContext<'_>, s: &ast::Stmt) {
if let StmtKind::Local(ref local) = s.kind { if let StmtKind::Let(ref local) = s.kind {
self.check_unused_parens_pat(cx, &local.pat, true, false, (true, false)); self.check_unused_parens_pat(cx, &local.pat, true, false, (true, false));
} }

2
compiler/rustc_middle/src/hir/map/mod.rs
View File

@ -653,7 +653,7 @@ impl<'hir> Map<'hir> {
| Node::ForeignItem(_) | Node::ForeignItem(_)
| Node::TraitItem(_) | Node::TraitItem(_)
| Node::ImplItem(_) | Node::ImplItem(_)
| Node::Stmt(Stmt { kind: StmtKind::Local(_), .. }) => break, | Node::Stmt(Stmt { kind: StmtKind::Let(_), .. }) => break,
Node::Expr(expr @ Expr { kind: ExprKind::If(..) | ExprKind::Match(..), .. }) => { Node::Expr(expr @ Expr { kind: ExprKind::If(..) | ExprKind::Match(..), .. }) => {
return Some(expr); return Some(expr);
} }

2
compiler/rustc_mir_build/src/thir/cx/block.rs
View File

@ -63,7 +63,7 @@ impl<'tcx> Cx<'tcx> {
// ignore for purposes of the MIR // ignore for purposes of the MIR
None None
} }
hir::StmtKind::Local(local) => { hir::StmtKind::Let(local) => {
let remainder_scope = region::Scope { let remainder_scope = region::Scope {
id: block_id, id: block_id,
data: region::ScopeData::Remainder(region::FirstStatementIndex::new( data: region::ScopeData::Remainder(region::FirstStatementIndex::new(

8
compiler/rustc_parse/src/parser/stmt.rs
View File

@ -254,7 +254,7 @@ impl<'a> Parser<'a> {
let local = this.parse_local(attrs)?; let local = this.parse_local(attrs)?;
// FIXME - maybe capture semicolon in recovery? // FIXME - maybe capture semicolon in recovery?
Ok(( Ok((
this.mk_stmt(lo.to(this.prev_token.span), StmtKind::Local(local)), this.mk_stmt(lo.to(this.prev_token.span), StmtKind::Let(local)),
TrailingToken::None, TrailingToken::None,
)) ))
})?; })?;
@ -278,7 +278,7 @@ impl<'a> Parser<'a> {
} else { } else {
TrailingToken::None TrailingToken::None
}; };
Ok((this.mk_stmt(lo.to(this.prev_token.span), StmtKind::Local(local)), trailing)) Ok((this.mk_stmt(lo.to(this.prev_token.span), StmtKind::Let(local)), trailing))
}) })
} }
@ -764,7 +764,7 @@ impl<'a> Parser<'a> {
} }
} }
StmtKind::Expr(_) | StmtKind::MacCall(_) => {} StmtKind::Expr(_) | StmtKind::MacCall(_) => {}
StmtKind::Local(local) if let Err(mut e) = self.expect_semi() => { StmtKind::Let(local) if let Err(mut e) = self.expect_semi() => {
// We might be at the `,` in `let x = foo<bar, baz>;`. Try to recover. // We might be at the `,` in `let x = foo<bar, baz>;`. Try to recover.
match &mut local.kind { match &mut local.kind {
LocalKind::Init(expr) | LocalKind::InitElse(expr, _) => { LocalKind::Init(expr) | LocalKind::InitElse(expr, _) => {
@ -820,7 +820,7 @@ impl<'a> Parser<'a> {
} }
eat_semi = false; eat_semi = false;
} }
StmtKind::Empty | StmtKind::Item(_) | StmtKind::Local(_) | StmtKind::Semi(_) => { StmtKind::Empty | StmtKind::Item(_) | StmtKind::Let(_) | StmtKind::Semi(_) => {
eat_semi = false eat_semi = false
} }
} }

2
compiler/rustc_passes/src/check_attr.rs
View File

@ -2444,7 +2444,7 @@ impl<'tcx> Visitor<'tcx> for CheckAttrVisitor<'tcx> {
fn visit_stmt(&mut self, stmt: &'tcx hir::Stmt<'tcx>) { fn visit_stmt(&mut self, stmt: &'tcx hir::Stmt<'tcx>) {
// When checking statements ignore expressions, they will be checked later. // When checking statements ignore expressions, they will be checked later.
if let hir::StmtKind::Local(l) = stmt.kind { if let hir::StmtKind::Let(l) = stmt.kind {
self.check_attributes(l.hir_id, stmt.span, Target::Statement, None); self.check_attributes(l.hir_id, stmt.span, Target::Statement, None);
} }
intravisit::walk_stmt(self, stmt) intravisit::walk_stmt(self, stmt)

4
compiler/rustc_passes/src/hir_stats.rs
View File

@ -277,7 +277,7 @@ impl<'v> hir_visit::Visitor<'v> for StatCollector<'v> {
fn visit_stmt(&mut self, s: &'v hir::Stmt<'v>) { fn visit_stmt(&mut self, s: &'v hir::Stmt<'v>) {
record_variants!( record_variants!(
(self, s, s.kind, Id::Node(s.hir_id), hir, Stmt, StmtKind), (self, s, s.kind, Id::Node(s.hir_id), hir, Stmt, StmtKind),
[Local, Item, Expr, Semi] [Let, Item, Expr, Semi]
); );
hir_visit::walk_stmt(self, s) hir_visit::walk_stmt(self, s)
} }
@ -539,7 +539,7 @@ impl<'v> ast_visit::Visitor<'v> for StatCollector<'v> {
fn visit_stmt(&mut self, s: &'v ast::Stmt) { fn visit_stmt(&mut self, s: &'v ast::Stmt) {
record_variants!( record_variants!(
(self, s, s.kind, Id::None, ast, Stmt, StmtKind), (self, s, s.kind, Id::None, ast, Stmt, StmtKind),
[Local, Item, Expr, Semi, Empty, MacCall] [Let, Item, Expr, Semi, Empty, MacCall]
); );
ast_visit::walk_stmt(self, s) ast_visit::walk_stmt(self, s)
} }

2
compiler/rustc_passes/src/liveness.rs
View File

@ -771,7 +771,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
fn propagate_through_stmt(&mut self, stmt: &hir::Stmt<'_>, succ: LiveNode) -> LiveNode { fn propagate_through_stmt(&mut self, stmt: &hir::Stmt<'_>, succ: LiveNode) -> LiveNode {
match stmt.kind { match stmt.kind {
hir::StmtKind::Local(local) => { hir::StmtKind::Let(local) => {
// Note: we mark the variable as defined regardless of whether // Note: we mark the variable as defined regardless of whether
// there is an initializer. Initially I had thought to only mark // there is an initializer. Initially I had thought to only mark
// the live variable as defined if it was initialized, and then we // the live variable as defined if it was initialized, and then we

2
compiler/rustc_passes/src/naked_functions.rs
View File

@ -280,7 +280,7 @@ impl<'tcx> Visitor<'tcx> for CheckInlineAssembly<'tcx> {
fn visit_stmt(&mut self, stmt: &'tcx hir::Stmt<'tcx>) { fn visit_stmt(&mut self, stmt: &'tcx hir::Stmt<'tcx>) {
match stmt.kind { match stmt.kind {
StmtKind::Item(..) => {} StmtKind::Item(..) => {}
StmtKind::Local(..) => { StmtKind::Let(..) => {
self.items.push((ItemKind::NonAsm, stmt.span)); self.items.push((ItemKind::NonAsm, stmt.span));
} }
StmtKind::Expr(expr) | StmtKind::Semi(expr) => { StmtKind::Expr(expr) | StmtKind::Semi(expr) => {

2
compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs
View File

@ -763,7 +763,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
let hir_id = self.tcx.local_def_id_to_hir_id(def_id.as_local()?); let hir_id = self.tcx.local_def_id_to_hir_id(def_id.as_local()?);
match self.tcx.parent_hir_node(hir_id) { match self.tcx.parent_hir_node(hir_id) {
hir::Node::Stmt(hir::Stmt { kind: hir::StmtKind::Local(local), .. }) => { hir::Node::Stmt(hir::Stmt { kind: hir::StmtKind::Let(local), .. }) => {
get_name(err, &local.pat.kind) get_name(err, &local.pat.kind)
} }
// Different to previous arm because one is `&hir::Local` and the other // Different to previous arm because one is `&hir::Local` and the other

2
src/tools/clippy/clippy_lints/src/attrs/utils.rs
View File

@ -52,7 +52,7 @@ fn is_relevant_block(cx: &LateContext<'_>, typeck_results: &ty::TypeckResults<'_
.as_ref() .as_ref()
.map_or(false, |e| is_relevant_expr(cx, typeck_results, e)), .map_or(false, |e| is_relevant_expr(cx, typeck_results, e)),
|stmt| match &stmt.kind { |stmt| match &stmt.kind {
StmtKind::Local(_) => true, StmtKind::Let(_) => true,
StmtKind::Expr(expr) | StmtKind::Semi(expr) => is_relevant_expr(cx, typeck_results, expr), StmtKind::Expr(expr) | StmtKind::Semi(expr) => is_relevant_expr(cx, typeck_results, expr),
StmtKind::Item(_) => false, StmtKind::Item(_) => false,
}, },

8
src/tools/clippy/clippy_lints/src/copies.rs
View File

@ -349,7 +349,7 @@ impl BlockEq {
/// If the statement is a local, checks if the bound names match the expected list of names. /// If the statement is a local, checks if the bound names match the expected list of names.
fn eq_binding_names(s: &Stmt<'_>, names: &[(HirId, Symbol)]) -> bool { fn eq_binding_names(s: &Stmt<'_>, names: &[(HirId, Symbol)]) -> bool {
if let StmtKind::Local(l) = s.kind { if let StmtKind::Let(l) = s.kind {
let mut i = 0usize; let mut i = 0usize;
let mut res = true; let mut res = true;
l.pat.each_binding_or_first(&mut |_, _, _, name| { l.pat.each_binding_or_first(&mut |_, _, _, name| {
@ -389,7 +389,7 @@ fn eq_stmts(
eq: &mut HirEqInterExpr<'_, '_, '_>, eq: &mut HirEqInterExpr<'_, '_, '_>,
moved_bindings: &mut Vec<(HirId, Symbol)>, moved_bindings: &mut Vec<(HirId, Symbol)>,
) -> bool { ) -> bool {
(if let StmtKind::Local(l) = stmt.kind { (if let StmtKind::Let(l) = stmt.kind {
let old_count = moved_bindings.len(); let old_count = moved_bindings.len();
l.pat.each_binding_or_first(&mut |_, id, _, name| { l.pat.each_binding_or_first(&mut |_, id, _, name| {
moved_bindings.push((id, name.name)); moved_bindings.push((id, name.name));
@ -432,7 +432,7 @@ fn scan_block_for_eq<'tcx>(
.iter() .iter()
.enumerate() .enumerate()
.find(|&(i, stmt)| { .find(|&(i, stmt)| {
if let StmtKind::Local(l) = stmt.kind if let StmtKind::Let(l) = stmt.kind
&& needs_ordered_drop(cx, cx.typeck_results().node_type(l.hir_id)) && needs_ordered_drop(cx, cx.typeck_results().node_type(l.hir_id))
{ {
local_needs_ordered_drop = true; local_needs_ordered_drop = true;
@ -509,7 +509,7 @@ fn scan_block_for_eq<'tcx>(
// Clear out all locals seen at the end so far. None of them can be moved. // Clear out all locals seen at the end so far. None of them can be moved.
let stmts = &blocks[0].stmts; let stmts = &blocks[0].stmts;
for stmt in &stmts[stmts.len() - init..=stmts.len() - offset] { for stmt in &stmts[stmts.len() - init..=stmts.len() - offset] {
if let StmtKind::Local(l) = stmt.kind { if let StmtKind::Let(l) = stmt.kind {
l.pat.each_binding_or_first(&mut |_, id, _, _| { l.pat.each_binding_or_first(&mut |_, id, _, _| {
// FIXME(rust/#120456) - is `swap_remove` correct? // FIXME(rust/#120456) - is `swap_remove` correct?
eq.locals.swap_remove(&id); eq.locals.swap_remove(&id);

2
src/tools/clippy/clippy_lints/src/default.rs
View File

@ -121,7 +121,7 @@ impl<'tcx> LateLintPass<'tcx> for Default {
// find all binding statements like `let mut _ = T::default()` where `T::default()` is the // find all binding statements like `let mut _ = T::default()` where `T::default()` is the
// `default` method of the `Default` trait, and store statement index in current block being // `default` method of the `Default` trait, and store statement index in current block being
// checked and the name of the bound variable // checked and the name of the bound variable
let (local, variant, binding_name, binding_type, span) = if let StmtKind::Local(local) = stmt.kind let (local, variant, binding_name, binding_type, span) = if let StmtKind::Let(local) = stmt.kind
// only take `let ...` statements // only take `let ...` statements
&& let Some(expr) = local.init && let Some(expr) = local.init
&& !any_parent_is_automatically_derived(cx.tcx, expr.hir_id) && !any_parent_is_automatically_derived(cx.tcx, expr.hir_id)

2
src/tools/clippy/clippy_lints/src/default_numeric_fallback.rs
View File

@ -221,7 +221,7 @@ impl<'a, 'tcx> Visitor<'tcx> for NumericFallbackVisitor<'a, 'tcx> {
fn visit_stmt(&mut self, stmt: &'tcx Stmt<'_>) { fn visit_stmt(&mut self, stmt: &'tcx Stmt<'_>) {
match stmt.kind { match stmt.kind {
// we cannot check the exact type since it's a hir::Ty which does not implement `is_numeric` // we cannot check the exact type since it's a hir::Ty which does not implement `is_numeric`
StmtKind::Local(local) => self.ty_bounds.push(ExplicitTyBound(local.ty.is_some())), StmtKind::Let(local) => self.ty_bounds.push(ExplicitTyBound(local.ty.is_some())),
_ => self.ty_bounds.push(ExplicitTyBound(false)), _ => self.ty_bounds.push(ExplicitTyBound(false)),
} }

2
src/tools/clippy/clippy_lints/src/entry.rs
View File

@ -423,7 +423,7 @@ impl<'tcx> Visitor<'tcx> for InsertSearcher<'_, 'tcx> {
} }
}, },
StmtKind::Expr(e) => self.visit_expr(e), StmtKind::Expr(e) => self.visit_expr(e),
StmtKind::Local(l) => { StmtKind::Let(l) => {
self.visit_pat(l.pat); self.visit_pat(l.pat);
if let Some(e) = l.init { if let Some(e) = l.init {
self.allow_insert_closure &= !self.in_tail_pos; self.allow_insert_closure &= !self.in_tail_pos;

2
src/tools/clippy/clippy_lints/src/explicit_write.rs
View File

@ -102,7 +102,7 @@ impl<'tcx> LateLintPass<'tcx> for ExplicitWrite {
fn look_in_block<'tcx, 'hir>(cx: &LateContext<'tcx>, kind: &'tcx ExprKind<'hir>) -> &'tcx ExprKind<'hir> { fn look_in_block<'tcx, 'hir>(cx: &LateContext<'tcx>, kind: &'tcx ExprKind<'hir>) -> &'tcx ExprKind<'hir> {
if let ExprKind::Block(block, _label @ None) = kind if let ExprKind::Block(block, _label @ None) = kind
&& let Block { && let Block {
stmts: [Stmt { kind: StmtKind::Local(local), .. }], stmts: [Stmt { kind: StmtKind::Let(local), .. }],
expr: Some(expr_end_of_block), expr: Some(expr_end_of_block),
rules: BlockCheckMode::DefaultBlock, rules: BlockCheckMode::DefaultBlock,
.. ..

2
src/tools/clippy/clippy_lints/src/let_if_seq.rs
View File

@ -61,7 +61,7 @@ impl<'tcx> LateLintPass<'tcx> for LetIfSeq {
let mut it = block.stmts.iter().peekable(); let mut it = block.stmts.iter().peekable();
while let Some(stmt) = it.next() { while let Some(stmt) = it.next() {
if let Some(expr) = it.peek() if let Some(expr) = it.peek()
&& let hir::StmtKind::Local(local) = stmt.kind && let hir::StmtKind::Let(local) = stmt.kind
&& let hir::PatKind::Binding(mode, canonical_id, ident, None) = local.pat.kind && let hir::PatKind::Binding(mode, canonical_id, ident, None) = local.pat.kind
&& let hir::StmtKind::Expr(if_) = expr.kind && let hir::StmtKind::Expr(if_) = expr.kind
&& let hir::ExprKind::If( && let hir::ExprKind::If(

2
src/tools/clippy/clippy_lints/src/loops/manual_memcpy.rs
View File

@ -410,7 +410,7 @@ fn get_assignments<'a, 'tcx>(
stmts stmts
.iter() .iter()
.filter_map(move |stmt| match stmt.kind { .filter_map(move |stmt| match stmt.kind {
StmtKind::Local(..) | StmtKind::Item(..) => None, StmtKind::Let(..) | StmtKind::Item(..) => None,
StmtKind::Expr(e) | StmtKind::Semi(e) => Some(e), StmtKind::Expr(e) | StmtKind::Semi(e) => Some(e),
}) })
.chain(*expr) .chain(*expr)

2
src/tools/clippy/clippy_lints/src/loops/manual_while_let_some.rs
View File

@ -72,7 +72,7 @@ fn is_vec_pop_unwrap(cx: &LateContext<'_>, expr: &Expr<'_>, is_empty_recv: &Expr
} }
fn check_local(cx: &LateContext<'_>, stmt: &Stmt<'_>, is_empty_recv: &Expr<'_>, loop_span: Span) { fn check_local(cx: &LateContext<'_>, stmt: &Stmt<'_>, is_empty_recv: &Expr<'_>, loop_span: Span) {
if let StmtKind::Local(local) = stmt.kind if let StmtKind::Let(local) = stmt.kind
&& let Some(init) = local.init && let Some(init) = local.init
&& is_vec_pop_unwrap(cx, init, is_empty_recv) && is_vec_pop_unwrap(cx, init, is_empty_recv)
{ {

2
src/tools/clippy/clippy_lints/src/loops/never_loop.rs
View File

@ -137,7 +137,7 @@ fn stmt_to_expr<'tcx>(stmt: &Stmt<'tcx>) -> Option<(&'tcx Expr<'tcx>, Option<&'t
match stmt.kind { match stmt.kind {
StmtKind::Semi(e) | StmtKind::Expr(e) => Some((e, None)), StmtKind::Semi(e) | StmtKind::Expr(e) => Some((e, None)),
// add the let...else expression (if present) // add the let...else expression (if present)
StmtKind::Local(local) => local.init.map(|init| (init, local.els)), StmtKind::Let(local) => local.init.map(|init| (init, local.els)),
StmtKind::Item(..) => None, StmtKind::Item(..) => None,
} }
} }

2
src/tools/clippy/clippy_lints/src/loops/while_let_loop.rs
View File

@ -11,7 +11,7 @@ use rustc_lint::LateContext;
pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, loop_block: &'tcx Block<'_>) { pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, loop_block: &'tcx Block<'_>) {
let (init, has_trailing_exprs) = match (loop_block.stmts, loop_block.expr) { let (init, has_trailing_exprs) = match (loop_block.stmts, loop_block.expr) {
([stmt, stmts @ ..], expr) => { ([stmt, stmts @ ..], expr) => {
if let StmtKind::Local(&Local { if let StmtKind::Let(&Local {
init: Some(e), init: Some(e),
els: None, els: None,
.. ..

2
src/tools/clippy/clippy_lints/src/manual_let_else.rs
View File

@ -53,7 +53,7 @@ impl<'tcx> QuestionMark {
return; return;
} }
if let StmtKind::Local(local) = stmt.kind if let StmtKind::Let(local) = stmt.kind
&& let Some(init) = local.init && let Some(init) = local.init
&& local.els.is_none() && local.els.is_none()
&& local.ty.is_none() && local.ty.is_none()

2
src/tools/clippy/clippy_lints/src/map_unit_fn.rs
View File

@ -138,7 +138,7 @@ fn reduce_unit_expression(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> Option<
// If block only contains statements, // If block only contains statements,
// reduce `{ X; }` to `X` or `X;` // reduce `{ X; }` to `X` or `X;`
match inner_stmt.kind { match inner_stmt.kind {
hir::StmtKind::Local(local) => Some(local.span), hir::StmtKind::Let(local) => Some(local.span),
hir::StmtKind::Expr(e) => Some(e.span), hir::StmtKind::Expr(e) => Some(e.span),
hir::StmtKind::Semi(..) => Some(inner_stmt.span), hir::StmtKind::Semi(..) => Some(inner_stmt.span),
hir::StmtKind::Item(..) => None, hir::StmtKind::Item(..) => None,

2
src/tools/clippy/clippy_lints/src/methods/needless_collect.rs
View File

@ -424,7 +424,7 @@ fn get_expr_and_hir_id_from_stmt<'v>(stmt: &'v Stmt<'v>) -> Option<(&'v Expr<'v>
match stmt.kind { match stmt.kind {
StmtKind::Expr(expr) | StmtKind::Semi(expr) => Some((expr, None)), StmtKind::Expr(expr) | StmtKind::Semi(expr) => Some((expr, None)),
StmtKind::Item(..) => None, StmtKind::Item(..) => None,
StmtKind::Local(Local { init, pat, .. }) => { StmtKind::Let(Local { init, pat, .. }) => {
if let PatKind::Binding(_, hir_id, ..) = pat.kind { if let PatKind::Binding(_, hir_id, ..) = pat.kind {
init.map(|init_expr| (init_expr, Some(hir_id))) init.map(|init_expr| (init_expr, Some(hir_id)))
} else { } else {

2
src/tools/clippy/clippy_lints/src/methods/str_splitn.rs
View File

@ -198,7 +198,7 @@ fn indirect_usage<'tcx>(
binding: HirId, binding: HirId,
ctxt: SyntaxContext, ctxt: SyntaxContext,
) -> Option<IndirectUsage<'tcx>> { ) -> Option<IndirectUsage<'tcx>> {
if let StmtKind::Local(&Local { if let StmtKind::Let(&Local {
pat: Pat { pat: Pat {
kind: PatKind::Binding(BindingAnnotation::NONE, _, ident, None), kind: PatKind::Binding(BindingAnnotation::NONE, _, ident, None),
.. ..

2
src/tools/clippy/clippy_lints/src/methods/unnecessary_result_map_or_else.rs
View File

@ -27,7 +27,7 @@ fn emit_lint(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, def_arg: &E
fn get_last_chain_binding_hir_id(mut hir_id: HirId, statements: &[Stmt<'_>]) -> Option<HirId> { fn get_last_chain_binding_hir_id(mut hir_id: HirId, statements: &[Stmt<'_>]) -> Option<HirId> {
for stmt in statements { for stmt in statements {
if let StmtKind::Local(local) = stmt.kind if let StmtKind::Let(local) = stmt.kind
&& let Some(init) = local.init && let Some(init) = local.init
&& let ExprKind::Path(QPath::Resolved(_, path)) = init.kind && let ExprKind::Path(QPath::Resolved(_, path)) = init.kind
&& let hir::def::Res::Local(local_hir_id) = path.res && let hir::def::Res::Local(local_hir_id) = path.res

2
src/tools/clippy/clippy_lints/src/misc.rs
View File

@ -143,7 +143,7 @@ impl<'tcx> LateLintPass<'tcx> for LintPass {
fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) { fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
if !in_external_macro(cx.tcx.sess, stmt.span) if !in_external_macro(cx.tcx.sess, stmt.span)
&& let StmtKind::Local(local) = stmt.kind && let StmtKind::Let(local) = stmt.kind
&& let PatKind::Binding(BindingAnnotation(ByRef::Yes, mutabl), .., name, None) = local.pat.kind && let PatKind::Binding(BindingAnnotation(ByRef::Yes, mutabl), .., name, None) = local.pat.kind
&& let Some(init) = local.init && let Some(init) = local.init
// Do not emit if clippy::ref_patterns is not allowed to avoid having two lints for the same issue. // Do not emit if clippy::ref_patterns is not allowed to avoid having two lints for the same issue.

4
src/tools/clippy/clippy_lints/src/mixed_read_write_in_expression.rs
View File

@ -97,7 +97,7 @@ impl<'tcx> LateLintPass<'tcx> for EvalOrderDependence {
} }
fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) { fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
match stmt.kind { match stmt.kind {
StmtKind::Local(local) => { StmtKind::Let(local) => {
if let Local { init: Some(e), .. } = local { if let Local { init: Some(e), .. } = local {
DivergenceVisitor { cx }.visit_expr(e); DivergenceVisitor { cx }.visit_expr(e);
} }
@ -291,7 +291,7 @@ fn check_stmt<'tcx>(vis: &mut ReadVisitor<'_, 'tcx>, stmt: &'tcx Stmt<'_>) -> St
StmtKind::Expr(expr) | StmtKind::Semi(expr) => check_expr(vis, expr), StmtKind::Expr(expr) | StmtKind::Semi(expr) => check_expr(vis, expr),
// If the declaration is of a local variable, check its initializer // If the declaration is of a local variable, check its initializer
// expression if it has one. Otherwise, keep going. // expression if it has one. Otherwise, keep going.
StmtKind::Local(local) => local StmtKind::Let(local) => local
.init .init
.as_ref() .as_ref()
.map_or(StopEarly::KeepGoing, |expr| check_expr(vis, expr)), .map_or(StopEarly::KeepGoing, |expr| check_expr(vis, expr)),

2
src/tools/clippy/clippy_lints/src/needless_late_init.rs
View File

@ -86,7 +86,7 @@ fn contains_let(cond: &Expr<'_>) -> bool {
} }
fn stmt_needs_ordered_drop(cx: &LateContext<'_>, stmt: &Stmt<'_>) -> bool { fn stmt_needs_ordered_drop(cx: &LateContext<'_>, stmt: &Stmt<'_>) -> bool {
let StmtKind::Local(local) = stmt.kind else { let StmtKind::Let(local) = stmt.kind else {
return false; return false;
}; };
!local.pat.walk_short(|pat| { !local.pat.walk_short(|pat| {

2
src/tools/clippy/clippy_lints/src/no_effect.rs
View File

@ -174,7 +174,7 @@ impl NoEffect {
); );
return true; return true;
} }
} else if let StmtKind::Local(local) = stmt.kind { } else if let StmtKind::Let(local) = stmt.kind {
if !is_lint_allowed(cx, NO_EFFECT_UNDERSCORE_BINDING, local.hir_id) if !is_lint_allowed(cx, NO_EFFECT_UNDERSCORE_BINDING, local.hir_id)
&& !matches!(local.source, LocalSource::AsyncFn) && !matches!(local.source, LocalSource::AsyncFn)
&& let Some(init) = local.init && let Some(init) = local.init

2
src/tools/clippy/clippy_lints/src/pattern_type_mismatch.rs
View File

@ -82,7 +82,7 @@ declare_lint_pass!(PatternTypeMismatch => [PATTERN_TYPE_MISMATCH]);
impl<'tcx> LateLintPass<'tcx> for PatternTypeMismatch { impl<'tcx> LateLintPass<'tcx> for PatternTypeMismatch {
fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) { fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
if let StmtKind::Local(local) = stmt.kind { if let StmtKind::Let(local) = stmt.kind {
if in_external_macro(cx.sess(), local.pat.span) { if in_external_macro(cx.sess(), local.pat.span) {
return; return;
} }

2
src/tools/clippy/clippy_lints/src/question_mark.rs
View File

@ -109,7 +109,7 @@ fn find_let_else_ret_expression<'hir>(block: &'hir Block<'hir>) -> Option<&'hir
} }
fn check_let_some_else_return_none(cx: &LateContext<'_>, stmt: &Stmt<'_>) { fn check_let_some_else_return_none(cx: &LateContext<'_>, stmt: &Stmt<'_>) {
if let StmtKind::Local(Local { if let StmtKind::Let(Local {
pat, pat,
init: Some(init_expr), init: Some(init_expr),
els: Some(els), els: Some(els),

2
src/tools/clippy/clippy_lints/src/read_zero_byte_vec.rs
View File

@ -56,7 +56,7 @@ impl<'tcx> LateLintPass<'tcx> for ReadZeroByteVec {
return; return;
} }
if let StmtKind::Local(local) = stmt.kind if let StmtKind::Let(local) = stmt.kind
&& let Local { && let Local {
pat, init: Some(init), .. pat, init: Some(init), ..
} = local } = local

2
src/tools/clippy/clippy_lints/src/redundant_closure_call.rs
View File

@ -262,7 +262,7 @@ impl<'tcx> LateLintPass<'tcx> for RedundantClosureCall {
} }
for w in block.stmts.windows(2) { for w in block.stmts.windows(2) {
if let hir::StmtKind::Local(local) = w[0].kind if let hir::StmtKind::Let(local) = w[0].kind
&& let Option::Some(t) = local.init && let Option::Some(t) = local.init
&& let hir::ExprKind::Closure { .. } = t.kind && let hir::ExprKind::Closure { .. } = t.kind
&& let hir::PatKind::Binding(_, _, ident, _) = local.pat.kind && let hir::PatKind::Binding(_, _, ident, _) = local.pat.kind

2
src/tools/clippy/clippy_lints/src/returns.rs
View File

@ -222,7 +222,7 @@ impl<'tcx> LateLintPass<'tcx> for Return {
// we need both a let-binding stmt and an expr // we need both a let-binding stmt and an expr
if let Some(retexpr) = block.expr if let Some(retexpr) = block.expr
&& let Some(stmt) = block.stmts.iter().last() && let Some(stmt) = block.stmts.iter().last()
&& let StmtKind::Local(local) = &stmt.kind && let StmtKind::Let(local) = &stmt.kind
&& local.ty.is_none() && local.ty.is_none()
&& cx.tcx.hir().attrs(local.hir_id).is_empty() && cx.tcx.hir().attrs(local.hir_id).is_empty()
&& let Some(initexpr) = &local.init && let Some(initexpr) = &local.init

6
src/tools/clippy/clippy_lints/src/significant_drop_tightening.rs
View File

@ -236,7 +236,7 @@ impl<'ap, 'lc, 'others, 'stmt, 'tcx> StmtsChecker<'ap, 'lc, 'others, 'stmt, 'tcx
fn manage_has_expensive_expr_after_last_attr(&mut self) { fn manage_has_expensive_expr_after_last_attr(&mut self) {
let has_expensive_stmt = match self.ap.curr_stmt.kind { let has_expensive_stmt = match self.ap.curr_stmt.kind {
hir::StmtKind::Expr(expr) if is_inexpensive_expr(expr) => false, hir::StmtKind::Expr(expr) if is_inexpensive_expr(expr) => false,
hir::StmtKind::Local(local) hir::StmtKind::Let(local)
if let Some(expr) = local.init if let Some(expr) = local.init
&& let hir::ExprKind::Path(_) = expr.kind => && let hir::ExprKind::Path(_) = expr.kind =>
{ {
@ -290,7 +290,7 @@ impl<'ap, 'lc, 'others, 'stmt, 'tcx> Visitor<'tcx> for StmtsChecker<'ap, 'lc, 'o
}; };
let mut ac = AttrChecker::new(self.cx, self.seen_types, self.type_cache); let mut ac = AttrChecker::new(self.cx, self.seen_types, self.type_cache);
if ac.has_sig_drop_attr(self.cx.typeck_results().expr_ty(expr)) { if ac.has_sig_drop_attr(self.cx.typeck_results().expr_ty(expr)) {
if let hir::StmtKind::Local(local) = self.ap.curr_stmt.kind if let hir::StmtKind::Let(local) = self.ap.curr_stmt.kind
&& let hir::PatKind::Binding(_, hir_id, ident, _) = local.pat.kind && let hir::PatKind::Binding(_, hir_id, ident, _) = local.pat.kind
&& !self.ap.apas.contains_key(&hir_id) && !self.ap.apas.contains_key(&hir_id)
&& { && {
@ -326,7 +326,7 @@ impl<'ap, 'lc, 'others, 'stmt, 'tcx> Visitor<'tcx> for StmtsChecker<'ap, 'lc, 'o
return; return;
}; };
match self.ap.curr_stmt.kind { match self.ap.curr_stmt.kind {
hir::StmtKind::Local(local) => { hir::StmtKind::Let(local) => {
if let hir::PatKind::Binding(_, _, ident, _) = local.pat.kind { if let hir::PatKind::Binding(_, _, ident, _) = local.pat.kind {
apa.last_bind_ident = ident; apa.last_bind_ident = ident;
} }

2
src/tools/clippy/clippy_lints/src/slow_vector_initialization.rs
View File

@ -119,7 +119,7 @@ impl<'tcx> LateLintPass<'tcx> for SlowVectorInit {
fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) { fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
// Matches statements which initializes vectors. For example: `let mut vec = Vec::with_capacity(10)` // Matches statements which initializes vectors. For example: `let mut vec = Vec::with_capacity(10)`
// or `Vec::new()` // or `Vec::new()`
if let StmtKind::Local(local) = stmt.kind if let StmtKind::Let(local) = stmt.kind
&& let PatKind::Binding(BindingAnnotation::MUT, local_id, _, None) = local.pat.kind && let PatKind::Binding(BindingAnnotation::MUT, local_id, _, None) = local.pat.kind
&& let Some(init) = local.init && let Some(init) = local.init
&& let Some(size_expr) = Self::as_vec_initializer(cx, init) && let Some(size_expr) = Self::as_vec_initializer(cx, init)

4
src/tools/clippy/clippy_lints/src/swap.rs
View File

@ -148,7 +148,7 @@ fn check_manual_swap(cx: &LateContext<'_>, block: &Block<'_>) {
} }
for [s1, s2, s3] in block.stmts.array_windows::<3>() { for [s1, s2, s3] in block.stmts.array_windows::<3>() {
if let StmtKind::Local(tmp) = s1.kind if let StmtKind::Let(tmp) = s1.kind
// let t = foo(); // let t = foo();
&& let Some(tmp_init) = tmp.init && let Some(tmp_init) = tmp.init
&& let PatKind::Binding(.., ident, None) = tmp.pat.kind && let PatKind::Binding(.., ident, None) = tmp.pat.kind
@ -243,7 +243,7 @@ fn parse<'a, 'hir>(stmt: &'a Stmt<'hir>) -> Option<(ExprOrIdent<'hir>, &'a Expr<
if let ExprKind::Assign(lhs, rhs, _) = expr.kind { if let ExprKind::Assign(lhs, rhs, _) = expr.kind {
return Some((ExprOrIdent::Expr(lhs), rhs)); return Some((ExprOrIdent::Expr(lhs), rhs));
} }
} else if let StmtKind::Local(expr) = stmt.kind { } else if let StmtKind::Let(expr) = stmt.kind {
if let Some(rhs) = expr.init { if let Some(rhs) = expr.init {
if let PatKind::Binding(_, _, ident_l, _) = expr.pat.kind { if let PatKind::Binding(_, _, ident_l, _) = expr.pat.kind {
return Some((ExprOrIdent::Ident(ident_l), rhs)); return Some((ExprOrIdent::Ident(ident_l), rhs));

4
src/tools/clippy/clippy_lints/src/undocumented_unsafe_blocks.rs
View File

@ -158,7 +158,7 @@ impl<'tcx> LateLintPass<'tcx> for UndocumentedUnsafeBlocks {
} }
fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &hir::Stmt<'tcx>) { fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &hir::Stmt<'tcx>) {
let (hir::StmtKind::Local(&hir::Local { init: Some(expr), .. }) let (hir::StmtKind::Let(&hir::Local { init: Some(expr), .. })
| hir::StmtKind::Expr(expr) | hir::StmtKind::Expr(expr)
| hir::StmtKind::Semi(expr)) = stmt.kind | hir::StmtKind::Semi(expr)) = stmt.kind
else { else {
@ -358,7 +358,7 @@ fn block_parents_have_safety_comment(
}, },
Node::Stmt(hir::Stmt { Node::Stmt(hir::Stmt {
kind: kind:
hir::StmtKind::Local(hir::Local { span, hir_id, .. }) hir::StmtKind::Let(hir::Local { span, hir_id, .. })
| hir::StmtKind::Expr(hir::Expr { span, hir_id, .. }) | hir::StmtKind::Expr(hir::Expr { span, hir_id, .. })
| hir::StmtKind::Semi(hir::Expr { span, hir_id, .. }), | hir::StmtKind::Semi(hir::Expr { span, hir_id, .. }),
.. ..

2
src/tools/clippy/clippy_lints/src/uninit_vec.rs
View File

@ -153,7 +153,7 @@ impl<'tcx> VecLocation<'tcx> {
/// or `self` expression for `Vec::reserve()`. /// or `self` expression for `Vec::reserve()`.
fn extract_init_or_reserve_target<'tcx>(cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'tcx>) -> Option<TargetVec<'tcx>> { fn extract_init_or_reserve_target<'tcx>(cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'tcx>) -> Option<TargetVec<'tcx>> {
match stmt.kind { match stmt.kind {
StmtKind::Local(local) => { StmtKind::Let(local) => {
if let Some(init_expr) = local.init if let Some(init_expr) = local.init
&& let PatKind::Binding(_, hir_id, _, None) = local.pat.kind && let PatKind::Binding(_, hir_id, _, None) = local.pat.kind
&& let Some(init_kind) = get_vec_init_kind(cx, init_expr) && let Some(init_kind) = get_vec_init_kind(cx, init_expr)

4
src/tools/clippy/clippy_lints/src/unused_io_amount.rs
View File

@ -61,10 +61,10 @@ impl<'tcx> LateLintPass<'tcx> for UnusedIoAmount {
/// we need to check them at `check_expr` or `check_block` as they are not stmts /// we need to check them at `check_expr` or `check_block` as they are not stmts
/// but we can't check them at `check_expr` because we need the broader context /// but we can't check them at `check_expr` because we need the broader context
/// because we should do this only for the final expression of the block, and not for /// because we should do this only for the final expression of the block, and not for
/// `StmtKind::Local` which binds values => the io amount is used. /// `StmtKind::Let` which binds values => the io amount is used.
/// ///
/// To check for unused io amount in stmts, we only consider `StmtKind::Semi`. /// To check for unused io amount in stmts, we only consider `StmtKind::Semi`.
/// `StmtKind::Local` is not considered because it binds values => the io amount is used. /// `StmtKind::Let` is not considered because it binds values => the io amount is used.
/// `StmtKind::Expr` is not considered because requires unit type => the io amount is used. /// `StmtKind::Expr` is not considered because requires unit type => the io amount is used.
/// `StmtKind::Item` is not considered because it's not an expression. /// `StmtKind::Item` is not considered because it's not an expression.
/// ///

4
src/tools/clippy/clippy_lints/src/unused_peekable.rs
View File

@ -56,7 +56,7 @@ impl<'tcx> LateLintPass<'tcx> for UnusedPeekable {
for (idx, stmt) in block.stmts.iter().enumerate() { for (idx, stmt) in block.stmts.iter().enumerate() {
if !stmt.span.from_expansion() if !stmt.span.from_expansion()
&& let StmtKind::Local(local) = stmt.kind && let StmtKind::Let(local) = stmt.kind
&& let PatKind::Binding(_, binding, ident, _) = local.pat.kind && let PatKind::Binding(_, binding, ident, _) = local.pat.kind
&& let Some(init) = local.init && let Some(init) = local.init
&& !init.span.from_expansion() && !init.span.from_expansion()
@ -197,7 +197,7 @@ impl<'tcx> Visitor<'tcx> for PeekableVisitor<'_, 'tcx> {
}, },
Node::Stmt(stmt) => { Node::Stmt(stmt) => {
match stmt.kind { match stmt.kind {
StmtKind::Local(_) | StmtKind::Item(_) => self.found_peek_call = true, StmtKind::Let(_) | StmtKind::Item(_) => self.found_peek_call = true,
StmtKind::Expr(_) | StmtKind::Semi(_) => {}, StmtKind::Expr(_) | StmtKind::Semi(_) => {},
} }

2
src/tools/clippy/clippy_lints/src/utils/author.rs
View File

@ -724,7 +724,7 @@ impl<'a, 'tcx> PrintVisitor<'a, 'tcx> {
} }
match stmt.value.kind { match stmt.value.kind {
StmtKind::Local(local) => { StmtKind::Let(local) => {
bind!(self, local); bind!(self, local);
kind!("Local({local})"); kind!("Local({local})");
self.option(field!(local.init), "init", |init| { self.option(field!(local.init), "init", |init| {

2
src/tools/clippy/clippy_utils/src/ast_utils.rs
View File

@ -267,7 +267,7 @@ pub fn eq_block(l: &Block, r: &Block) -> bool {
pub fn eq_stmt(l: &Stmt, r: &Stmt) -> bool { pub fn eq_stmt(l: &Stmt, r: &Stmt) -> bool {
use StmtKind::*; use StmtKind::*;
match (&l.kind, &r.kind) { match (&l.kind, &r.kind) {
(Local(l), Local(r)) => { (Let(l), Let(r)) => {
eq_pat(&l.pat, &r.pat) eq_pat(&l.pat, &r.pat)
&& both(&l.ty, &r.ty, |l, r| eq_ty(l, r)) && both(&l.ty, &r.ty, |l, r| eq_ty(l, r))
&& eq_local_kind(&l.kind, &r.kind) && eq_local_kind(&l.kind, &r.kind)

4
src/tools/clippy/clippy_utils/src/hir_utils.rs
View File

@ -108,7 +108,7 @@ pub struct HirEqInterExpr<'a, 'b, 'tcx> {
impl HirEqInterExpr<'_, '_, '_> { impl HirEqInterExpr<'_, '_, '_> {
pub fn eq_stmt(&mut self, left: &Stmt<'_>, right: &Stmt<'_>) -> bool { pub fn eq_stmt(&mut self, left: &Stmt<'_>, right: &Stmt<'_>) -> bool {
match (&left.kind, &right.kind) { match (&left.kind, &right.kind) {
(&StmtKind::Local(l), &StmtKind::Local(r)) => { (&StmtKind::Let(l), &StmtKind::Let(r)) => {
// This additional check ensures that the type of the locals are equivalent even if the init // This additional check ensures that the type of the locals are equivalent even if the init
// expression or type have some inferred parts. // expression or type have some inferred parts.
if let Some((typeck_lhs, typeck_rhs)) = self.inner.maybe_typeck_results { if let Some((typeck_lhs, typeck_rhs)) = self.inner.maybe_typeck_results {
@ -1030,7 +1030,7 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {
std::mem::discriminant(&b.kind).hash(&mut self.s); std::mem::discriminant(&b.kind).hash(&mut self.s);
match &b.kind { match &b.kind {
StmtKind::Local(local) => { StmtKind::Let(local) => {
self.hash_pat(local.pat); self.hash_pat(local.pat);
if let Some(init) = local.init { if let Some(init) = local.init {
self.hash_expr(init); self.hash_expr(init);

2
src/tools/clippy/clippy_utils/src/lib.rs
View File

@ -2161,7 +2161,7 @@ pub fn is_expr_used_or_unified(tcx: TyCtxt<'_>, expr: &Expr<'_>) -> bool {
Node::Stmt(Stmt { Node::Stmt(Stmt {
kind: StmtKind::Expr(_) kind: StmtKind::Expr(_)
| StmtKind::Semi(_) | StmtKind::Semi(_)
| StmtKind::Local(Local { | StmtKind::Let(Local {
pat: Pat { pat: Pat {
kind: PatKind::Wild, kind: PatKind::Wild,
.. ..

2
src/tools/rustfmt/src/attr.rs
View File

@ -26,7 +26,7 @@ pub(crate) fn get_attrs_from_stmt(stmt: &ast::Stmt) -> &[ast::Attribute] {
pub(crate) fn get_span_without_attrs(stmt: &ast::Stmt) -> Span { pub(crate) fn get_span_without_attrs(stmt: &ast::Stmt) -> Span {
match stmt.kind { match stmt.kind {
ast::StmtKind::Local(ref local) => local.span, ast::StmtKind::Let(ref local) => local.span,
ast::StmtKind::Item(ref item) => item.span, ast::StmtKind::Item(ref item) => item.span,
ast::StmtKind::Expr(ref expr) | ast::StmtKind::Semi(ref expr) => expr.span, ast::StmtKind::Expr(ref expr) | ast::StmtKind::Semi(ref expr) => expr.span,
ast::StmtKind::MacCall(ref mac_stmt) => mac_stmt.mac.span(), ast::StmtKind::MacCall(ref mac_stmt) => mac_stmt.mac.span(),

2
src/tools/rustfmt/src/spanned.rs
View File

@ -61,7 +61,7 @@ implement_spanned!(ast::Local);
impl Spanned for ast::Stmt { impl Spanned for ast::Stmt {
fn span(&self) -> Span { fn span(&self) -> Span {
match self.kind { match self.kind {
ast::StmtKind::Local(ref local) => mk_sp(local.span().lo(), self.span.hi()), ast::StmtKind::Let(ref local) => mk_sp(local.span().lo(), self.span.hi()),
ast::StmtKind::Item(ref item) => mk_sp(item.span().lo(), self.span.hi()), ast::StmtKind::Item(ref item) => mk_sp(item.span().lo(), self.span.hi()),
ast::StmtKind::Expr(ref expr) | ast::StmtKind::Semi(ref expr) => { ast::StmtKind::Expr(ref expr) | ast::StmtKind::Semi(ref expr) => {
mk_sp(expr.span().lo(), self.span.hi()) mk_sp(expr.span().lo(), self.span.hi())

2
src/tools/rustfmt/src/stmt.rs
View File

@ -115,7 +115,7 @@ fn format_stmt(
skip_out_of_file_lines_range!(context, stmt.span()); skip_out_of_file_lines_range!(context, stmt.span());
let result = match stmt.kind { let result = match stmt.kind {
ast::StmtKind::Local(ref local) => local.rewrite(context, shape), ast::StmtKind::Let(ref local) => local.rewrite(context, shape),
ast::StmtKind::Expr(ref ex) | ast::StmtKind::Semi(ref ex) => { ast::StmtKind::Expr(ref ex) | ast::StmtKind::Semi(ref ex) => {
let suffix = if semicolon_for_stmt(context, stmt, is_last_expr) { let suffix = if semicolon_for_stmt(context, stmt, is_last_expr) {
";" ";"

2
src/tools/rustfmt/src/visitor.rs
View File

@ -150,7 +150,7 @@ impl<'b, 'a: 'b> FmtVisitor<'a> {
self.visit_item(item); self.visit_item(item);
self.last_pos = stmt.span().hi(); self.last_pos = stmt.span().hi();
} }
ast::StmtKind::Local(..) | ast::StmtKind::Expr(..) | ast::StmtKind::Semi(..) => { ast::StmtKind::Let(..) | ast::StmtKind::Expr(..) | ast::StmtKind::Semi(..) => {
let attrs = get_attrs_from_stmt(stmt.as_ast_node()); let attrs = get_attrs_from_stmt(stmt.as_ast_node());
if contains_skip(attrs) { if contains_skip(attrs) {
self.push_skipped_with_span( self.push_skipped_with_span(

6
tests/ui/stats/hir-stats.stderr
View File

@ -17,7 +17,7 @@ ast-stats-1 - Fn 96 ( 1.4%) 1
ast-stats-1 FnDecl 120 ( 1.8%) 5 24 ast-stats-1 FnDecl 120 ( 1.8%) 5 24
ast-stats-1 FieldDef 160 ( 2.4%) 2 80 ast-stats-1 FieldDef 160 ( 2.4%) 2 80
ast-stats-1 Stmt 160 ( 2.4%) 5 32 ast-stats-1 Stmt 160 ( 2.4%) 5 32
ast-stats-1 - Local 32 ( 0.5%) 1 ast-stats-1 - Let 32 ( 0.5%) 1
ast-stats-1 - MacCall 32 ( 0.5%) 1 ast-stats-1 - MacCall 32 ( 0.5%) 1
ast-stats-1 - Expr 96 ( 1.4%) 3 ast-stats-1 - Expr 96 ( 1.4%) 3
ast-stats-1 Param 160 ( 2.4%) 4 40 ast-stats-1 Param 160 ( 2.4%) 4 40
@ -75,7 +75,7 @@ ast-stats-2 - DocComment 32 ( 0.4%) 1
ast-stats-2 - Normal 96 ( 1.3%) 3 ast-stats-2 - Normal 96 ( 1.3%) 3
ast-stats-2 FieldDef 160 ( 2.2%) 2 80 ast-stats-2 FieldDef 160 ( 2.2%) 2 80
ast-stats-2 Stmt 160 ( 2.2%) 5 32 ast-stats-2 Stmt 160 ( 2.2%) 5 32
ast-stats-2 - Local 32 ( 0.4%) 1 ast-stats-2 - Let 32 ( 0.4%) 1
ast-stats-2 - Semi 32 ( 0.4%) 1 ast-stats-2 - Semi 32 ( 0.4%) 1
ast-stats-2 - Expr 96 ( 1.3%) 3 ast-stats-2 - Expr 96 ( 1.3%) 3
ast-stats-2 Param 160 ( 2.2%) 4 40 ast-stats-2 Param 160 ( 2.2%) 4 40
@ -131,7 +131,7 @@ hir-stats ImplItemRef 72 ( 0.8%) 2 36
hir-stats Arm 80 ( 0.9%) 2 40 hir-stats Arm 80 ( 0.9%) 2 40
hir-stats FieldDef 96 ( 1.1%) 2 48 hir-stats FieldDef 96 ( 1.1%) 2 48
hir-stats Stmt 96 ( 1.1%) 3 32 hir-stats Stmt 96 ( 1.1%) 3 32
hir-stats - Local 32 ( 0.4%) 1 hir-stats - Let 32 ( 0.4%) 1
hir-stats - Semi 32 ( 0.4%) 1 hir-stats - Semi 32 ( 0.4%) 1
hir-stats - Expr 32 ( 0.4%) 1 hir-stats - Expr 32 ( 0.4%) 1
hir-stats FnDecl 120 ( 1.3%) 3 40 hir-stats FnDecl 120 ( 1.3%) 3 40