rust-lang · bors · Oct 24, 2023 · Oct 23, 2023 · Oct 23, 2023 · Oct 21, 2023
diff --git a/compiler/rustc_const_eval/src/interpret/eval_context.rs b/compiler/rustc_const_eval/src/interpret/eval_context.rs
@@ -1010,7 1010,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
  // Just make this an efficient immediate.
  // Note that not calling `layout_of` here does have one real consequence:
  // if the type is too big, we'll only notice this when the local is actually initialized,
- // which is a bit too late -- we should ideally notice this alreayd here, when the memory
  // which is a bit too late -- we should ideally notice this already here, when the memory
  // is conceptually allocated. But given how rare that error is and that this is a hot function,
  // we accept this downside for now.
  Operand::Immediate(Immediate::Uninit)

diff --git a/compiler/rustc_infer/src/infer/mod.rs b/compiler/rustc_infer/src/infer/mod.rs
@@ -341,7 341,9 @@ pub struct InferCtxt<'tcx> {
  next_trait_solver: bool,
 }
 
-impl<'tcx> ty::InferCtxtLike<TyCtxt<'tcx>> for InferCtxt<'tcx> {
 impl<'tcx> ty::InferCtxtLike for InferCtxt<'tcx> {
  type Interner = TyCtxt<'tcx>;
 
  fn universe_of_ty(&self, ty: ty::InferTy) -> Option<ty::UniverseIndex> {
  use InferTy::*;
  match ty {

diff --git a/compiler/rustc_middle/src/ty/list.rs b/compiler/rustc_middle/src/ty/list.rs
@@ -1,7 1,7 @@
 use crate::arena::Arena;
 use rustc_data_structures::aligned::{align_of, Aligned};
 use rustc_serialize::{Encodable, Encoder};
-use rustc_type_ir::{InferCtxtLike, OptWithInfcx};
 use rustc_type_ir::{InferCtxtLike, WithInfcx};
 use std::alloc::Layout;
 use std::cmp::Ordering;
 use std::fmt;
@@ -121,8 121,8 @@ impl<T: fmt::Debug> fmt::Debug for List<T> {
  }
 }
 impl<'tcx, T: super::DebugWithInfcx<TyCtxt<'tcx>>> super::DebugWithInfcx<TyCtxt<'tcx>> for List<T> {
- fn fmt<InfCtx: InferCtxtLike<TyCtxt<'tcx>>>(
- this: OptWithInfcx<'_, TyCtxt<'tcx>, InfCtx, &Self>,
  fn fmt<Infcx: InferCtxtLike<Interner = TyCtxt<'tcx>>>(
  this: WithInfcx<'_, Infcx, &Self>,
  f: &mut core::fmt::Formatter<'_>,
  ) -> core::fmt::Result {
  fmt::Debug::fmt(&this.map(|this| this.as_slice()), f)

diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
@@ -54,7 54,7 @@ use rustc_span::symbol::{kw, sym, Ident, Symbol};
 use rustc_span::{ExpnId, ExpnKind, Span};
 use rustc_target::abi::{Align, FieldIdx, Integer, IntegerType, VariantIdx};
 pub use rustc_target::abi::{ReprFlags, ReprOptions};
-pub use rustc_type_ir::{DebugWithInfcx, InferCtxtLike, OptWithInfcx};
 pub use rustc_type_ir::{DebugWithInfcx, InferCtxtLike, WithInfcx};
 pub use vtable::*;
 
 use std::fmt::Debug;

diff --git a/compiler/rustc_middle/src/ty/structural_impls.rs b/compiler/rustc_middle/src/ty/structural_impls.rs
@@ -10,7 10,7 @@ use crate::ty::visit::{TypeSuperVisitable, TypeVisitable, TypeVisitor};
 use crate::ty::{self, AliasTy, InferConst, Lift, Term, TermKind, Ty, TyCtxt};
 use rustc_hir::def::Namespace;
 use rustc_target::abi::TyAndLayout;
-use rustc_type_ir::{ConstKind, DebugWithInfcx, InferCtxtLike, OptWithInfcx};
 use rustc_type_ir::{ConstKind, DebugWithInfcx, InferCtxtLike, WithInfcx};
 
 use std::fmt::{self, Debug};
 use std::ops::ControlFlow;
@@ -87,12 87,12 @@ impl fmt::Debug for ty::FreeRegion {
 
 impl<'tcx> fmt::Debug for ty::FnSig<'tcx> {
  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
- OptWithInfcx::new_no_ctx(self).fmt(f)
  WithInfcx::with_no_infcx(self).fmt(f)
  }
 }
 impl<'tcx> DebugWithInfcx<TyCtxt<'tcx>> for ty::FnSig<'tcx> {
- fn fmt<InfCtx: InferCtxtLike<TyCtxt<'tcx>>>(
- this: OptWithInfcx<'_, TyCtxt<'tcx>, InfCtx, &Self>,
  fn fmt<Infcx: InferCtxtLike<Interner = TyCtxt<'tcx>>>(
  this: WithInfcx<'_, Infcx, &Self>,
  f: &mut core::fmt::Formatter<'_>,
  ) -> core::fmt::Result {
  let sig = this.data;
@@ -147,8 147,8 @@ impl<'tcx> fmt::Debug for ty::TraitRef<'tcx> {
 }
 
 impl<'tcx> ty::DebugWithInfcx<TyCtxt<'tcx>> for Ty<'tcx> {
- fn fmt<InfCtx: InferCtxtLike<TyCtxt<'tcx>>>(
- this: OptWithInfcx<'_, TyCtxt<'tcx>, InfCtx, &Self>,
  fn fmt<Infcx: InferCtxtLike<Interner = TyCtxt<'tcx>>>(
  this: WithInfcx<'_, Infcx, &Self>,
  f: &mut core::fmt::Formatter<'_>,
  ) -> core::fmt::Result {
  this.data.fmt(f)
@@ -236,12 236,12 @@ impl<'tcx> fmt::Debug for ty::PredicateKind<'tcx> {
 
 impl<'tcx> fmt::Debug for AliasTy<'tcx> {
  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
- OptWithInfcx::new_no_ctx(self).fmt(f)
  WithInfcx::with_no_infcx(self).fmt(f)
  }
 }
 impl<'tcx> DebugWithInfcx<TyCtxt<'tcx>> for AliasTy<'tcx> {
- fn fmt<InfCtx: InferCtxtLike<TyCtxt<'tcx>>>(
- this: OptWithInfcx<'_, TyCtxt<'tcx>, InfCtx, &Self>,
  fn fmt<Infcx: InferCtxtLike<Interner = TyCtxt<'tcx>>>(
  this: WithInfcx<'_, Infcx, &Self>,
  f: &mut core::fmt::Formatter<'_>,
  ) -> core::fmt::Result {
  f.debug_struct("AliasTy")
@@ -261,12 261,12 @@ impl<'tcx> fmt::Debug for ty::InferConst<'tcx> {
  }
 }
 impl<'tcx> DebugWithInfcx<TyCtxt<'tcx>> for ty::InferConst<'tcx> {
- fn fmt<InfCtx: InferCtxtLike<TyCtxt<'tcx>>>(
- this: OptWithInfcx<'_, TyCtxt<'tcx>, InfCtx, &Self>,
  fn fmt<Infcx: InferCtxtLike<Interner = TyCtxt<'tcx>>>(
  this: WithInfcx<'_, Infcx, &Self>,
  f: &mut core::fmt::Formatter<'_>,
  ) -> core::fmt::Result {
  use ty::InferConst::*;
- match this.infcx.and_then(|infcx| infcx.universe_of_ct(*this.data)) {
  match this.infcx.universe_of_ct(*this.data) {
  None => write!(f, "{:?}", this.data),
  Some(universe) => match *this.data {
  Var(vid) => write!(f, "?{}_{}c", vid.index, universe.index()),
@@ -281,12 281,12 @@ impl<'tcx> DebugWithInfcx<TyCtxt<'tcx>> for ty::InferConst<'tcx> {
 
 impl<'tcx> fmt::Debug for ty::consts::Expr<'tcx> {
  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
- OptWithInfcx::new_no_ctx(self).fmt(f)
  WithInfcx::with_no_infcx(self).fmt(f)
  }
 }
 impl<'tcx> DebugWithInfcx<TyCtxt<'tcx>> for ty::consts::Expr<'tcx> {
- fn fmt<InfCtx: InferCtxtLike<TyCtxt<'tcx>>>(
- this: OptWithInfcx<'_, TyCtxt<'tcx>, InfCtx, &Self>,
  fn fmt<Infcx: InferCtxtLike<Interner = TyCtxt<'tcx>>>(
  this: WithInfcx<'_, Infcx, &Self>,
  f: &mut core::fmt::Formatter<'_>,
  ) -> core::fmt::Result {
  match this.data {
@@ -314,12 314,12 @@ impl<'tcx> DebugWithInfcx<TyCtxt<'tcx>> for ty::consts::Expr<'tcx> {
 
 impl<'tcx> fmt::Debug for ty::UnevaluatedConst<'tcx> {
  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
- OptWithInfcx::new_no_ctx(self).fmt(f)
  WithInfcx::with_no_infcx(self).fmt(f)
  }
 }
 impl<'tcx> DebugWithInfcx<TyCtxt<'tcx>> for ty::UnevaluatedConst<'tcx> {
- fn fmt<InfCtx: InferCtxtLike<TyCtxt<'tcx>>>(
- this: OptWithInfcx<'_, TyCtxt<'tcx>, InfCtx, &Self>,
  fn fmt<Infcx: InferCtxtLike<Interner = TyCtxt<'tcx>>>(
  this: WithInfcx<'_, Infcx, &Self>,
  f: &mut core::fmt::Formatter<'_>,
  ) -> core::fmt::Result {
  f.debug_struct("UnevaluatedConst")
@@ -331,12 331,12 @@ impl<'tcx> DebugWithInfcx<TyCtxt<'tcx>> for ty::UnevaluatedConst<'tcx> {
 
 impl<'tcx> fmt::Debug for ty::Const<'tcx> {
  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
- OptWithInfcx::new_no_ctx(self).fmt(f)
  WithInfcx::with_no_infcx(self).fmt(f)
  }
 }
 impl<'tcx> DebugWithInfcx<TyCtxt<'tcx>> for ty::Const<'tcx> {
- fn fmt<InfCtx: InferCtxtLike<TyCtxt<'tcx>>>(
- this: OptWithInfcx<'_, TyCtxt<'tcx>, InfCtx, &Self>,
  fn fmt<Infcx: InferCtxtLike<Interner = TyCtxt<'tcx>>>(
  this: WithInfcx<'_, Infcx, &Self>,
  f: &mut core::fmt::Formatter<'_>,
  ) -> core::fmt::Result {
  // If this is a value, we spend some effort to make it look nice.
@@ -392,8 392,8 @@ impl<'tcx> fmt::Debug for GenericArg<'tcx> {
  }
 }
 impl<'tcx> DebugWithInfcx<TyCtxt<'tcx>> for GenericArg<'tcx> {
- fn fmt<InfCtx: InferCtxtLike<TyCtxt<'tcx>>>(
- this: OptWithInfcx<'_, TyCtxt<'tcx>, InfCtx, &Self>,
  fn fmt<Infcx: InferCtxtLike<Interner = TyCtxt<'tcx>>>(
  this: WithInfcx<'_, Infcx, &Self>,
  f: &mut core::fmt::Formatter<'_>,
  ) -> core::fmt::Result {
  match this.data.unpack() {
@@ -410,29 410,29 @@ impl<'tcx> fmt::Debug for Region<'tcx> {
  }
 }
 impl<'tcx> DebugWithInfcx<TyCtxt<'tcx>> for Region<'tcx> {
- fn fmt<InfCtx: InferCtxtLike<TyCtxt<'tcx>>>(
- this: OptWithInfcx<'_, TyCtxt<'tcx>, InfCtx, &Self>,
  fn fmt<Infcx: InferCtxtLike<Interner = TyCtxt<'tcx>>>(
  this: WithInfcx<'_, Infcx, &Self>,
  f: &mut core::fmt::Formatter<'_>,
  ) -> core::fmt::Result {
  write!(f, "{:?}", &this.map(|data| data.kind()))
  }
 }
 
 impl<'tcx> DebugWithInfcx<TyCtxt<'tcx>> for ty::RegionVid {
- fn fmt<InfCtx: InferCtxtLike<TyCtxt<'tcx>>>(
- this: OptWithInfcx<'_, TyCtxt<'tcx>, InfCtx, &Self>,
  fn fmt<Infcx: InferCtxtLike<Interner = TyCtxt<'tcx>>>(
  this: WithInfcx<'_, Infcx, &Self>,
  f: &mut core::fmt::Formatter<'_>,
  ) -> core::fmt::Result {
- match this.infcx.and_then(|infcx| infcx.universe_of_lt(*this.data)) {
  match this.infcx.universe_of_lt(*this.data) {
  Some(universe) => write!(f, "'?{}_{}", this.data.index(), universe.index()),
  None => write!(f, "{:?}", this.data),
  }
  }
 }
 
 impl<'tcx, T: DebugWithInfcx<TyCtxt<'tcx>>> DebugWithInfcx<TyCtxt<'tcx>> for ty::Binder<'tcx, T> {
- fn fmt<InfCtx: InferCtxtLike<TyCtxt<'tcx>>>(
- this: OptWithInfcx<'_, TyCtxt<'tcx>, InfCtx, &Self>,
  fn fmt<Infcx: InferCtxtLike<Interner = TyCtxt<'tcx>>>(
  this: WithInfcx<'_, Infcx, &Self>,
  f: &mut core::fmt::Formatter<'_>,
  ) -> core::fmt::Result {
  f.debug_tuple("Binder")

diff --git a/compiler/rustc_middle/src/ty/sty.rs b/compiler/rustc_middle/src/ty/sty.rs
@@ -683,8 683,8 @@ pub enum ExistentialPredicate<'tcx> {
 }
 
 impl<'tcx> DebugWithInfcx<TyCtxt<'tcx>> for ExistentialPredicate<'tcx> {
