[WIP] Run the unused variables lint on the MIR

Cargo.lock

@@ -4164,6 +4164,7 @@ dependencies = [
  "rustc_infer",
  "rustc_macros",
  "rustc_middle",
+ "rustc_mir",
  "rustc_session",
  "rustc_span",
  "rustc_target",

src/librustc_interface/passes.rs

@@ -823,8 +823,6 @@ fn analysis(tcx: TyCtxt<'_>, cnum: CrateNum) -> Result<()> {
                         //
                         // maybe move the check to a MIR pass?
                         let local_def_id = tcx.hir().local_def_id(module);
-
-                        tcx.ensure().check_mod_liveness(local_def_id);
                         tcx.ensure().check_mod_intrinsics(local_def_id);
                     });
                 });

src/librustc_middle/lint.rs

@@ -12,7 +12,7 @@ use rustc_span::source_map::{DesugaringKind, ExpnKind, MultiSpan};
 use rustc_span::{Span, Symbol};
 
 /// How a lint level was set.
-#[derive(Clone, Copy, PartialEq, Eq, HashStable)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, HashStable, RustcEncodable, RustcDecodable)]
 pub enum LintSource {
     /// Lint is at the default level as declared
     /// in rustc or a plugin.

src/librustc_middle/mir/mod.rs

@@ -2,6 +2,7 @@
 //!
 //! [rustc dev guide]: https://rustc-dev-guide.rust-lang.org/mir/index.html
 
+use crate::lint;
 use crate::mir::interpret::{GlobalAlloc, Scalar};
 use crate::mir::visit::MirVisitable;
 use crate::ty::adjustment::PointerCast;
@@ -14,7 +15,7 @@ use crate::ty::{
 use rustc_hir as hir;
 use rustc_hir::def::{CtorKind, Namespace};
 use rustc_hir::def_id::DefId;
-use rustc_hir::{self, GeneratorKind};
+use rustc_hir::GeneratorKind;
 use rustc_target::abi::VariantIdx;
 
 use polonius_engine::Atom;
@@ -596,6 +597,22 @@ pub enum LocalKind {
 
 #[derive(Clone, Debug, RustcEncodable, RustcDecodable, HashStable)]
 pub struct VarBindingForm<'tcx> {
+    /// Bindings in match arms with guards are lowered to two distinct locals, one for inside the
+    /// guard and one for inside the match arm. If this local is the one used in the match arm,
+    /// `counterpart_in_guard` will be the local representing the same binding in the guard.
+    pub counterpart_in_guard: Option<Local>,
+
+    /// `true` if this variable was declared as a binding to a struct field with the same name
+    /// (e.g., `x` in `Foo { x }`).
+    pub is_shorthand_field_binding: bool,
+
+    /// The name of this variable.
+    pub name: Symbol,
+
+    pub unused_variables_lint_level: lint::LevelSource,
+
+    pub unused_assignments_lint_level: lint::LevelSource,
+
     /// Is variable bound via `x`, `mut x`, `ref x`, or `ref mut x`?
     pub binding_mode: ty::BindingMode,
     /// If an explicit type was provided for this variable binding,
@@ -845,9 +862,7 @@ impl<'tcx> LocalDecl<'tcx> {
         match self.local_info {
             Some(box LocalInfo::User(ClearCrossCrate::Set(BindingForm::Var(VarBindingForm {
                 binding_mode: ty::BindingMode::BindByValue(_),
-                opt_ty_info: _,
-                opt_match_place: _,
-                pat_span: _,
+                ..
             })))) => true,
 
             Some(box LocalInfo::User(ClearCrossCrate::Set(BindingForm::ImplicitSelf(
@@ -865,9 +880,7 @@ impl<'tcx> LocalDecl<'tcx> {
         match self.local_info {
             Some(box LocalInfo::User(ClearCrossCrate::Set(BindingForm::Var(VarBindingForm {
                 binding_mode: ty::BindingMode::BindByValue(_),
-                opt_ty_info: _,
-                opt_match_place: _,
-                pat_span: _,
+                ..
             })))) => true,
 
             Some(box LocalInfo::User(ClearCrossCrate::Set(BindingForm::ImplicitSelf(_)))) => true,
@@ -1717,6 +1730,14 @@ pub enum FakeReadCause {
     /// appropriate errors.
     ForLet,
 
+    /// This denotes the existence of a statement like
+    ///
+    /// `let _ = <expr>;`
+    ///
+    /// which would not otherwise be recorded in the MIR. This is required for to
+    /// implement the unused variable lint on the MIR. It should be ignored elsewhere.
+    ForLetUnderscore,
+
     /// If we have an index expression like
     ///
     /// (*x)[1][{ x = y; 4}]

src/librustc_middle/mir/visit.rs

@@ -1184,9 +1184,34 @@ impl PlaceContext {
             PlaceContext::MutatingUse(
                 MutatingUseContext::Store
                 | MutatingUseContext::Call
+                | MutatingUseContext::Yield
                 | MutatingUseContext::AsmOutput,
             ) => true,
             _ => false,
         }
     }
+
+    /// Returns `true` if this context could read the contents of the place.
+    pub fn is_read(&self) -> bool {
+        match *self {
+            PlaceContext::MutatingUse(
+                MutatingUseContext::Store | MutatingUseContext::Call | MutatingUseContext::Yield,
+            )
+            | PlaceContext::NonUse(_) => false,
+
+            PlaceContext::MutatingUse(_) | PlaceContext::NonMutatingUse(_) => true,
+        }
+    }
+
+    /// Returns `true` if this context does not read from this place but does write to it.
+    ///
+    /// This is relevant for inline assembly, which has read/write parameters.
+    pub fn is_write_only(&self) -> bool {
+        matches!(
+            self,
+            PlaceContext::MutatingUse(
+                MutatingUseContext::Store | MutatingUseContext::Call | MutatingUseContext::Yield
+            )
+        )
+    }
 }

src/librustc_middle/query/mod.rs

@@ -430,10 +430,6 @@ rustc_queries! {
             desc { |tcx| "checking intrinsics in {}", describe_as_module(key, tcx) }
         }
 
-        query check_mod_liveness(key: DefId) -> () {
-            desc { |tcx| "checking liveness of variables in {}", describe_as_module(key, tcx) }
-        }
-
         query check_mod_impl_wf(key: DefId) -> () {
             desc { |tcx| "checking that impls are well-formed in {}", describe_as_module(key, tcx) }
         }

src/librustc_mir/borrow_check/diagnostics/move_errors.rs

@@ -106,9 +106,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
                         if let Some(box LocalInfo::User(ClearCrossCrate::Set(BindingForm::Var(
                             VarBindingForm {
                                 opt_match_place: Some((opt_match_place, match_span)),
-                                binding_mode: _,
-                                opt_ty_info: _,
-                                pat_span: _,
+                                ..
                             },
                         )))) = local_decl.local_info
                         {

src/librustc_mir/borrow_check/mod.rs

@@ -12,7 +12,7 @@ use rustc_index::bit_set::BitSet;
 use rustc_index::vec::IndexVec;
 use rustc_infer::infer::{InferCtxt, TyCtxtInferExt};
 use rustc_middle::mir::{
-    traversal, Body, ClearCrossCrate, Local, Location, Mutability, Operand, Place, PlaceElem,
+    self, traversal, Body, ClearCrossCrate, Local, Location, Mutability, Operand, Place, PlaceElem,
     PlaceRef,
 };
 use rustc_middle::mir::{AggregateKind, BasicBlock, BorrowCheckResult, BorrowKind};
@@ -571,6 +571,10 @@ impl<'cx, 'tcx> dataflow::ResultsVisitor<'cx, 'tcx> for MirBorrowckCtxt<'cx, 'tc
 
                 self.mutate_place(location, (*lhs, span), Shallow(None), JustWrite, flow_state);
             }
+
+            // `ForLetUnderscore` is only intended for the unused variables lint.
+            StatementKind::FakeRead(mir::FakeReadCause::ForLetUnderscore, _) => {}
+
             StatementKind::FakeRead(_, box ref place) => {
                 // Read for match doesn't access any memory and is used to
                 // assert that a place is safe and live. So we don't have to

src/librustc_mir/dataflow/impls/liveness.rs

@@ -49,6 +49,9 @@ impl GenKillAnalysis<'tcx> for MaybeLiveLocals {
         statement: &mir::Statement<'tcx>,
         location: Location,
     ) {
+        if let mir::StatementKind::FakeRead(mir::FakeReadCause::ForLet, _) = statement.kind {
+            return;
+        }
         self.transfer_function(trans).visit_statement(statement, location);
     }
 

src/librustc_mir/transform/check_consts/validation.rs

@@ -514,7 +514,10 @@ impl Visitor<'tcx> for Validator<'mir, 'tcx> {
                 self.check_op(ops::InlineAsm);
             }
 
-            StatementKind::FakeRead(FakeReadCause::ForLet | FakeReadCause::ForIndex, _)
+            StatementKind::FakeRead(
+                FakeReadCause::ForLet | FakeReadCause::ForIndex | FakeReadCause::ForLetUnderscore,
+                _,
+            )
             | StatementKind::StorageLive(_)
             | StatementKind::StorageDead(_)
             | StatementKind::Retag { .. }

src/librustc_mir_build/Cargo.toml

@@ -21,6 +21,7 @@ rustc_errors = { path = "../librustc_errors" }
 rustc_hir = { path = "../librustc_hir" }
 rustc_infer = { path = "../librustc_infer" }
 rustc_macros = { path = "../librustc_macros" }
+rustc_mir = { path = "../librustc_mir" } # Just for dataflow
 rustc_serialize = { path = "../libserialize", package = "serialize" }
 rustc_session = { path = "../librustc_session" }
 rustc_span = { path = "../librustc_span" }

src/librustc_mir_build/build/block.rs

@@ -78,6 +78,8 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
 
         let source_info = this.source_info(span);
         for stmt in stmts {
+            debug!("ast_block_stmt({:?})", stmt);
+
             let Stmt { kind, opt_destruction_scope } = this.hir.mirror(stmt);
             match kind {
                 StmtKind::Expr { scope, expr } => {
@@ -96,8 +98,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                     );
                 }
                 StmtKind::Let { remainder_scope, init_scope, pattern, initializer, lint_level } => {
-                    let ignores_expr_result =
-                        if let PatKind::Wild = *pattern.kind { true } else { false };
+                    let ignores_expr_result = matches!(*pattern.kind, PatKind::Wild);
                     this.block_context.push(BlockFrame::Statement { ignores_expr_result });
 
                     // Enter the remainder scope, i.e., the bindings' destruction scope.

src/librustc_mir_build/build/matches/mod.rs

@@ -16,6 +16,7 @@ use rustc_index::bit_set::BitSet;
 use rustc_middle::middle::region;
 use rustc_middle::mir::*;
 use rustc_middle::ty::{self, CanonicalUserTypeAnnotation, Ty};
+use rustc_session::lint;
 use rustc_span::Span;
 use rustc_span::symbol::Symbol;
 use rustc_target::abi::VariantIdx;
@@ -439,6 +440,20 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 block.unit()
             }
 
+            // Handle bindings like `let _ = var;` by lowering them to a fake read of the RHS. This
+            // is needed by the unused variables lint pass.
+            PatKind::Wild => {
+                let place = unpack!(block = self.as_place(block, initializer));
+                debug!("expr_into_pattern(place = {:?}, PatKind::Wild)", place);
+
+                if place.as_local().is_some() {
+                    let source_info = self.source_info(irrefutable_pat.span);
+                    self.cfg.push_fake_read(block, source_info, FakeReadCause::ForLetUnderscore, place);
+                }
+
+                block.unit()
+            }
+
             _ => {
                 let place = unpack!(block = self.as_place(block, initializer));
                 self.place_into_pattern(block, irrefutable_pat, place, true)
@@ -1966,6 +1981,31 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             BindingMode::ByRef(_) => ty::BindingMode::BindByReference(mutability),
         };
         debug!("declare_binding: user_ty={:?}", user_ty);
+
+        let ref_for_guard = has_guard.0.then(|| {
+            let local = self.local_decls.push(LocalDecl::<'tcx> {
+                // This variable isn't mutated but has a name, so has to be
+                // immutable to avoid the unused mut lint.
+                mutability: Mutability::Not,
+                ty: tcx.mk_imm_ref(tcx.lifetimes.re_erased, var_ty),
+                user_ty: None,
+                source_info,
+                internal: false,
+                is_block_tail: None,
+                local_info: Some(box LocalInfo::User(ClearCrossCrate::Set(BindingForm::RefForGuard))),
+            });
+            self.var_debug_info.push(VarDebugInfo {
+                name,
+                source_info: debug_source_info,
+                place: local.into(),
+            });
+            local
+        });
+
+        let name = tcx.hir().name(var_id);
+        let is_shorthand_field_binding = false;
+        let unused_variables_lint_level = tcx.lint_level_at_node(lint::builtin::UNUSED_VARIABLES, var_id);
+        let unused_assignments_lint_level = tcx.lint_level_at_node(lint::builtin::UNUSED_ASSIGNMENTS, var_id);
         let local = LocalDecl::<'tcx> {
             mutability,
             ty: var_ty,
@@ -1974,6 +2014,11 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             internal: false,
             is_block_tail: None,
             local_info: Some(box LocalInfo::User(ClearCrossCrate::Set(BindingForm::Var(VarBindingForm {
+                unused_assignments_lint_level,
+                unused_variables_lint_level,
+                is_shorthand_field_binding,
+                counterpart_in_guard: ref_for_guard,
+                name,
                 binding_mode,
                 // hypothetically, `visit_primary_bindings` could try to unzip
                 // an outermost hir::Ty as we descend, matching up
@@ -1990,27 +2035,12 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             source_info: debug_source_info,
             place: for_arm_body.into(),
         });
-        let locals = if has_guard.0 {
-            let ref_for_guard = self.local_decls.push(LocalDecl::<'tcx> {
-                // This variable isn't mutated but has a name, so has to be
-                // immutable to avoid the unused mut lint.
-                mutability: Mutability::Not,
-                ty: tcx.mk_imm_ref(tcx.lifetimes.re_erased, var_ty),
-                user_ty: None,
-                source_info,
-                internal: false,
-                is_block_tail: None,
-                local_info: Some(box LocalInfo::User(ClearCrossCrate::Set(BindingForm::RefForGuard))),
-            });
-            self.var_debug_info.push(VarDebugInfo {
-                name,
-                source_info: debug_source_info,
-                place: ref_for_guard.into(),
-            });
-            LocalsForNode::ForGuard { ref_for_guard, for_arm_body }
-        } else {
-            LocalsForNode::One(for_arm_body)
+
+        let locals = match ref_for_guard {
+            Some(ref_for_guard) => LocalsForNode::ForGuard { ref_for_guard, for_arm_body },
+            None => LocalsForNode::One(for_arm_body),
         };
+
         debug!("declare_binding: vars={:?}", locals);
         self.var_indices.insert(var_id, locals);
     }

src/librustc_mir_build/build/mod.rs

@@ -14,6 +14,7 @@ use rustc_middle::middle::region;
 use rustc_middle::mir::*;
 use rustc_middle::ty::subst::Subst;
 use rustc_middle::ty::{self, Ty, TyCtxt, TypeFoldable};
+use rustc_session::lint;
 use rustc_span::symbol::kw;
 use rustc_span::Span;
 use rustc_target::spec::abi::Abi;
@@ -181,7 +182,8 @@ fn mir_build(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Body<'_> {
             build::construct_const(cx, body_id, return_ty, return_ty_span)
         };
 
-        lints::check(tcx, &body, def_id);
+        lints::unconditional_recursion::check(tcx, &body, def_id);
+        lints::unused_variables::check(tcx, &body, def_id);
 
         // The borrow checker will replace all the regions here with its own
         // inference variables. There's no point having non-erased regions here.
@@ -888,8 +890,17 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                             Some(box LocalInfo::User(ClearCrossCrate::Set(BindingForm::ImplicitSelf(*kind))))
                         } else {
                             let binding_mode = ty::BindingMode::BindByValue(mutability);
+                            let unused_variables_lint_level = tcx.lint_level_at_node(lint::builtin::UNUSED_VARIABLES, var);
+                            let unused_assignments_lint_level = tcx.lint_level_at_node(lint::builtin::UNUSED_ASSIGNMENTS, var);
+                            let is_shorthand_field_binding = false;
+                            let name = tcx_hir.name(var);
                             Some(box LocalInfo::User(ClearCrossCrate::Set(BindingForm::Var(
                                 VarBindingForm {
+                                    is_shorthand_field_binding,
+                                    counterpart_in_guard: None,
+                                    name,
+                                    unused_variables_lint_level,
+                                    unused_assignments_lint_level,
                                     binding_mode,
                                     opt_ty_info,
                                     opt_match_place: Some((Some(place), span)),

src/librustc_mir_build/lib.rs

@@ -9,6 +9,7 @@
 #![feature(const_panic)]
 #![feature(crate_visibility_modifier)]
 #![feature(bool_to_option)]
+#![feature(in_band_lifetimes)]
 #![feature(or_patterns)]
 #![recursion_limit = "256"]
 

src/librustc_mir_build/lints/mod.rs

@@ -0,0 +1,7 @@
+//! Lints that run immediately after MIR building.
+//!
+//! By running these before any MIR transformations, we ensure that the MIR is as close to the
+//! user's code as possible.
+
+pub mod unconditional_recursion;
+pub mod unused_variables;

src/librustc_mir_build/lints/unused_variables.rs

@@ -0,0 +1,374 @@
+#![allow(unused)]
+
+use rustc_hir::def_id::LocalDefId;
+use rustc_index::bit_set::BitSet;
+use rustc_middle::lint::{struct_lint_level, LevelSource};
+use rustc_middle::mir::visit::{MutatingUseContext, PlaceContext, Visitor};
+use rustc_middle::mir::{self, Local, Location};
+use rustc_middle::ty::TyCtxt;
+use rustc_mir::dataflow::impls::MaybeLiveLocals;
+use rustc_mir::dataflow::{self, Analysis};
+use rustc_session::lint;
+use rustc_span::Symbol;
+
+pub fn check(tcx: TyCtxt<'tcx>, body: &'mir mir::Body<'tcx>, def_id: LocalDefId) {
+    warn!("check unused variables: {:?}", def_id);
+
+    let used = UsedLocals::in_body(body);
+
+    let live = MaybeLiveLocals
+        .into_engine(tcx, body, def_id.to_def_id())
+        .iterate_to_fixpoint()
+        .into_results_cursor(body);
+
+    let mut pass = LintUnused {
+        tcx,
+        body,
+        live,
+        used: used.0,
+        written: BitSet::new_empty(body.local_decls.len()),
+    };
+
+    // Mark the match arm local for a variable as used if its counterpart in the match guard is
+    // used.
+    for local in body.local_decls.indices() {
+        if let Some(counterpart) = pass.user_var(local).and_then(Variable::counterpart_in_guard) {
+            if pass.used.contains(counterpart) {
+                pass.used.insert(local);
+            }
+        }
+    }
+
+    pass.visit_body(body);
+
+    pass.check_args_at_function_entry();
+    pass.check_for_unused();
+}
+
+/// A user-defined variable.
+///
+/// Ideally this would only be a `HirId`, but storing a `HirId` inside a `LocalInfo` breaks some
+/// incremental tests.
+#[derive(Clone, Copy)]
+struct Variable<'a, 'tcx> {
+    var: &'a mir::VarBindingForm<'tcx>,
+}
+
+impl Variable<'_, 'tcx> {
+    fn name(&self) -> Symbol {
+        self.var.name
+    }
+
+    fn lint_if_unused(&self) -> bool {
+        let name = self.name().as_str();
+        let ignore = name.starts_with('_') || name == "self";
+        !ignore
+    }
+
+    fn counterpart_in_guard(self) -> Option<Local> {
+        self.var.counterpart_in_guard
+    }
+
+    #[allow(unused)]
+    fn is_shorthand_field_binding(&self) -> bool {
+        self.var.is_shorthand_field_binding
+    }
+
+    fn unused_variables_lint_level(&self) -> LevelSource {
+        self.var.unused_variables_lint_level
+    }
+
+    fn unused_assignments_lint_level(&self) -> LevelSource {
+        self.var.unused_assignments_lint_level
+    }
+}
+
+struct LintUnused<'mir, 'tcx> {
+    tcx: TyCtxt<'tcx>,
+    body: &'mir mir::Body<'tcx>,
+    live: dataflow::ResultsCursor<'mir, 'tcx, MaybeLiveLocals>,
+
+    used: BitSet<Local>,
+    written: BitSet<Local>,
+}
+
+impl LintUnused<'mir, 'tcx> {
+    fn should_lint(&self, local: Local) -> bool {
+        self.user_var(local).map_or(false, |var| var.lint_if_unused())
+    }
+
+    fn user_var(&self, local: Local) -> Option<Variable<'_, 'tcx>> {
+        let local_decl = &self.body.local_decls[local];
+        let local_info = local_decl.local_info.as_ref()?;
+
+        let var = match local_info {
+            box mir::LocalInfo::User(mir::ClearCrossCrate::Set(mir::BindingForm::Var(var))) => var,
+            _ => return None,
+        };
+
+        Some(Variable { var })
+    }
+
+    fn check_args_at_function_entry(&mut self) {
+        self.live.seek_to_block_start(mir::START_BLOCK);
+        for arg in self.body.args_iter() {
+            if !self.live.contains(arg) && self.used.contains(arg) && self.should_lint(arg) {
+                self.lint_unused_param(arg);
+            }
+        }
+    }
+
+    fn check_for_unused(&self) {
+        for local in self.body.local_decls.indices() {
+            if !self.used.contains(local) && self.should_lint(local) {
+                if self.written.contains(local) {
+                    self.lint_unused_but_assigned(local);
+                } else {
+                    self.lint_unused(local);
+                }
+            }
+        }
+    }
+
+    fn lint_unused_but_assigned(&self, local: Local) {
+        debug!("lint_unused_but_assigned({:?})", local);
+
+        let span = self.body.local_decls[local].source_info.span;
+        let var = self.user_var(local).unwrap();
+        let name = var.name();
+
+        struct_lint_level(
+            &self.tcx.sess,
+            lint::builtin::UNUSED_VARIABLES,
+            var.unused_variables_lint_level().0,
+            var.unused_variables_lint_level().1,
+            Some(span.into()),
+            |lint| {
+                lint.build(&format!("variable `{}` is assigned to, but never used", name))
+                    .note(&format!("consider using `_{}` instead", name))
+                    .emit();
+            },
+        );
+    }
+
+    fn lint_unused(&self, local: Local) {
+        debug!("lint_unused({:?})", local);
+
+        let span = self.body.local_decls[local].source_info.span;
+        let var = self.user_var(local).unwrap();
+
+        struct_lint_level(
+            &self.tcx.sess,
+            lint::builtin::UNUSED_VARIABLES,
+            var.unused_variables_lint_level().0,
+            var.unused_variables_lint_level().1,
+            Some(span.into()),
+            |lint| {
+                let mut err = lint.build(&format!("unused variable: `{}`", var.name()));
+                err.emit();
+                /*
+
+                let (shorthands, non_shorthands): (Vec<_>, Vec<_>) =
+                    hir_ids_and_spans.into_iter().partition(|(hir_id, span)| {
+                        let var = self.variable(*hir_id, *span);
+                        self.ir.variable_is_shorthand(var)
+                    });
+
+                let mut shorthands = shorthands
+                    .into_iter()
+                    .map(|(_, span)| (span, format!("{}: _", name)))
+                    .collect::<Vec<_>>();
+
+                // If we have both shorthand and non-shorthand, prefer the "try ignoring
+                // the field" message, and suggest `_` for the non-shorthands. If we only
+                // have non-shorthand, then prefix with an underscore instead.
+                if !shorthands.is_empty() {
+                    shorthands.extend(
+                        non_shorthands
+                            .into_iter()
+                            .map(|(_, span)| (span, "_".to_string()))
+                            .collect::<Vec<_>>(),
+                    );
+
+                    err.multipart_suggestion(
+                        "try ignoring the field",
+                        shorthands,
+                        Applicability::MachineApplicable,
+                    );
+                } else {
+                    err.multipart_suggestion(
+                        "if this is intentional, prefix it with an underscore",
+                        non_shorthands
+                            .into_iter()
+                            .map(|(_, span)| (span, format!("_{}", name)))
+                            .collect::<Vec<_>>(),
+                        Applicability::MachineApplicable,
+                    );
+                }
+
+                err.emit()
+                */
+            },
+        );
+    }
+
+    fn lint_unused_assign(&mut self, local: Local, location: Location) {
+        debug!("lint_unused_assign({:?}, {:?})", local, location);
+
+        let span = self.body.source_info(location).span;
+        let var = self.user_var(local).unwrap();
+        struct_lint_level(
+            &self.tcx.sess,
+            lint::builtin::UNUSED_ASSIGNMENTS,
+            var.unused_assignments_lint_level().0,
+            var.unused_assignments_lint_level().1,
+            Some(span.into()),
+            |lint| {
+                lint.build(&format!("value assigned to `{}` is never read", var.name()))
+                    .help("maybe it is overwritten before being read?")
+                    .emit();
+            },
+        );
+    }
+
+    fn lint_unused_param(&mut self, local: Local) {
+        debug!("lint_unused_assign({:?})", local);
+
+        let span = self.body.local_decls[local].source_info.span;
+        let var = self.user_var(local).unwrap();
+        struct_lint_level(
+            &self.tcx.sess,
+            lint::builtin::UNUSED_ASSIGNMENTS,
+            var.unused_assignments_lint_level().0,
+            var.unused_assignments_lint_level().1,
+            Some(span.into()),
+            |lint| {
+                lint.build(&format!("value passed to `{}` is never read", var.name()))
+                    .help("maybe it is overwritten before being read?")
+                    .emit();
+            },
+        )
+    }
+}
+
+impl Visitor<'tcx> for LintUnused<'mir, 'tcx> {
+    fn visit_statement(&mut self, statement: &mir::Statement<'tcx>, location: Location) {
+        if let mir::StatementKind::FakeRead(mir::FakeReadCause::ForLet, _) = statement.kind {
+            return;
+        }
+
+        self.super_statement(statement, location);
+    }
+
+    fn visit_local(&mut self, &local: &Local, context: PlaceContext, location: Location) {
+        trace!("visit_local({:?}, {:?}, {:?})", local, context, location);
+
+        if !context.is_write_only() {
+            return;
+        }
+
+        self.written.insert(local);
+
+        if !self.used.contains(local) || !self.should_lint(local) {
+            return;
+        }
+
+        // Bindings in match arms with guards are lowered to two separate `Local`s, one for inside
+        // the guard (the "guard local") and one for inside the match arm body (the "match arm
+        // local"). Both of these are assigned a value unconditionally in the lowered MIR. This
+        // means that, if the binding is only used inside the guard, we will see an assignment to
+        // the match arm local with no subsequent use.
+        //
+        //      match x {
+        //          x if x > 0 => true,
+        //          _ => false,
+        //      }
+        //
+        // We mustn't lint in this case because `x` is indeed used. To detect this, we depend on
+        // the fact that MIR lowering inserts the possibly useless assignment to the match arm
+        // local immediately after its `StorageLive` declaration. We ignore that first assignment
+        // of the match arm local if the same variable has a guard local that is used. This ensures
+        // that we continue to lint for *subsequent* unused assignments, such as the one in the
+        // following example.
+        //
+        //      match x {
+        //          mut x if x > 0 => { x = 4; } // `x = 4` is dead
+        //          _ => {}
+        //      }
+        //
+        if let Some(counterpart) = self.user_var(local).and_then(Variable::counterpart_in_guard) {
+            if self.used.contains(counterpart) {
+                let block_data = &self.body[location.block];
+
+                let is_first_assign_after_storage_live = (0..location.statement_index)
+                    .rev()
+                    .map(|idx| &block_data.statements[idx].kind)
+                    .take_while(|&stmt| !is_assign_to_local(stmt, local))
+                    .find(|stmt| matches!(stmt, mir::StatementKind::StorageLive(l) if *l == local))
+                    .is_some();
+
+                if is_first_assign_after_storage_live {
+                    return;
+                }
+            }
+        }
+
+        let term = self.body[location.block].terminator();
+        let call_return_succ = match term.kind {
+            mir::TerminatorKind::Call { destination: Some((_, dest)), .. }
+                if context == PlaceContext::MutatingUse(MutatingUseContext::Call) =>
+            {
+                Some(dest)
+            }
+
+            _ => None,
+        };
+
+        // Any edge-specific terminator effects, such as the one for a successful function call,
+        // are already applied by the time we store the entry set. Because of this, we need to look
+        // at the dataflow state at the exit (before the first statement in backward dataflow) of
+        // the call-return block to see if the call return place is live prior to its assignment.
+        if let Some(call_return_succ) = call_return_succ {
+            self.live.seek_to_block_start(call_return_succ);
+        } else {
+            self.live.seek_before_primary_effect(location);
+        }
+
+        if !self.live.contains(local) {
+            self.lint_unused_assign(local, location);
+        }
+    }
+}
+
+struct UsedLocals(BitSet<Local>);
+
+impl UsedLocals {
+    fn in_body(body: &mir::Body<'_>) -> Self {
+        let mut ret = UsedLocals(BitSet::new_empty(body.local_decls.len()));
+        ret.visit_body(body);
+        ret
+    }
+}
+
+impl Visitor<'tcx> for UsedLocals {
+    fn visit_statement(&mut self, statement: &mir::Statement<'tcx>, location: Location) {
+        // Ignore `FakeRead`s for `let` bindings.
+        if let mir::StatementKind::FakeRead(mir::FakeReadCause::ForLet, _) = statement.kind {
+            return;
+        }
+
+        self.super_statement(statement, location);
+    }
+
+    fn visit_local(&mut self, &local: &Local, context: PlaceContext, location: Location) {
+        trace!("visit_local({:?}, {:?}, {:?})", local, context, location);
+
+        if context.is_read() {
+            self.0.insert(local);
+        }
+    }
+}
+
+fn is_assign_to_local(stmt: &mir::StatementKind<'tcx>, local: Local) -> bool {
+    matches!(stmt, mir::StatementKind::Assign(box (lhs, _)) if lhs.local == local)
+}

src/librustc_passes/lib.rs

@@ -28,7 +28,6 @@ mod intrinsicck;
 mod lang_items;
 pub mod layout_test;
 mod lib_features;
-mod liveness;
 pub mod loops;
 mod reachable;
 mod region;
@@ -44,7 +43,6 @@ pub fn provide(providers: &mut Providers<'_>) {
     lang_items::provide(providers);
     lib_features::provide(providers);
     loops::provide(providers);
-    liveness::provide(providers);
     intrinsicck::provide(providers);
     reachable::provide(providers);
     region::provide(providers);

src/librustc_session/lint.rs

@@ -8,7 +8,7 @@ use rustc_span::{sym, symbol::Ident, MultiSpan, Span, Symbol};
 pub mod builtin;
 
 /// Setting for how to handle a lint.
-#[derive(Clone, Copy, PartialEq, PartialOrd, Eq, Ord, Debug, Hash)]
+#[derive(Clone, Copy, PartialEq, PartialOrd, Eq, Ord, Debug, Hash, RustcEncodable, RustcDecodable)]
 pub enum Level {
     Allow,
     Warn,

src/test/ui/liveness/liveness-dead.rs

@@ -36,4 +36,22 @@ fn f6() {
     }
 }
 
+fn f7(x: i32) {
+    match x {
+        n if n > 22 => {} // no error
+        _ => {}
+    }
+}
+
+fn f8(x: Option<i32>) -> i32 {
+    match x {
+        None => 0,
+        Some(mut n) => {
+            //~^ ERROR: value assigned to `n` is never read
+            n = 42;
+            n
+        }
+    }
+}
+
 fn main() {}