Diagnose liveness on MIR.

Author: cjgillot

compiler/rustc_interface/src/passes.rs

@@ -798,6 +798,7 @@ fn analysis(tcx: TyCtxt<'_>, (): ()) -> Result<()> {
                 rustc_mir_transform::check_unsafety::check_unsafety(tcx, def_id);
             }
             tcx.ensure().has_ffi_unwind_calls(def_id);
+            tcx.ensure().check_liveness(def_id);
 
             // If we need to codegen, ensure that we emit all errors from
             // `mir_drops_elaborated_and_const_checked` now, to avoid discovering

compiler/rustc_middle/src/mir/mod.rs

@@ -705,7 +705,7 @@ pub enum BindingForm<'tcx> {
     /// Binding for a `self`/`&self`/`&mut self` binding where the type is implicit.
     ImplicitSelf(ImplicitSelfKind),
     /// Reference used in a guard expression to ensure immutability.
-    RefForGuard,
+    RefForGuard(Local),
 }
 
 TrivialTypeTraversalAndLiftImpls! {
@@ -724,7 +724,7 @@ mod binding_form_impl {
             match self {
                 Var(binding) => binding.hash_stable(hcx, hasher),
                 ImplicitSelf(kind) => kind.hash_stable(hcx, hasher),
-                RefForGuard => (),
+                RefForGuard(local) => local.hash_stable(hcx, hasher),
             }
         }
     }
