Perform unused assignment and unused variables lints on MIR.

compiler/rustc_borrowck/src/diagnostics/move_errors.rs

@@ -134,9 +134,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
  // whether or not the right-hand side is a place expression
  if let LocalInfo::User(BindingForm::Var(VarBindingForm {
  opt_match_place: Some((opt_match_place, match_span)),
- binding_mode: _,
- opt_ty_info: _,
- pat_span: _,
+ ..
  })) = *local_decl.local_info()
  {
  let stmt_source_info = self.body.source_info(location);

compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs

@@ -305,8 +305,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
  LocalInfo::User(BindingForm::Var(mir::VarBindingForm {
  binding_mode: BindingAnnotation(ByRef::No, Mutability::Not),
  opt_ty_info: Some(sp),
- opt_match_place: _,
- pat_span: _,
+ ..
  })) => {
  if suggest {
  err.span_note(sp, "the binding is already a mutable borrow");
@@ -729,6 +728,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
  opt_ty_info: _,
  opt_match_place: _,
  pat_span,
+ introductions: _,
  })) => pat_span,
  _ => local_decl.source_info.span,
  };

compiler/rustc_interface/src/passes.rs

@@ -749,6 +749,7 @@ fn analysis(tcx: TyCtxt<'_>, (): ()) -> Result<()> {
  sess.time("MIR_effect_checking", || {
  for def_id in tcx.hir().body_owners() {
  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

@@ -999,6 +999,8 @@ pub struct VarBindingForm<'tcx> {
  pub opt_match_place: Option<(Option<Place<'tcx>>, Span)>,
  /// The span of the pattern in which this variable was bound.
  pub pat_span: Span,
+ /// For each introduction place, record here the span and whether this was a shorthand pattern.
+ pub introductions: Vec<(Span, /* is_shorthand */ bool)>,
 }
 
 #[derive(Clone, Debug, TyEncodable, TyDecodable)]
@@ -1008,7 +1010,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),
 }
 
 TrivialTypeTraversalImpls! { BindingForm<'tcx> }
@@ -1025,7 +1027,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),
  }
  }
  }
@@ -1208,9 +1210,7 @@ impl<'tcx> LocalDecl<'tcx> {
  LocalInfo::User(
  BindingForm::Var(VarBindingForm {
  binding_mode: BindingAnnotation(ByRef::No, _),
- opt_ty_info: _,
- opt_match_place: _,
- pat_span: _,
+ ..
  }) | BindingForm::ImplicitSelf(ImplicitSelfKind::Imm),
  )
  )
@@ -1225,9 +1225,7 @@ impl<'tcx> LocalDecl<'tcx> {
  LocalInfo::User(
  BindingForm::Var(VarBindingForm {
  binding_mode: BindingAnnotation(ByRef::No, _),
- opt_ty_info: _,
- opt_match_place: _,
- pat_span: _,
+ ..
  }) | BindingForm::ImplicitSelf(_),
  )
  )
@@ -1244,7 +1242,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

compiler/rustc_middle/src/mir/statement.rs

@@ -50,7 +50,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,
 

compiler/rustc_middle/src/query/mod.rs

@@ -943,8 +943,10 @@ rustc_queries! {
  desc { |tcx| "checking privacy in {}", describe_as_module(key.to_local_def_id(), 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_middle/src/thir.rs

@@ -738,6 +738,7 @@ pub enum PatKind<'tcx> {
  /// Is this the leftmost occurrence of the binding, i.e., is `var` the
  /// `HirId` of this pattern?
  is_primary: bool,
+ is_shorthand: bool,
  },
 
  /// `Foo(...)` or `Foo{...}` or `Foo`, where `Foo` is a variant name from an ADT with

compiler/rustc_middle/src/ty/closure.rs

@@ -325,6 +325,8 @@ pub fn place_to_string_for_capture<'tcx>(tcx: TyCtxt<'tcx>, place: &HirPlace<'tc
  )
  }
  },
+ // Just change the type to the hidden type, so we can actually project.
+ HirProjectionKind::OpaqueCast => {}
  proj => bug!("{:?} unexpected because it isn't captured", proj),
  }
  }

compiler/rustc_mir_build/src/build/block.rs

@@ -204,6 +204,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
  block,
  node,
  span,
+ false,
  OutsideGuard,
  true,
  );
