mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Auto merge of #88710 - Mark-Simulacrum:tyvid-idx, r=jackh726

Browse Source 
Use index newtyping for TyVid

This is useful for using TyVid in types like VecGraph, and just otherwise seems like a small win.
This commit is contained in:
bors 2021-09-07 15:28:34 +00:00
commit 69c4aa2901
5 changed files with 21 additions and 26 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
compiler/rustc_infer/src/infer/fudge.rs
View File

@ -187,7 +187,7 @@ fn fold_ty(&mut self, ty: Ty<'tcx>) -> Ty<'tcx> {
if self.type_vars.0.contains(&vid) {
// This variable was created during the fudging.
// Recreate it with a fresh variable here.
let idx = (vid.index - self.type_vars.0.start.index) as usize;
let idx = (vid.as_usize() - self.type_vars.0.start.as_usize()) as usize;
let origin = self.type_vars.1[idx];
self.infcx.next_ty_var(origin)
} else {

18
compiler/rustc_infer/src/infer/type_variable.rs
View File

@ -196,7 +196,7 @@ impl<'tcx> TypeVariableTable<'_, 'tcx> {
/// Note that this function does not return care whether
/// `vid` has been unified with something else or not.
pub fn var_diverges(&self, vid: ty::TyVid) -> Diverging {
self.storage.values.get(vid.index as usize).diverging
self.storage.values.get(vid.index()).diverging
}
/// Returns the origin that was given when `vid` was created.
@ -204,7 +204,7 @@ pub fn var_diverges(&self, vid: ty::TyVid) -> Diverging {
/// Note that this function does not return care whether
/// `vid` has been unified with something else or not.
pub fn var_origin(&self, vid: ty::TyVid) -> &TypeVariableOrigin {
&self.storage.values.get(vid.index as usize).origin
&self.storage.values.get(vid.as_usize()).origin
}
/// Records that `a == b`, depending on `dir`.
@ -269,7 +269,7 @@ pub fn new_var(
assert_eq!(eq_key.vid, sub_key);
let index = self.values().push(TypeVariableData { origin, diverging });
assert_eq!(eq_key.vid.index, index as u32);
assert_eq!(eq_key.vid.as_u32(), index as u32);
debug!(
"new_var(index={:?}, universe={:?}, diverging={:?}, origin={:?}",
@ -357,11 +357,11 @@ pub fn vars_since_snapshot(
&mut self,
value_count: usize,
) -> (Range<TyVid>, Vec<TypeVariableOrigin>) {
let range = TyVid { index: value_count as u32 }..TyVid { index: self.num_vars() as u32 };
let range = TyVid::from_usize(value_count)..TyVid::from_usize(self.num_vars());
(
range.start..range.end,
(range.start.index..range.end.index)
.map(|index| self.storage.values.get(index as usize).origin)
(range.start.as_usize()..range.end.as_usize())
.map(|index| self.storage.values.get(index).origin)
.collect(),
)
}
@ -371,7 +371,7 @@ pub fn vars_since_snapshot(
pub fn unsolved_variables(&mut self) -> Vec<ty::TyVid> {
(0..self.storage.values.len())
.filter_map(|i| {
let vid = ty::TyVid { index: i as u32 };
let vid = ty::TyVid::from_usize(i);
match self.probe(vid) {
TypeVariableValue::Unknown { .. } => Some(vid),
TypeVariableValue::Known { .. } => None,
@ -424,10 +424,10 @@ impl<'tcx> ut::UnifyKey for TyVidEqKey<'tcx> {
type Value = TypeVariableValue<'tcx>;
#[inline(always)]
fn index(&self) -> u32 {
self.vid.index
self.vid.as_u32()
}
fn from_index(i: u32) -> Self {
TyVidEqKey::from(ty::TyVid { index: i })
TyVidEqKey::from(ty::TyVid::from_u32(i))
}
fn tag() -> &'static str {
"TyVidEqKey"

4
compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs
View File

@ -1244,7 +1244,7 @@ fn report_closure_arg_mismatch(
let sig = if let ty::Tuple(inputs) = inputs.kind() {
tcx.mk_fn_sig(
inputs.iter().map(|k| k.expect_ty()),
tcx.mk_ty_infer(ty::TyVar(ty::TyVid { index: 0 })),
tcx.mk_ty_infer(ty::TyVar(ty::TyVid::from_u32(0))),
false,
hir::Unsafety::Normal,
abi::Abi::Rust,
@ -1252,7 +1252,7 @@ fn report_closure_arg_mismatch(
} else {
tcx.mk_fn_sig(
std::iter::once(inputs),
tcx.mk_ty_infer(ty::TyVar(ty::TyVid { index: 0 })),
tcx.mk_ty_infer(ty::TyVar(ty::TyVid::from_u32(0))),
false,
hir::Unsafety::Normal,
abi::Abi::Rust,

21
compiler/rustc_type_ir/src/lib.rs
View File

@ -363,10 +363,11 @@ pub enum IntVarValue {
#[derive(Clone, Copy, PartialEq, Eq)]
pub struct FloatVarValue(pub FloatTy);
/// A **ty**pe **v**ariable **ID**.
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Encodable, Decodable)]
pub struct TyVid {
pub index: u32,
rustc_index::newtype_index! {
/// A **ty**pe **v**ariable **ID**.
pub struct TyVid {
DEBUG_FORMAT = "_#{}t"
}
}
/// An **int**egral (`u32`, `i32`, `usize`, etc.) type **v**ariable **ID**.
@ -422,10 +423,10 @@ pub enum InferTy {
impl UnifyKey for TyVid {
type Value = ();
fn index(&self) -> u32 {
self.index
self.as_u32()
}
fn from_index(i: u32) -> TyVid {
TyVid { index: i }
TyVid::from_u32(i)
}
fn tag() -> &'static str {
"TyVid"
@ -558,7 +559,7 @@ impl<CTX> HashStable<CTX> for InferTy {
fn hash_stable(&self, ctx: &mut CTX, hasher: &mut StableHasher) {
use InferTy::*;
match self {
TyVar(v) => v.index.hash_stable(ctx, hasher),
TyVar(v) => v.as_u32().hash_stable(ctx, hasher),
IntVar(v) => v.index.hash_stable(ctx, hasher),
FloatVar(v) => v.index.hash_stable(ctx, hasher),
FreshTy(v) | FreshIntTy(v) | FreshFloatTy(v) => v.hash_stable(ctx, hasher),
@ -587,12 +588,6 @@ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
}
}
impl fmt::Debug for TyVid {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "_#{}t", self.index)
}
}
impl fmt::Debug for IntVid {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "_#{}i", self.index)

2
compiler/rustc_typeck/src/check/method/suggest.rs
View File

@ -742,7 +742,7 @@ fn report_function<T: std::fmt::Display>(
let projection_ty = pred.skip_binder().projection_ty;
let substs_with_infer_self = tcx.mk_substs(
iter::once(tcx.mk_ty_var(ty::TyVid { index: 0 }).into())
iter::once(tcx.mk_ty_var(ty::TyVid::from_u32(0)).into())
.chain(projection_ty.substs.iter().skip(1)),
);