- fn fmt<InfCtx: rustc_type_ir::InferCtxtLike<TyCtxt<'tcx>>>(
- this: rustc_type_ir::OptWithInfcx<'_, TyCtxt<'tcx>, InfCtx, &Self>,
  fn fmt<Infcx: rustc_type_ir::InferCtxtLike<Interner = TyCtxt<'tcx>>>(
  this: rustc_type_ir::WithInfcx<'_, Infcx, &Self>,
  f: &mut core::fmt::Formatter<'_>,
  ) -> core::fmt::Result {
  fmt::Debug::fmt(&this.data, f)

diff --git a/compiler/rustc_type_ir/src/const_kind.rs b/compiler/rustc_type_ir/src/const_kind.rs
@@ -5,8 5,8 @@ use std::fmt;
 use std::hash;
 
 use crate::{
- DebruijnIndex, DebugWithInfcx, HashStableContext, InferCtxtLike, Interner, OptWithInfcx,
- TyDecoder, TyEncoder,
  DebruijnIndex, DebugWithInfcx, HashStableContext, InferCtxtLike, Interner, TyDecoder,
  TyEncoder, WithInfcx,
 };
 
 use self::ConstKind::*;
@@ -231,13 231,13 @@ impl<I: Interner> Clone for ConstKind<I> {
 
 impl<I: Interner> fmt::Debug for ConstKind<I> {
  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
- OptWithInfcx::new_no_ctx(self).fmt(f)
  WithInfcx::with_no_infcx(self).fmt(f)
  }
 }
 
 impl<I: Interner> DebugWithInfcx<I> for ConstKind<I> {
- fn fmt<InfCtx: InferCtxtLike<I>>(
- this: OptWithInfcx<'_, I, InfCtx, &Self>,
  fn fmt<Infcx: InferCtxtLike<Interner = I>>(
  this: WithInfcx<'_, Infcx, &Self>,
  f: &mut core::fmt::Formatter<'_>,
  ) -> core::fmt::Result {
  use ConstKind::*;

diff --git a/compiler/rustc_type_ir/src/debug.rs b/compiler/rustc_type_ir/src/debug.rs
@@ -3,47 3,57 @@ use crate::{Interner, UniverseIndex};
 use core::fmt;
 use std::marker::PhantomData;
 
-pub trait InferCtxtLike<I: Interner> {
- fn universe_of_ty(&self, ty: I::InferTy) -> Option<UniverseIndex>;
 pub trait InferCtxtLike {
  type Interner: Interner;
 
- fn universe_of_lt(&self, lt: I::InferRegion) -> Option<UniverseIndex>;
  fn universe_of_ty(&self, ty: <Self::Interner as Interner>::InferTy) -> Option<UniverseIndex>;
 
- fn universe_of_ct(&self, ct: I::InferConst) -> Option<UniverseIndex>;
  fn universe_of_lt(
  &self,
  lt: <Self::Interner as Interner>::InferRegion,
  ) -> Option<UniverseIndex>;
 
  fn universe_of_ct(&self, ct: <Self::Interner as Interner>::InferConst)
  -> Option<UniverseIndex>;
 }
 
-impl<I: Interner> InferCtxtLike<I> for core::convert::Infallible {
 pub struct NoInfcx<I>(PhantomData<I>);
 
 impl<I: Interner> InferCtxtLike for NoInfcx<I> {
  type Interner = I;
 
  fn universe_of_ty(&self, _ty: <I as Interner>::InferTy) -> Option<UniverseIndex> {
- match *self {}
  None
  }
 
  fn universe_of_ct(&self, _ct: <I as Interner>::InferConst) -> Option<UniverseIndex> {
- match *self {}
  None
  }
 
  fn universe_of_lt(&self, _lt: <I as Interner>::InferRegion) -> Option<UniverseIndex> {
- match *self {}
  None
  }
 }
 
 pub trait DebugWithInfcx<I: Interner>: fmt::Debug {
- fn fmt<InfCtx: InferCtxtLike<I>>(
- this: OptWithInfcx<'_, I, InfCtx, &Self>,
  fn fmt<Infcx: InferCtxtLike<Interner = I>>(
  this: WithInfcx<'_, Infcx, &Self>,
  f: &mut fmt::Formatter<'_>,
  ) -> fmt::Result;
 }
 
 impl<I: Interner, T: DebugWithInfcx<I> ?Sized> DebugWithInfcx<I> for &'_ T {
- fn fmt<InfCtx: InferCtxtLike<I>>(
- this: OptWithInfcx<'_, I, InfCtx, &Self>,
  fn fmt<Infcx: InferCtxtLike<Interner = I>>(
  this: WithInfcx<'_, Infcx, &Self>,
  f: &mut fmt::Formatter<'_>,
  ) -> fmt::Result {
  <T as DebugWithInfcx<I>>::fmt(this.map(|&data| data), f)
  }
 }
 
 impl<I: Interner, T: DebugWithInfcx<I>> DebugWithInfcx<I> for [T] {
- fn fmt<InfCtx: InferCtxtLike<I>>(
- this: OptWithInfcx<'_, I, InfCtx, &Self>,
  fn fmt<Infcx: InferCtxtLike<Interner = I>>(
  this: WithInfcx<'_, Infcx, &Self>,
  f: &mut fmt::Formatter<'_>,
  ) -> fmt::Result {
  match f.alternate() {
@@ -70,46 80,45 @@ impl<I: Interner, T: DebugWithInfcx<I>> DebugWithInfcx<I> for [T] {
  }
 }
 
-pub struct OptWithInfcx<'a, I: Interner, InfCtx: InferCtxtLike<I>, T> {
 pub struct WithInfcx<'a, Infcx: InferCtxtLike, T> {
  pub data: T,
- pub infcx: Option<&'a InfCtx>,
- _interner: PhantomData<I>,
  pub infcx: &'a Infcx,
 }
 
-impl<I: Interner, InfCtx: InferCtxtLike<I>, T: Copy> Copy for OptWithInfcx<'_, I, InfCtx, T> {}
 impl<Infcx: InferCtxtLike, T: Copy> Copy for WithInfcx<'_, Infcx, T> {}
 
-impl<I: Interner, InfCtx: InferCtxtLike<I>, T: Clone> Clone for OptWithInfcx<'_, I, InfCtx, T> {
 impl<Infcx: InferCtxtLike, T: Clone> Clone for WithInfcx<'_, Infcx, T> {
  fn clone(&self) -> Self {
- Self { data: self.data.clone(), infcx: self.infcx, _interner: self._interner }
  Self { data: self.data.clone(), infcx: self.infcx }
  }
 }
 
-impl<'a, I: Interner, T> OptWithInfcx<'a, I, core::convert::Infallible, T> {
- pub fn new_no_ctx(data: T) -> Self {
- Self { data, infcx: None, _interner: PhantomData }
 impl<'a, I: Interner, T> WithInfcx<'a, NoInfcx<I>, T> {
  pub fn with_no_infcx(data: T) -> Self {
  Self { data, infcx: &NoInfcx(PhantomData) }
  }
 }
 
-impl<'a, I: Interner, InfCtx: InferCtxtLike<I>, T> OptWithInfcx<'a, I, InfCtx, T> {
- pub fn new(data: T, infcx: &'a InfCtx) -> Self {
- Self { data, infcx: Some(infcx), _interner: PhantomData }
 impl<'a, Infcx: InferCtxtLike, T> WithInfcx<'a, Infcx, T> {
  pub fn new(data: T, infcx: &'a Infcx) -> Self {
  Self { data, infcx }
  }
 
- pub fn wrap<U>(self, u: U) -> OptWithInfcx<'a, I, InfCtx, U> {
- OptWithInfcx { data: u, infcx: self.infcx, _interner: PhantomData }
  pub fn wrap<U>(self, u: U) -> WithInfcx<'a, Infcx, U> {
  WithInfcx { data: u, infcx: self.infcx }
  }
 
- pub fn map<U>(self, f: impl FnOnce(T) -> U) -> OptWithInfcx<'a, I, InfCtx, U> {
- OptWithInfcx { data: f(self.data), infcx: self.infcx, _interner: PhantomData }
  pub fn map<U>(self, f: impl FnOnce(T) -> U) -> WithInfcx<'a, Infcx, U> {
  WithInfcx { data: f(self.data), infcx: self.infcx }
  }
 
- pub fn as_ref(&self) -> OptWithInfcx<'a, I, InfCtx, &T> {
- OptWithInfcx { data: &self.data, infcx: self.infcx, _interner: PhantomData }
  pub fn as_ref(&self) -> WithInfcx<'a, Infcx, &T> {
  WithInfcx { data: &self.data, infcx: self.infcx }
  }
 }
 
-impl<I: Interner, InfCtx: InferCtxtLike<I>, T: DebugWithInfcx<I>> fmt::Debug
- for OptWithInfcx<'_, I, InfCtx, T>
 impl<Infcx: InferCtxtLike, T: DebugWithInfcx<Infcx::Interner>> fmt::Debug
  for WithInfcx<'_, Infcx, T>
 {
  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  DebugWithInfcx::fmt(self.as_ref(), f)

diff --git a/compiler/rustc_type_ir/src/lib.rs b/compiler/rustc_type_ir/src/lib.rs
@@ -34,7 34,7 @@ mod region_kind;
 
 pub use codec::*;
 pub use const_kind::*;
-pub use debug::{DebugWithInfcx, InferCtxtLike, OptWithInfcx};
 pub use debug::{DebugWithInfcx, InferCtxtLike, WithInfcx};
 pub use flags::*;
 pub use interner::*;
 pub use region_kind::*;