@@ -290,7 +291,14 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
  pattern,
  UserTypeProjections::none(),
  &mut |this, _, _, node, span, _, _| {
- this.storage_live_binding(block, node, span, OutsideGuard, true);
+ this.storage_live_binding(
+ block,
+ node,
+ span,
+ false,
+ OutsideGuard,
+ true,
+ );
  this.schedule_drop_for_binding(node, span, OutsideGuard);
  },
  )

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

@@ -627,8 +627,14 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
  subpattern: None,
  ..
  } => {
- let place =
- self.storage_live_binding(block, var, irrefutable_pat.span, OutsideGuard, true);
+ let place = self.storage_live_binding(
+ block,
+ var,
+ irrefutable_pat.span,
+ false,
+ OutsideGuard,
+ true,
+ );
  unpack!(block = self.expr_into_dest(place, block, initializer_id));
 
  // Inject a fake read, see comments on `FakeReadCause::ForLet`.
@@ -661,8 +667,14 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
  },
  ascription: thir::Ascription { ref annotation, variance: _ },
  } => {
- let place =
- self.storage_live_binding(block, var, irrefutable_pat.span, OutsideGuard, true);
+ let place = self.storage_live_binding(
+ block,
+ var,
+ irrefutable_pat.span,
+ false,
+ OutsideGuard,
+ true,
+ );
  unpack!(block = self.expr_into_dest(place, block, initializer_id));
 
  // Inject a fake read, see comments on `FakeReadCause::ForLet`.
@@ -855,6 +867,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
  block: BasicBlock,
  var: LocalVarId,
  span: Span,
+ is_shorthand: bool,
  for_guard: ForGuard,
  schedule_drop: bool,
  ) -> Place<'tcx> {
@@ -868,6 +881,10 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
  {
  self.schedule_drop(span, region_scope, local_id, DropKind::Storage);
  }
+ let local_info = self.local_decls[local_id].local_info.as_mut().assert_crate_local();
+ if let LocalInfo::User(BindingForm::Var(var_info)) = &mut **local_info {
+ var_info.introductions.push((span, is_shorthand));
+ }
  Place::from(local_id)
  }
 
@@ -1149,6 +1166,7 @@ struct Binding<'tcx> {
  source: Place<'tcx>,
  var_id: LocalVarId,
  binding_mode: BindingAnnotation,
+ is_shorthand: bool,
 }
 
 /// Indicates that the type of `source` must be a subtype of the
@@ -2332,6 +2350,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
  block,
  binding.var_id,
  binding.span,
+ binding.is_shorthand,
  RefWithinGuard,
  schedule_drops,
  );
@@ -2345,6 +2364,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
  block,
  binding.var_id,
  binding.span,
+ binding.is_shorthand,
  OutsideGuard,
  schedule_drops,
  );
@@ -2384,6 +2404,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
  block,
  binding.var_id,
  binding.span,
+ binding.is_shorthand,
  OutsideGuard,
  schedule_drops,
  )
@@ -2437,6 +2458,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
  opt_ty_info: None,
  opt_match_place,
  pat_span,
+ introductions: Vec::new(),
  },
  )))),
  };
@@ -2457,7 +2479,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
  user_ty: None,
  source_info,
  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/matches/util.rs

@@ -154,12 +154,13 @@ impl<'pat, 'tcx> MatchPair<'pat, 'tcx> {
  TestCase::Irrefutable { ascription, binding: None }
  }
 
- PatKind::Binding { mode, var, ref subpattern, .. } => {
+ PatKind::Binding { mode, var, ref subpattern, is_shorthand, .. } => {
  let binding = place.map(|source| super::Binding {
  span: pattern.span,
  source,
  var_id: var,
  binding_mode: mode,
+ is_shorthand,
  });
 
  if let Some(subpattern) = subpattern.as_ref() {

compiler/rustc_mir_build/src/build/mod.rs

@@ -60,12 +60,6 @@ pub(crate) fn mir_build<'tcx>(tcx: TyCtxtAt<'tcx>, def: LocalDefId) -> Body<'tcx
  thir::BodyTy::Const(ty) => construct_const(tcx, def, thir, expr, ty),
  };
 
- // 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);
-
  // Don't steal here, instead steal in unsafeck. This is so that
  // pattern inline constants can be evaluated as part of building the
  // THIR of the parent function without a cycle.
@@ -947,6 +941,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
  opt_ty_info: param.ty_span,
  opt_match_place: Some((None, span)),
  pat_span: span,
+ introductions: vec![(span, false)],
  }))
  };
  self.var_indices.insert(var, LocalsForNode::One(local));