@@ -955,7 +955,7 @@ impl<'tcx> LocalDecl<'tcx> {
     /// expression that is used to access said variable for the guard of the
     /// match arm.
     pub fn is_ref_for_guard(&self) -> bool {
-        matches!(self.local_info(), LocalInfo::User(BindingForm::RefForGuard))
+        matches!(self.local_info(), LocalInfo::User(BindingForm::RefForGuard(_)))
     }
 
     /// Returns `Some` if this is a reference to a static item that is used to
@@ -1519,7 +1519,7 @@ impl<'tcx> StatementKind<'tcx> {
 impl<V, T> ProjectionElem<V, T> {
     /// Returns `true` if the target of this projection may refer to a different region of memory
     /// than the base.
-    fn is_indirect(&self) -> bool {
+    pub fn is_indirect(&self) -> bool {
         match self {
             Self::Deref => true,
 
@@ -1574,7 +1574,7 @@ impl<V, T> ProjectionElem<V, T> {
 /// need neither the `V` parameter for `Index` nor the `T` for `Field`.
 pub type ProjectionKind = ProjectionElem<(), ()>;
 
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash)]
 pub struct PlaceRef<'tcx> {
     pub local: Local,
     pub projection: &'tcx [PlaceElem<'tcx>],
@@ -1661,6 +1661,13 @@ impl From<Local> for Place<'_> {
     }
 }
 
+impl From<Local> for PlaceRef<'_> {
+    #[inline]
+    fn from(local: Local) -> Self {
+        PlaceRef { local, projection: List::empty() }
+    }
+}
+
 impl<'tcx> PlaceRef<'tcx> {
     /// Finds the innermost `Local` from this `Place`, *if* it is either a local itself or
     /// a single deref of a local.
@@ -1746,7 +1753,13 @@ impl<'tcx> PlaceRef<'tcx> {
 
 impl Debug for Place<'_> {
     fn fmt(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
-        for elem in self.projection.iter().rev() {
+        Debug::fmt(&self.as_ref(), fmt)
+    }
+}
+
+impl Debug for PlaceRef<'_> {
+    fn fmt(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
+        for &elem in self.projection.iter().rev() {
             match elem {
                 ProjectionElem::OpaqueCast(_)
                 | ProjectionElem::Downcast(_, _)
@@ -1764,7 +1777,7 @@ impl Debug for Place<'_> {
 
         write!(fmt, "{:?}", self.local)?;
 
-        for elem in self.projection.iter() {
+        for &elem in self.projection.iter() {
             match elem {
                 ProjectionElem::OpaqueCast(ty) => {
                     write!(fmt, " as {})", ty)?;

compiler/rustc_middle/src/query/mod.rs

@@ -930,8 +930,10 @@ rustc_queries! {
         desc { |tcx| "checking privacy in {}", describe_as_module(key, tcx) }
     }
 
-    query check_liveness(key: LocalDefId) {
-        desc { |tcx| "checking liveness of variables in `{}`", tcx.def_path_str(key) }
+    query check_liveness(key: LocalDefId) -> &'tcx rustc_index::bit_set::BitSet<abi::FieldIdx> {
+        arena_cache
+        desc { |tcx| "checking liveness of variables in `{}`", tcx.def_path_str(key.to_def_id()) }
+        cache_on_disk_if(tcx) { tcx.is_typeck_child(key.to_def_id()) }
     }
 
     /// Return the live symbols in the crate for dead code check.

compiler/rustc_mir_build/src/build/matches/mod.rs

@@ -2277,7 +2277,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 source_info,
                 internal: false,
                 local_info: ClearCrossCrate::Set(Box::new(LocalInfo::User(
-                    BindingForm::RefForGuard,
+                    BindingForm::RefForGuard(for_arm_body),
                 ))),
             });
             self.var_debug_info.push(VarDebugInfo {

compiler/rustc_mir_build/src/build/mod.rs

@@ -69,11 +69,6 @@ fn mir_build(tcx: TyCtxt<'_>, def: LocalDefId) -> Body<'_> {
             let thir = thir.steal();
 
             tcx.ensure().check_match(def);
-            // this must run before MIR dump, because
-            // "not all control paths return a value" is reported here.
-            //
-            // maybe move the check to a MIR pass?
-            tcx.ensure().check_liveness(def);
 
             match thir.body_type {
                 thir::BodyTy::Fn(fn_sig) => construct_fn(tcx, def, &thir, expr, fn_sig),

compiler/rustc_mir_transform/messages.ftl

@@ -25,6 +25,9 @@ mir_transform_fn_item_ref = taking a reference to a function item does not give
 
 mir_transform_initializing_valid_range_label = initializing type with `rustc_layout_scalar_valid_range` attr
 mir_transform_initializing_valid_range_note = initializing a layout restricted type's field with a value outside the valid range is undefined behavior
+
+mir_transform_maybe_string_interpolation = you might have meant to use string interpolation in this string literal
+
 mir_transform_must_not_suspend = {$pre}`{$def_path}`{$post} held across a suspend point, but should not be
     .label = the value is held across this suspend point
     .note = {$reason}
@@ -44,6 +47,8 @@ mir_transform_requires_unsafe = {$details} is unsafe and requires unsafe {$op_in
 
 mir_transform_simd_shuffle_last_const = last argument of `simd_shuffle` is required to be a `const` item
 
+mir_transform_string_interpolation_only_works = string interpolation only works in `format!` invocations
+
 mir_transform_target_feature_call_label = call to function with `#[target_feature]`
 mir_transform_target_feature_call_note = can only be called if the required target features are available
 
@@ -58,9 +63,27 @@ mir_transform_unsafe_op_in_unsafe_fn = {$details} is unsafe and requires unsafe
     .suggestion = consider wrapping the function body in an unsafe block
     .note = an unsafe function restricts its caller, but its body is safe by default
 
+mir_transform_unused_assign = value assigned to `{$name}` is never read
+    .help = maybe it is overwritten before being read?
+
+mir_transform_unused_assign_passed = value passed to `{$name}` is never read
+    .help = maybe it is overwritten before being read?
+
+mir_transform_unused_capture_maybe_capture_ref = value captured by `{$name}` is never read
+    .help = did you mean to capture by reference instead?
+
 mir_transform_unused_unsafe = unnecessary `unsafe` block
     .label = because it's nested under this `unsafe` block
 
+mir_transform_unused_var_assigned_only = variable `{$name}` is assigned to, but never used
+    .note = consider using `_{$name}` instead
+
+mir_transform_unused_var_underscore = if this is intentional, prefix it with an underscore
+
+mir_transform_unused_variable = unused variable: `{$name}`
+
+mir_transform_unused_variable_try_ignore = try ignoring the field
+
 mir_transform_use_of_asm_label = use of inline assembly
 mir_transform_use_of_asm_note = inline assembly is entirely unchecked and can cause undefined behavior
 mir_transform_use_of_extern_static_label = use of extern static

compiler/rustc_mir_transform/src/errors.rs

@@ -1,6 +1,6 @@
 use rustc_errors::{
-    Applicability, DecorateLint, DiagnosticBuilder, DiagnosticMessage, EmissionGuarantee, Handler,
-    IntoDiagnostic,
+    AddToDiagnostic, Applicability, DecorateLint, Diagnostic, DiagnosticBuilder, DiagnosticMessage,
+    EmissionGuarantee, Handler, IntoDiagnostic,
 };
 use rustc_macros::{Diagnostic, LintDiagnostic, Subdiagnostic};
 use rustc_middle::mir::{AssertKind, UnsafetyViolationDetails};
@@ -237,6 +237,90 @@ pub(crate) struct FnItemRef {
     pub ident: String,
 }
 
+#[derive(LintDiagnostic)]
+#[diag(mir_transform_unused_capture_maybe_capture_ref)]
+#[help]
+pub(crate) struct UnusedCaptureMaybeCaptureRef {
+    pub name: String,
+}
+
+#[derive(LintDiagnostic)]
+#[diag(mir_transform_unused_var_assigned_only)]
+#[note]
+pub(crate) struct UnusedVarAssignedOnly {
+    pub name: String,
+}
+
+#[derive(LintDiagnostic)]
+#[diag(mir_transform_unused_assign)]
+#[help]
+pub(crate) struct UnusedAssign {
+    pub name: String,
+}
+
+#[derive(LintDiagnostic)]
+#[diag(mir_transform_unused_assign_passed)]
+#[help]
+pub(crate) struct UnusedAssignPassed {
+    pub name: String,
+}
+
+#[derive(LintDiagnostic)]
+#[diag(mir_transform_unused_variable)]
+pub(crate) struct UnusedVariable {
+    pub name: String,
+    #[subdiagnostic]
+    pub string_interp: Vec<UnusedVariableStringInterp>,
+    #[subdiagnostic]
+    pub sugg: UnusedVariableSugg,
+}
+
+#[derive(Subdiagnostic)]
+pub(crate) enum UnusedVariableSugg {
+    #[multipart_suggestion(
+        mir_transform_unused_variable_try_ignore,
+        applicability = "machine-applicable"
+    )]
+    TryIgnore {
+        #[suggestion_part(code = "{name}: _")]
+        shorthands: Vec<Span>,
+        #[suggestion_part(code = "_")]
+        non_shorthands: Vec<Span>,
+        name: String,
+    },
+
+    #[multipart_suggestion(
+        mir_transform_unused_var_underscore,
+        applicability = "machine-applicable"
+    )]
+    TryPrefix {
+        #[suggestion_part(code = "_{name}")]
+        spans: Vec<Span>,
+        name: String,
+    },
+}
+
+pub(crate) struct UnusedVariableStringInterp {
+    pub lit: Span,
+}
+
+impl AddToDiagnostic for UnusedVariableStringInterp {
+    fn add_to_diagnostic_with<F>(self, diag: &mut Diagnostic, _: F) {
+        diag.span_label(
+            self.lit,
+            crate::fluent_generated::mir_transform_maybe_string_interpolation,
+        );
+        diag.multipart_suggestion(
+            crate::fluent_generated::mir_transform_string_interpolation_only_works,
+            vec![
+                (self.lit.shrink_to_lo(), String::from("format!(")),
+                (self.lit.shrink_to_hi(), String::from(")")),
+            ],
+            Applicability::MachineApplicable,
+        );
+    }
+}
+
 #[derive(LintDiagnostic)]
 #[diag(mir_transform_must_not_suspend)]
 pub(crate) struct MustNotSupend<'a> {

compiler/rustc_mir_transform/src/lib.rs

@@ -78,6 +78,7 @@ mod generator;
 mod inline;
 mod instsimplify;
 mod large_enums;
+mod liveness;
 mod lower_intrinsics;
 mod lower_slice_len;
 mod match_branches;
@@ -105,6 +106,7 @@ mod sroa;
 mod uninhabited_enum_branching;
 mod unreachable_prop;
 
+use liveness::check_liveness;
 use rustc_const_eval::transform::check_consts::{self, ConstCx};
 use rustc_const_eval::transform::promote_consts;
 use rustc_const_eval::transform::validate;
@@ -129,6 +131,7 @@ pub fn provide(providers: &mut Providers) {
         mir_for_ctfe,
         mir_generator_witnesses: generator::mir_generator_witnesses,
         optimized_mir,
+        check_liveness,
         is_mir_available,
         is_ctfe_mir_available: |tcx, did| is_mir_available(tcx, did),
         mir_callgraph_reachable: inline::cycle::mir_callgraph_reachable,
@@ -394,6 +397,8 @@ fn mir_drops_elaborated_and_const_checked(tcx: TyCtxt<'_>, def: LocalDefId) -> &
         }
     }
 
+    tcx.ensure_with_value().check_liveness(def);
+
     let (body, _) = tcx.mir_promoted(def);
     let mut body = body.steal();
     if let Some(error_reported) = mir_borrowck.tainted_by_errors {