rename BorrowKind::Shallow to Fake

also adds some comments

compiler/rustc_borrowck/src/borrow_set.rs

@@ -71,7 +71,7 @@ impl<'tcx> fmt::Display for BorrowData<'tcx> {
  fn fmt(&self, w: &mut fmt::Formatter<'_>) -> fmt::Result {
  let kind = match self.kind {
  mir::BorrowKind::Shared => "",
- mir::BorrowKind::Shallow => "shallow ",
+ mir::BorrowKind::Fake => "fake ",
  mir::BorrowKind::Mut { kind: mir::MutBorrowKind::ClosureCapture } => "uniq ",
  // FIXME: differentiate `TwoPhaseBorrow`
  mir::BorrowKind::Mut {

compiler/rustc_borrowck/src/def_use.rs

@@ -49,7 +49,7 @@ pub fn categorize(context: PlaceContext) -> Option<DefUse> {
  // cross suspension points so this behavior is unproblematic.
  PlaceContext::MutatingUse(MutatingUseContext::Borrow) |
  PlaceContext::NonMutatingUse(NonMutatingUseContext::SharedBorrow) |
- PlaceContext::NonMutatingUse(NonMutatingUseContext::ShallowBorrow) |
+ PlaceContext::NonMutatingUse(NonMutatingUseContext::FakeBorrow) |
 
  // `PlaceMention` and `AscribeUserType` both evaluate the place, which must not
  // contain dangling references.

compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs

@@ -1022,7 +1022,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
  self.cannot_uniquely_borrow_by_two_closures(span, &desc_place, issued_span, None)
  }
 
- (BorrowKind::Mut { .. }, BorrowKind::Shallow) => {
+ (BorrowKind::Mut { .. }, BorrowKind::Fake) => {
  if let Some(immutable_section_description) =
  self.classify_immutable_section(issued_borrow.assigned_place)
  {
@@ -1114,11 +1114,10 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
  )
  }
 
- (BorrowKind::Shared, BorrowKind::Shared | BorrowKind::Shallow)
- | (
- BorrowKind::Shallow,
- BorrowKind::Mut { .. } | BorrowKind::Shared | BorrowKind::Shallow,
- ) => unreachable!(),
+ (BorrowKind::Shared, BorrowKind::Shared | BorrowKind::Fake)
+ | (BorrowKind::Fake, BorrowKind::Mut { .. } | BorrowKind::Shared | BorrowKind::Fake) => {
+ unreachable!()
+ }
  };
 
  if issued_spans == borrow_spans {
@@ -2806,7 +2805,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
  let loan_span = loan_spans.args_or_use();
 
  let descr_place = self.describe_any_place(place.as_ref());
- if loan.kind == BorrowKind::Shallow {
+ if loan.kind == BorrowKind::Fake {
  if let Some(section) = self.classify_immutable_section(loan.assigned_place) {
  let mut err = self.cannot_mutate_in_immutable_section(
  span,

compiler/rustc_borrowck/src/diagnostics/mod.rs

@@ -634,7 +634,7 @@ impl UseSpans<'_> {
  err.subdiagnostic(match kind {
  Some(kd) => match kd {
  rustc_middle::mir::BorrowKind::Shared
- | rustc_middle::mir::BorrowKind::Shallow => {
+ | rustc_middle::mir::BorrowKind::Fake => {
  CaptureVarKind::Immut { kind_span: capture_kind_span }
  }
 

compiler/rustc_borrowck/src/invalidation.rs

@@ -253,8 +253,8 @@ impl<'cx, 'tcx> InvalidationGenerator<'cx, 'tcx> {
  match rvalue {
  &Rvalue::Ref(_ /*rgn*/, bk, place) => {
  let access_kind = match bk {
- BorrowKind::Shallow => {
- (Shallow(Some(ArtificialField::ShallowBorrow)), Read(ReadKind::Borrow(bk)))
+ BorrowKind::Fake => {
+ (Shallow(Some(ArtificialField::FakeBorrow)), Read(ReadKind::Borrow(bk)))
  }
  BorrowKind::Shared => (Deep, Read(ReadKind::Borrow(bk))),
  BorrowKind::Mut { .. } => {
@@ -376,8 +376,8 @@ impl<'cx, 'tcx> InvalidationGenerator<'cx, 'tcx> {
  // have already taken the reservation
  }
 
- (Read(_), BorrowKind::Shallow | BorrowKind::Shared)
- | (Read(ReadKind::Borrow(BorrowKind::Shallow)), BorrowKind::Mut { .. }) => {
+ (Read(_), BorrowKind::Fake | BorrowKind::Shared)
+ | (Read(ReadKind::Borrow(BorrowKind::Fake)), BorrowKind::Mut { .. }) => {
  // Reads don't invalidate shared or shallow borrows
  }
 
@@ -422,7 +422,7 @@ impl<'cx, 'tcx> InvalidationGenerator<'cx, 'tcx> {
 
  // only mutable borrows should be 2-phase
  assert!(match borrow.kind {
- BorrowKind::Shared | BorrowKind::Shallow => false,
+ BorrowKind::Shared | BorrowKind::Fake => false,
  BorrowKind::Mut { .. } => true,
  });
 

compiler/rustc_borrowck/src/lib.rs

@@ -846,7 +846,7 @@ use self::ReadOrWrite::{Activation, Read, Reservation, Write};
 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
 enum ArtificialField {
  ArrayLength,
- ShallowBorrow,
+ FakeBorrow,
 }
 
 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
@@ -1085,18 +1085,18 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
  Control::Continue
  }
 
- (Read(_), BorrowKind::Shared | BorrowKind::Shallow)
- | (Read(ReadKind::Borrow(BorrowKind::Shallow)), BorrowKind::Mut { .. }) => {
+ (Read(_), BorrowKind::Shared | BorrowKind::Fake)
+ | (Read(ReadKind::Borrow(BorrowKind::Fake)), BorrowKind::Mut { .. }) => {
  Control::Continue
  }
 
- (Reservation(_), BorrowKind::Shallow | BorrowKind::Shared) => {
+ (Reservation(_), BorrowKind::Fake | BorrowKind::Shared) => {
  // This used to be a future compatibility warning (to be
  // disallowed on NLL). See rust-lang/rust#56254
  Control::Continue
  }
 
- (Write(WriteKind::Move), BorrowKind::Shallow) => {
+ (Write(WriteKind::Move), BorrowKind::Fake) => {
  // Handled by initialization checks.
  Control::Continue
  }
@@ -1204,8 +1204,8 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
  match rvalue {
  &Rvalue::Ref(_ /*rgn*/, bk, place) => {
  let access_kind = match bk {
- BorrowKind::Shallow => {
- (Shallow(Some(ArtificialField::ShallowBorrow)), Read(ReadKind::Borrow(bk)))
+ BorrowKind::Fake => {
+ (Shallow(Some(ArtificialField::FakeBorrow)), Read(ReadKind::Borrow(bk)))
  }
  BorrowKind::Shared => (Deep, Read(ReadKind::Borrow(bk))),
  BorrowKind::Mut { .. } => {
@@ -1226,7 +1226,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
  flow_state,
  );
 
- let action = if bk == BorrowKind::Shallow {
+ let action = if bk == BorrowKind::Fake {
  InitializationRequiringAction::MatchOn
  } else {
  InitializationRequiringAction::Borrow
@@ -1583,7 +1583,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
 
  // only mutable borrows should be 2-phase
  assert!(match borrow.kind {
- BorrowKind::Shared | BorrowKind::Shallow => false,
+ BorrowKind::Shared | BorrowKind::Fake => false,
  BorrowKind::Mut { .. } => true,
  });
 
@@ -2142,14 +2142,14 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
  | WriteKind::Replace
  | WriteKind::StorageDeadOrDrop
  | WriteKind::MutableBorrow(BorrowKind::Shared)
- | WriteKind::MutableBorrow(BorrowKind::Shallow),
+ | WriteKind::MutableBorrow(BorrowKind::Fake),
  )
  | Write(
  WriteKind::Move
  | WriteKind::Replace
  | WriteKind::StorageDeadOrDrop
  | WriteKind::MutableBorrow(BorrowKind::Shared)
- | WriteKind::MutableBorrow(BorrowKind::Shallow),
+ | WriteKind::MutableBorrow(BorrowKind::Fake),
  ) => {
  if self.is_mutable(place.as_ref(), is_local_mutation_allowed).is_err()
  && !self.has_buffered_errors()
@@ -2173,7 +2173,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
  return false;
  }
  Read(
- ReadKind::Borrow(BorrowKind::Mut { .. } | BorrowKind::Shared | BorrowKind::Shallow)
+ ReadKind::Borrow(BorrowKind::Mut { .. } | BorrowKind::Shared | BorrowKind::Fake)
  | ReadKind::Copy,
  ) => {
  // Access authorized

compiler/rustc_borrowck/src/places_conflict.rs

@@ -204,7 +204,7 @@ fn place_components_conflict<'tcx>(
 
  match (elem, &base_ty.kind(), access) {
  (_, _, Shallow(Some(ArtificialField::ArrayLength)))
- | (_, _, Shallow(Some(ArtificialField::ShallowBorrow))) => {
+ | (_, _, Shallow(Some(ArtificialField::FakeBorrow))) => {
  // The array length is like additional fields on the
  // type; it does not overlap any existing data there.
  // Furthermore, if cannot actually be a prefix of any
@@ -273,10 +273,10 @@ fn place_components_conflict<'tcx>(
  // If the second example, where we did, then we still know
  // that the borrow can access a *part* of our place that
  // our access cares about, so we still have a conflict.
- if borrow_kind == BorrowKind::Shallow
+ if borrow_kind == BorrowKind::Fake
  && borrow_place.projection.len() < access_place.projection.len()
  {
- debug!("borrow_conflicts_with_place: shallow borrow");
+ debug!("borrow_conflicts_with_place: fake borrow");
  false
  } else {
  debug!("borrow_conflicts_with_place: full borrow, CONFLICT");

compiler/rustc_borrowck/src/type_check/mod.rs

@@ -751,7 +751,7 @@ impl<'a, 'b, 'tcx> TypeVerifier<'a, 'b, 'tcx> {
  PlaceContext::MutatingUse(_) => ty::Invariant,
  PlaceContext::NonUse(StorageDead | StorageLive | VarDebugInfo) => ty::Invariant,
  PlaceContext::NonMutatingUse(
- Inspect | Copy | Move | PlaceMention | SharedBorrow | ShallowBorrow | AddressOf
+ Inspect | Copy | Move | PlaceMention | SharedBorrow | FakeBorrow | AddressOf
  | Projection,
  ) => ty::Covariant,
  PlaceContext::NonUse(AscribeUserTy(variance)) => variance,

compiler/rustc_codegen_ssa/src/mir/analyze.rs

@@ -219,7 +219,7 @@ impl<'mir, 'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> Visitor<'tcx>
  | PlaceContext::NonMutatingUse(
  NonMutatingUseContext::Inspect
  | NonMutatingUseContext::SharedBorrow
- | NonMutatingUseContext::ShallowBorrow
+ | NonMutatingUseContext::FakeBorrow
  | NonMutatingUseContext::AddressOf
  | NonMutatingUseContext::Projection,
  ) => {

compiler/rustc_const_eval/src/transform/check_consts/check.rs

@@ -423,8 +423,8 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
  BorrowKind::Shared => {
  PlaceContext::NonMutatingUse(NonMutatingUseContext::SharedBorrow)
  }
- BorrowKind::Shallow => {
- PlaceContext::NonMutatingUse(NonMutatingUseContext::ShallowBorrow)
+ BorrowKind::Fake => {
+ PlaceContext::NonMutatingUse(NonMutatingUseContext::FakeBorrow)
  }
  BorrowKind::Mut { .. } => {
  PlaceContext::MutatingUse(MutatingUseContext::Borrow)
@@ -500,7 +500,7 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
  self.check_mut_borrow(place.local, hir::BorrowKind::Raw)
  }
 
- Rvalue::Ref(_, BorrowKind::Shared | BorrowKind::Shallow, place)
+ Rvalue::Ref(_, BorrowKind::Shared | BorrowKind::Fake, place)
  | Rvalue::AddressOf(Mutability::Not, place) => {
  let borrowed_place_has_mut_interior = qualifs::in_place::<HasMutInterior, _>(
  &self.ccx,

compiler/rustc_const_eval/src/transform/check_consts/resolver.rs

@@ -105,7 +105,7 @@ where
  fn ref_allows_mutation(&self, kind: mir::BorrowKind, place: mir::Place<'tcx>) -> bool {
  match kind {
  mir::BorrowKind::Mut { .. } => true,
- mir::BorrowKind::Shared | mir::BorrowKind::Shallow => {
+ mir::BorrowKind::Shared | mir::BorrowKind::Fake => {
  self.shared_borrow_allows_mutation(place)
  }
  }

compiler/rustc_const_eval/src/transform/promote_consts.rs

@@ -456,7 +456,7 @@ impl<'tcx> Validator<'_, 'tcx> {
  match kind {
  // Reject these borrow types just to be safe.
  // FIXME(RalfJung): could we allow them? Should we? No point in it until we have a usecase.
- BorrowKind::Shallow | BorrowKind::Mut { kind: MutBorrowKind::ClosureCapture } => {
+ BorrowKind::Fake | BorrowKind::Mut { kind: MutBorrowKind::ClosureCapture } => {
  return Err(Unpromotable);
  }
 

compiler/rustc_const_eval/src/transform/validate.rs

@@ -848,11 +848,11 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
  }
  match rvalue {
  Rvalue::Use(_) | Rvalue::CopyForDeref(_) | Rvalue::Aggregate(..) => {}
- Rvalue::Ref(_, BorrowKind::Shallow, _) => {
+ Rvalue::Ref(_, BorrowKind::Fake, _) => {
  if self.mir_phase >= MirPhase::Runtime(RuntimePhase::Initial) {
  self.fail(
  location,
- "`Assign` statement with a `Shallow` borrow should have been removed in runtime MIR",
+ "`Assign` statement with a `Fake` borrow should have been removed in runtime MIR",
  );
  }
  }

compiler/rustc_middle/src/mir/pretty.rs

@@ -942,7 +942,7 @@ impl<'tcx> Debug for Rvalue<'tcx> {
  Ref(region, borrow_kind, ref place) => {
  let kind_str = match borrow_kind {
  BorrowKind::Shared => "",
- BorrowKind::Shallow => "shallow ",
+ BorrowKind::Fake => "fake ",
  BorrowKind::Mut { .. } => "mut ",
  };
 

compiler/rustc_middle/src/mir/statement.rs

@@ -446,15 +446,15 @@ impl<'tcx> Rvalue<'tcx> {
 impl BorrowKind {
  pub fn mutability(&self) -> Mutability {
  match *self {
- BorrowKind::Shared | BorrowKind::Shallow => Mutability::Not,
+ BorrowKind::Shared | BorrowKind::Fake => Mutability::Not,
  BorrowKind::Mut { .. } => Mutability::Mut,
  }
  }
 
  pub fn allows_two_phase_borrow(&self) -> bool {
  match *self {
  BorrowKind::Shared
- | BorrowKind::Shallow
+ | BorrowKind::Fake
  | BorrowKind::Mut { kind: MutBorrowKind::Default | MutBorrowKind::ClosureCapture } => {
  false
  }

compiler/rustc_middle/src/mir/syntax.rs

@@ -123,7 +123,7 @@ pub enum AnalysisPhase {
  /// * [`TerminatorKind::FalseEdge`]
  /// * [`StatementKind::FakeRead`]
  /// * [`StatementKind::AscribeUserType`]
- /// * [`Rvalue::Ref`] with `BorrowKind::Shallow`
+ /// * [`Rvalue::Ref`] with `BorrowKind::Fake`
  ///
  /// Furthermore, `Deref` projections must be the first projection within any place (if they
  /// appear at all)
@@ -182,7 +182,7 @@ pub enum BorrowKind {
  /// should not prevent `if let None = x { ... }`, for example, because the
  /// mutating `(*x as Some).0` can't affect the discriminant of `x`.
  /// We can also report errors with this kind of borrow differently.
- Shallow,
+ Fake,
 
  /// Data is mutable and not aliasable.
  Mut { kind: MutBorrowKind },

compiler/rustc_middle/src/mir/tcx.rs

@@ -278,7 +278,7 @@ impl BorrowKind {
 
  // We have no type corresponding to a shallow borrow, so use
  // `&` as an approximation.
- BorrowKind::Shallow => hir::Mutability::Not,
+ BorrowKind::Fake => hir::Mutability::Not,
  }
  }
 }

compiler/rustc_middle/src/mir/visit.rs

@@ -649,8 +649,8 @@ macro_rules! make_mir_visitor {
  BorrowKind::Shared => PlaceContext::NonMutatingUse(
  NonMutatingUseContext::SharedBorrow
  ),
- BorrowKind::Shallow => PlaceContext::NonMutatingUse(
- NonMutatingUseContext::ShallowBorrow
+ BorrowKind::Fake => PlaceContext::NonMutatingUse(
+ NonMutatingUseContext::FakeBorrow
  ),
  BorrowKind::Mut { .. } =>
  PlaceContext::MutatingUse(MutatingUseContext::Borrow),
@@ -1261,8 +1261,8 @@ pub enum NonMutatingUseContext {
  Move,
  /// Shared borrow.
  SharedBorrow,
- /// Shallow borrow.
- ShallowBorrow,
+ /// A fake borrow.
+ FakeBorrow,
  /// AddressOf for *const pointer.
  AddressOf,
  /// PlaceMention statement.
@@ -1341,7 +1341,7 @@ impl PlaceContext {
  matches!(
  self,
  PlaceContext::NonMutatingUse(
- NonMutatingUseContext::SharedBorrow | NonMutatingUseContext::ShallowBorrow
+ NonMutatingUseContext::SharedBorrow | NonMutatingUseContext::FakeBorrow
  ) | PlaceContext::MutatingUse(MutatingUseContext::Borrow)
  )
  }

compiler/rustc_mir_build/src/build/expr/as_place.rs

@@ -690,7 +690,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
  fake_borrow_temp.into(),
  Rvalue::Ref(
  tcx.lifetimes.re_erased,
- BorrowKind::Shallow,
+ BorrowKind::Fake,
  Place { local: base_place.local, projection },
  ),
  );

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

@@ -2021,7 +2021,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
  let re_erased = tcx.lifetimes.re_erased;
  let scrutinee_source_info = self.source_info(scrutinee_span);
  for &(place, temp) in fake_borrows {
- let borrow = Rvalue::Ref(re_erased, BorrowKind::Shallow, place);
+ let borrow = Rvalue::Ref(re_erased, BorrowKind::Fake, place);
  self.cfg.push_assign(block, scrutinee_source_info, Place::from(temp), borrow);
  }