Skip to content

Commit

Permalink
Auto merge of #117139 - compiler-errors:vid-lifetimes, r=BoxyUwU
Browse files Browse the repository at this point in the history
Get rid of `'tcx` lifetime on `ConstVid`, `EffectVid`

These are simply newtyped numbers, so don't really have a reason (per se) to have a lifetime -- `TyVid` and `RegionVid` do not, for example.

The only consequence of this is that we need to use a new key type for `UnifyKey` that mentions `'tcx`. This is already done for `RegionVid`, with `RegionVidKey<'tcx>`, but this `UnifyKey` trait implementation may have been the original reason to give `ConstVid` a lifetime. See the changes to `compiler/rustc_middle/src/infer/unify_key.rs` specifically.

I consider the code cleaner this way, though -- we removed quite a few unnecessary `'tcx` in the process. This also makes it easier to uplift these two ids to `rustc_type_ir`, which I plan on doing in a follow-up PR.

r? `@BoxyUwU`
  • Loading branch information
bors committed Oct 25, 2023
2 parents 848a387 + a986ab4 commit 2e4e2a8
Show file tree
Hide file tree
Showing 17 changed files with 150 additions and 130 deletions.
2 changes: 1 addition & 1 deletion compiler/rustc_infer/src/infer/canonical/mod.rs
Original file line number Diff line number Diff line change
Expand Up @@ -152,7 +152,7 @@ impl<'tcx> InferCtxt<'tcx> {
)
.into(),
CanonicalVarKind::Effect => {
let vid = self.inner.borrow_mut().effect_unification_table().new_key(None);
let vid = self.inner.borrow_mut().effect_unification_table().new_key(None).vid;
ty::Const::new_infer(self.tcx, ty::InferConst::EffectVar(vid), self.tcx.types.bool)
.into()
}
Expand Down
4 changes: 2 additions & 2 deletions compiler/rustc_infer/src/infer/combine.rs
Original file line number Diff line number Diff line change
Expand Up @@ -320,7 +320,7 @@ impl<'tcx> InferCtxt<'tcx> {
#[instrument(level = "debug", skip(self))]
fn unify_const_variable(
&self,
target_vid: ty::ConstVid<'tcx>,
target_vid: ty::ConstVid,
ct: ty::Const<'tcx>,
param_env: ty::ParamEnv<'tcx>,
) -> RelateResult<'tcx, ty::Const<'tcx>> {
Expand Down Expand Up @@ -381,7 +381,7 @@ impl<'tcx> InferCtxt<'tcx> {
fn unify_effect_variable(
&self,
vid_is_expected: bool,
vid: ty::EffectVid<'tcx>,
vid: ty::EffectVid,
val: EffectVarValue<'tcx>,
) -> RelateResult<'tcx, ty::Const<'tcx>> {
self.inner
Expand Down
6 changes: 3 additions & 3 deletions compiler/rustc_infer/src/infer/freshen.rs
Original file line number Diff line number Diff line change
Expand Up @@ -42,7 +42,7 @@ pub struct TypeFreshener<'a, 'tcx> {
ty_freshen_count: u32,
const_freshen_count: u32,
ty_freshen_map: FxHashMap<ty::InferTy, Ty<'tcx>>,
const_freshen_map: FxHashMap<ty::InferConst<'tcx>, ty::Const<'tcx>>,
const_freshen_map: FxHashMap<ty::InferConst, ty::Const<'tcx>>,
}

impl<'a, 'tcx> TypeFreshener<'a, 'tcx> {
Expand Down Expand Up @@ -79,12 +79,12 @@ impl<'a, 'tcx> TypeFreshener<'a, 'tcx> {
fn freshen_const<F>(
&mut self,
opt_ct: Option<ty::Const<'tcx>>,
key: ty::InferConst<'tcx>,
key: ty::InferConst,
freshener: F,
ty: Ty<'tcx>,
) -> ty::Const<'tcx>
where
F: FnOnce(u32) -> ty::InferConst<'tcx>,
F: FnOnce(u32) -> ty::InferConst,
{
if let Some(ct) = opt_ct {
return ct.fold_with(self);
Expand Down
15 changes: 8 additions & 7 deletions compiler/rustc_infer/src/infer/fudge.rs
Original file line number Diff line number Diff line change
@@ -1,3 +1,4 @@
use rustc_middle::infer::unify_key::ConstVidKey;
use rustc_middle::ty::fold::{TypeFoldable, TypeFolder, TypeSuperFoldable};
use rustc_middle::ty::{self, ConstVid, FloatVid, IntVid, RegionVid, Ty, TyCtxt, TyVid};

Expand All @@ -23,14 +24,14 @@ where
}

fn const_vars_since_snapshot<'tcx>(
table: &mut UnificationTable<'_, 'tcx, ConstVid<'tcx>>,
table: &mut UnificationTable<'_, 'tcx, ConstVidKey<'tcx>>,
snapshot_var_len: usize,
) -> (Range<ConstVid<'tcx>>, Vec<ConstVariableOrigin>) {
) -> (Range<ConstVid>, Vec<ConstVariableOrigin>) {
let range = vars_since_snapshot(table, snapshot_var_len);
(
range.start..range.end,
(range.start.index..range.end.index)
.map(|index| table.probe_value(ConstVid::from_index(index)).origin)
range.start.vid..range.end.vid,
(range.start.index()..range.end.index())
.map(|index| table.probe_value(ConstVid::from_u32(index)).origin)
.collect(),
)
}
Expand Down Expand Up @@ -172,7 +173,7 @@ pub struct InferenceFudger<'a, 'tcx> {
int_vars: Range<IntVid>,
float_vars: Range<FloatVid>,
region_vars: (Range<RegionVid>, Vec<RegionVariableOrigin>),
const_vars: (Range<ConstVid<'tcx>>, Vec<ConstVariableOrigin>),
const_vars: (Range<ConstVid>, Vec<ConstVariableOrigin>),
}

impl<'a, 'tcx> TypeFolder<TyCtxt<'tcx>> for InferenceFudger<'a, 'tcx> {
Expand Down Expand Up @@ -235,7 +236,7 @@ impl<'a, 'tcx> TypeFolder<TyCtxt<'tcx>> for InferenceFudger<'a, 'tcx> {
if self.const_vars.0.contains(&vid) {
// This variable was created during the fudging.
// Recreate it with a fresh variable here.
let idx = (vid.index - self.const_vars.0.start.index) as usize;
let idx = (vid.index() - self.const_vars.0.start.index()) as usize;
let origin = self.const_vars.1[idx];
self.infcx.next_const_var(ct.ty(), origin)
} else {
Expand Down
20 changes: 12 additions & 8 deletions compiler/rustc_infer/src/infer/generalize.rs
Original file line number Diff line number Diff line change
Expand Up @@ -17,7 +17,7 @@ pub(super) fn generalize<'tcx, D: GeneralizerDelegate<'tcx>, T: Into<Term<'tcx>>
infcx: &InferCtxt<'tcx>,
delegate: &mut D,
term: T,
for_vid: impl Into<ty::TermVid<'tcx>>,
for_vid: impl Into<ty::TermVid>,
ambient_variance: ty::Variance,
) -> RelateResult<'tcx, Generalization<T>> {
let (for_universe, root_vid) = match for_vid.into() {
Expand All @@ -27,7 +27,7 @@ pub(super) fn generalize<'tcx, D: GeneralizerDelegate<'tcx>, T: Into<Term<'tcx>>
),
ty::TermVid::Const(ct_vid) => (
infcx.probe_const_var(ct_vid).unwrap_err(),
ty::TermVid::Const(infcx.inner.borrow_mut().const_unification_table().find(ct_vid)),
ty::TermVid::Const(infcx.inner.borrow_mut().const_unification_table().find(ct_vid).vid),
),
};

Expand Down Expand Up @@ -127,7 +127,7 @@ struct Generalizer<'me, 'tcx, D> {
/// The vid of the type variable that is in the process of being
/// instantiated. If we find this within the value we are folding,
/// that means we would have created a cyclic value.
root_vid: ty::TermVid<'tcx>,
root_vid: ty::TermVid,

/// The universe of the type variable that is in the process of being
/// instantiated. If we find anything that this universe cannot name,
Expand Down Expand Up @@ -376,7 +376,7 @@ where
// `vid` are related and we'd be inferring an infinitely
// deep const.
if ty::TermVid::Const(
self.infcx.inner.borrow_mut().const_unification_table().find(vid),
self.infcx.inner.borrow_mut().const_unification_table().find(vid).vid,
) == self.root_vid
{
return Err(self.cyclic_term_error());
Expand All @@ -394,10 +394,14 @@ where
if self.for_universe.can_name(universe) {
Ok(c)
} else {
let new_var_id = variable_table.new_key(ConstVarValue {
origin: var_value.origin,
val: ConstVariableValue::Unknown { universe: self.for_universe },
});
let new_var_id = variable_table
.new_key(ConstVarValue {
origin: var_value.origin,
val: ConstVariableValue::Unknown {
universe: self.for_universe,
},
})
.vid;
Ok(ty::Const::new_var(self.tcx(), new_var_id, c.ty()))
}
}
Expand Down
83 changes: 45 additions & 38 deletions compiler/rustc_infer/src/infer/mod.rs
Original file line number Diff line number Diff line change
Expand Up @@ -6,7 +6,9 @@ pub use self::RegionVariableOrigin::*;
pub use self::SubregionOrigin::*;
pub use self::ValuePairs::*;
pub use combine::ObligationEmittingRelation;
use rustc_data_structures::captures::Captures;
use rustc_data_structures::undo_log::UndoLogs;
use rustc_middle::infer::unify_key::{ConstVidKey, EffectVidKey};

use self::opaque_types::OpaqueTypeStorage;
pub(crate) use self::undo_log::{InferCtxtUndoLogs, Snapshot, UndoLog};
Expand Down Expand Up @@ -40,7 +42,6 @@ use rustc_span::{Span, DUMMY_SP};

use std::cell::{Cell, RefCell};
use std::fmt;
use std::marker::PhantomData;

use self::combine::CombineFields;
use self::error_reporting::TypeErrCtxt;
Expand Down Expand Up @@ -85,7 +86,7 @@ pub struct InferOk<'tcx, T> {
pub type InferResult<'tcx, T> = Result<InferOk<'tcx, T>, TypeError<'tcx>>;

pub type UnitResult<'tcx> = RelateResult<'tcx, ()>; // "unify result"
pub type FixupResult<'tcx, T> = Result<T, FixupError<'tcx>>; // "fixup result"
pub type FixupResult<T> = Result<T, FixupError>; // "fixup result"

pub(crate) type UnificationTable<'a, 'tcx, T> = ut::UnificationTable<
ut::InPlace<T, &'a mut ut::UnificationStorage<T>, &'a mut InferCtxtUndoLogs<'tcx>>,
Expand All @@ -108,7 +109,7 @@ pub struct InferCtxtInner<'tcx> {
type_variable_storage: type_variable::TypeVariableStorage<'tcx>,

/// Map from const parameter variable to the kind of const it represents.
const_unification_storage: ut::UnificationTableStorage<ty::ConstVid<'tcx>>,
const_unification_storage: ut::UnificationTableStorage<ConstVidKey<'tcx>>,

/// Map from integral variable to the kind of integer it represents.
int_unification_storage: ut::UnificationTableStorage<ty::IntVid>,
Expand All @@ -117,7 +118,7 @@ pub struct InferCtxtInner<'tcx> {
float_unification_storage: ut::UnificationTableStorage<ty::FloatVid>,

/// Map from effect variable to the effect param it represents.
effect_unification_storage: ut::UnificationTableStorage<ty::EffectVid<'tcx>>,
effect_unification_storage: ut::UnificationTableStorage<EffectVidKey<'tcx>>,

/// Tracks the set of region variables and the constraints between them.
///
Expand Down Expand Up @@ -224,11 +225,11 @@ impl<'tcx> InferCtxtInner<'tcx> {
}

#[inline]
fn const_unification_table(&mut self) -> UnificationTable<'_, 'tcx, ty::ConstVid<'tcx>> {
fn const_unification_table(&mut self) -> UnificationTable<'_, 'tcx, ConstVidKey<'tcx>> {
self.const_unification_storage.with_log(&mut self.undo_log)
}

fn effect_unification_table(&mut self) -> UnificationTable<'_, 'tcx, ty::EffectVid<'tcx>> {
fn effect_unification_table(&mut self) -> UnificationTable<'_, 'tcx, EffectVidKey<'tcx>> {
self.effect_unification_storage.with_log(&mut self.undo_log)
}

Expand Down Expand Up @@ -359,7 +360,7 @@ impl<'tcx> ty::InferCtxtLike for InferCtxt<'tcx> {
}
}

fn universe_of_ct(&self, ct: ty::InferConst<'tcx>) -> Option<ty::UniverseIndex> {
fn universe_of_ct(&self, ct: ty::InferConst) -> Option<ty::UniverseIndex> {
use ty::InferConst::*;
match ct {
// Same issue as with `universe_of_ty`
Expand Down Expand Up @@ -548,11 +549,11 @@ pub enum NllRegionVariableOrigin {

// FIXME(eddyb) investigate overlap between this and `TyOrConstInferVar`.
#[derive(Copy, Clone, Debug)]
pub enum FixupError<'tcx> {
pub enum FixupError {
UnresolvedIntTy(IntVid),
UnresolvedFloatTy(FloatVid),
UnresolvedTy(TyVid),
UnresolvedConst(ConstVid<'tcx>),
UnresolvedConst(ConstVid),
}

/// See the `region_obligations` field for more information.
Expand All @@ -563,7 +564,7 @@ pub struct RegionObligation<'tcx> {
pub origin: SubregionOrigin<'tcx>,
}

impl<'tcx> fmt::Display for FixupError<'tcx> {
impl fmt::Display for FixupError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
use self::FixupError::*;

Expand Down Expand Up @@ -794,7 +795,7 @@ impl<'tcx> InferCtxt<'tcx> {
let mut table = inner.effect_unification_table();

(0..table.len())
.map(|i| ty::EffectVid { index: i as u32, phantom: PhantomData })
.map(|i| ty::EffectVid::from_usize(i))
.filter(|&vid| table.probe_value(vid).is_none())
.map(|v| {
ty::Const::new_infer(self.tcx, ty::InferConst::EffectVar(v), self.tcx.types.bool)
Expand Down Expand Up @@ -1072,15 +1073,20 @@ impl<'tcx> InferCtxt<'tcx> {
.inner
.borrow_mut()
.const_unification_table()
.new_key(ConstVarValue { origin, val: ConstVariableValue::Unknown { universe } });
.new_key(ConstVarValue { origin, val: ConstVariableValue::Unknown { universe } })
.vid;
ty::Const::new_var(self.tcx, vid, ty)
}

pub fn next_const_var_id(&self, origin: ConstVariableOrigin) -> ConstVid<'tcx> {
self.inner.borrow_mut().const_unification_table().new_key(ConstVarValue {
origin,
val: ConstVariableValue::Unknown { universe: self.universe() },
})
pub fn next_const_var_id(&self, origin: ConstVariableOrigin) -> ConstVid {
self.inner
.borrow_mut()
.const_unification_table()
.new_key(ConstVarValue {
origin,
val: ConstVariableValue::Unknown { universe: self.universe() },
})
.vid
}

fn next_int_var_id(&self) -> IntVid {
Expand Down Expand Up @@ -1194,11 +1200,15 @@ impl<'tcx> InferCtxt<'tcx> {
),
span,
};
let const_var_id =
self.inner.borrow_mut().const_unification_table().new_key(ConstVarValue {
let const_var_id = self
.inner
.borrow_mut()
.const_unification_table()
.new_key(ConstVarValue {
origin,
val: ConstVariableValue::Unknown { universe: self.universe() },
});
})
.vid;
ty::Const::new_var(
self.tcx,
const_var_id,
Expand All @@ -1213,7 +1223,7 @@ impl<'tcx> InferCtxt<'tcx> {
}

pub fn var_for_effect(&self, param: &ty::GenericParamDef) -> GenericArg<'tcx> {
let effect_vid = self.inner.borrow_mut().effect_unification_table().new_key(None);
let effect_vid = self.inner.borrow_mut().effect_unification_table().new_key(None).vid;
let ty = self
.tcx
.type_of(param.def_id)
Expand Down Expand Up @@ -1333,12 +1343,12 @@ impl<'tcx> InferCtxt<'tcx> {
self.inner.borrow_mut().type_variables().root_var(var)
}

pub fn root_const_var(&self, var: ty::ConstVid<'tcx>) -> ty::ConstVid<'tcx> {
self.inner.borrow_mut().const_unification_table().find(var)
pub fn root_const_var(&self, var: ty::ConstVid) -> ty::ConstVid {
self.inner.borrow_mut().const_unification_table().find(var).vid
}

pub fn root_effect_var(&self, var: ty::EffectVid<'tcx>) -> ty::EffectVid<'tcx> {
self.inner.borrow_mut().effect_unification_table().find(var)
pub fn root_effect_var(&self, var: ty::EffectVid) -> ty::EffectVid {
self.inner.borrow_mut().effect_unification_table().find(var).vid
}

/// Resolves an int var to a rigid int type, if it was constrained to one,
Expand Down Expand Up @@ -1402,17 +1412,14 @@ impl<'tcx> InferCtxt<'tcx> {
value.visit_with(&mut resolve::UnresolvedTypeOrConstFinder::new(self)).break_value()
}

pub fn probe_const_var(
&self,
vid: ty::ConstVid<'tcx>,
) -> Result<ty::Const<'tcx>, ty::UniverseIndex> {
pub fn probe_const_var(&self, vid: ty::ConstVid) -> Result<ty::Const<'tcx>, ty::UniverseIndex> {
match self.inner.borrow_mut().const_unification_table().probe_value(vid).val {
ConstVariableValue::Known { value } => Ok(value),
ConstVariableValue::Unknown { universe } => Err(universe),
}
}

pub fn probe_effect_var(&self, vid: EffectVid<'tcx>) -> Option<EffectVarValue<'tcx>> {
pub fn probe_effect_var(&self, vid: EffectVid) -> Option<EffectVarValue<'tcx>> {
self.inner.borrow_mut().effect_unification_table().probe_value(vid)
}

Expand All @@ -1423,7 +1430,7 @@ impl<'tcx> InferCtxt<'tcx> {
///
/// This method is idempotent, but it not typically not invoked
/// except during the writeback phase.
pub fn fully_resolve<T: TypeFoldable<TyCtxt<'tcx>>>(&self, value: T) -> FixupResult<'tcx, T> {
pub fn fully_resolve<T: TypeFoldable<TyCtxt<'tcx>>>(&self, value: T) -> FixupResult<T> {
match resolve::fully_resolve(self, value) {
Ok(value) => {
if value.has_non_region_infer() {
Expand Down Expand Up @@ -1647,11 +1654,11 @@ impl<'tcx> InferCtxt<'tcx> {
#[inline]
pub fn is_ty_infer_var_definitely_unchanged<'a>(
&'a self,
) -> (impl Fn(TyOrConstInferVar<'tcx>) -> bool + 'a) {
) -> (impl Fn(TyOrConstInferVar) -> bool + Captures<'tcx> + 'a) {
// This hoists the borrow/release out of the loop body.
let inner = self.inner.try_borrow();

return move |infer_var: TyOrConstInferVar<'tcx>| match (infer_var, &inner) {
return move |infer_var: TyOrConstInferVar| match (infer_var, &inner) {
(TyOrConstInferVar::Ty(ty_var), Ok(inner)) => {
use self::type_variable::TypeVariableValue;

Expand All @@ -1674,7 +1681,7 @@ impl<'tcx> InferCtxt<'tcx> {
/// inference variables), and it handles both `Ty` and `ty::Const` without
/// having to resort to storing full `GenericArg`s in `stalled_on`.
#[inline(always)]
pub fn ty_or_const_infer_var_changed(&self, infer_var: TyOrConstInferVar<'tcx>) -> bool {
pub fn ty_or_const_infer_var_changed(&self, infer_var: TyOrConstInferVar) -> bool {
match infer_var {
TyOrConstInferVar::Ty(v) => {
use self::type_variable::TypeVariableValue;
Expand Down Expand Up @@ -1781,7 +1788,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
/// Helper for [InferCtxt::ty_or_const_infer_var_changed] (see comment on that), currently
/// used only for `traits::fulfill`'s list of `stalled_on` inference variables.
#[derive(Copy, Clone, Debug)]
pub enum TyOrConstInferVar<'tcx> {
pub enum TyOrConstInferVar {
/// Equivalent to `ty::Infer(ty::TyVar(_))`.
Ty(TyVid),
/// Equivalent to `ty::Infer(ty::IntVar(_))`.
Expand All @@ -1790,12 +1797,12 @@ pub enum TyOrConstInferVar<'tcx> {
TyFloat(FloatVid),

/// Equivalent to `ty::ConstKind::Infer(ty::InferConst::Var(_))`.
Const(ConstVid<'tcx>),
Const(ConstVid),
/// Equivalent to `ty::ConstKind::Infer(ty::InferConst::EffectVar(_))`.
Effect(EffectVid<'tcx>),
Effect(EffectVid),
}

impl<'tcx> TyOrConstInferVar<'tcx> {
impl<'tcx> TyOrConstInferVar {
/// Tries to extract an inference variable from a type or a constant, returns `None`
/// for types other than `ty::Infer(_)` (or `InferTy::Fresh*`) and
/// for constants other than `ty::ConstKind::Infer(_)` (or `InferConst::Fresh`).
Expand Down
Loading

0 comments on commit 2e4e2a8

Please sign in to comment.