compiler/rustc_mir_build/src/thir/pattern/mod.rs

@@ -311,6 +311,7 @@ impl<'a, 'tcx> PatCtxt<'a, 'tcx> {
  ty: var_ty,
  subpattern: self.lower_opt_pattern(sub),
  is_primary: id == pat.hir_id,
+ is_shorthand: false,
  }
  }
 
@@ -328,9 +329,13 @@ impl<'a, 'tcx> PatCtxt<'a, 'tcx> {
  let res = self.typeck_results.qpath_res(qpath, pat.hir_id);
  let subpatterns = fields
  .iter()
- .map(|field| FieldPat {
- field: self.typeck_results.field_index(field.hir_id),
- pattern: self.lower_pattern(field.pat),
+ .map(|field| {
+ let mut pattern = self.lower_pattern(field.pat);
+ if let PatKind::Binding { ref mut is_shorthand, .. } = pattern.kind {
+ *is_shorthand = field.is_shorthand;
+ }
+ let field = self.typeck_results.field_index(field.hir_id);
+ FieldPat { field, pattern }
  })
  .collect();
 

compiler/rustc_mir_build/src/thir/print.rs

@@ -635,13 +635,14 @@ impl<'a, 'tcx> ThirPrinter<'a, 'tcx> {
  self.print_pat(subpattern, depth_lvl + 3);
  print_indented!(self, "}", depth_lvl + 1);
  }
- PatKind::Binding { name, mode, var, ty, subpattern, is_primary } => {
+ PatKind::Binding { name, mode, var, ty, subpattern, is_primary, is_shorthand } => {
  print_indented!(self, "Binding {", depth_lvl + 1);
  print_indented!(self, format!("name: {:?}", name), depth_lvl + 2);
  print_indented!(self, format!("mode: {:?}", mode), depth_lvl + 2);
  print_indented!(self, format!("var: {:?}", var), depth_lvl + 2);
  print_indented!(self, format!("ty: {:?}", ty), depth_lvl + 2);
  print_indented!(self, format!("is_primary: {:?}", is_primary), depth_lvl + 2);
+ print_indented!(self, format!("is_shorthand: {:?}", is_shorthand), depth_lvl + 2);
 
  if let Some(subpattern) = subpattern {
  print_indented!(self, "subpattern: Some( ", depth_lvl + 2);

compiler/rustc_mir_dataflow/src/lib.rs

@@ -17,10 +17,11 @@ pub use self::drop_flag_effects::{
  drop_flag_effects_for_function_entry, drop_flag_effects_for_location,
  move_path_children_matching, on_all_children_bits, on_lookup_result_bits,
 };
+use self::framework::SwitchIntEdgeEffects;
 pub use self::framework::{
  fmt, graphviz, lattice, visit_results, Analysis, AnalysisDomain, Backward, Direction, Engine,
  Forward, GenKill, GenKillAnalysis, JoinSemiLattice, MaybeReachable, Results, ResultsCursor,
- ResultsVisitable, ResultsVisitor, SwitchIntEdgeEffects,
+ ResultsVisitable, ResultsVisitor,
 };
 use self::move_paths::MoveData;
 

compiler/rustc_mir_transform/messages.ftl

@@ -17,13 +17,37 @@ mir_transform_ffi_unwind_call = call to {$foreign ->
 mir_transform_fn_item_ref = taking a reference to a function item does not give a function pointer
  .suggestion = cast `{$ident}` to obtain a function pointer
 
+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}
  .help = consider using a block (`{"{ ... }"}`) to shrink the value's scope, ending before the suspend point
 mir_transform_operation_will_panic = this operation will panic at runtime
 
+mir_transform_string_interpolation_only_works = string interpolation only works in `format!` invocations
+
 mir_transform_unaligned_packed_ref = reference to packed field is unaligned
  .note = packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
  .note_ub = creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
  .help = copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
+
+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_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_args_in_macro = `{$name}` is captured in macro and introduced a unused variable
+
+mir_transform_unused_variable_try_ignore = try ignoring the field