squiid/rust
1
0
Fork 0
Code Issues Pull requests Projects Activity

Lift pure_wrt_drop to GenericParamDef

Browse source
This commit is contained in:
varkor 2018-05-10 23:46:57 +01:00
parent 9200bdee26
commit 007de2f896
17 changed files with 40 additions and 60 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
src/librustc/ich/impls_ty.rs
View file

@ -754,7 +754,7 @@ impl<'a> HashStable<StableHashingContext<'a>> for ty::Generics {
}
impl_stable_hash_for!(enum ty::GenericParamDefKind {
Lifetime(lt),
Lifetime,
Type(ty)
});
@ -762,17 +762,13 @@ impl_stable_hash_for!(struct ty::GenericParamDef {
name,
def_id,
index,
pure_wrt_drop,
kind
});
impl_stable_hash_for!(struct ty::LifetimeParamDef {
pure_wrt_drop
});
impl_stable_hash_for!(struct ty::TypeParamDef {
has_default,
object_lifetime_default,
pure_wrt_drop,
synthetic
});

2
src/librustc/infer/anon_types/mod.rs
View file

@ -315,7 +315,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
let mut least_region = None;
for param in &abstract_type_generics.params {
match param.kind {
GenericParamDefKind::Lifetime(_) => {}
GenericParamDefKind::Lifetime => {}
_ => continue
}
// Get the value supplied for this region from the substs.

2
src/librustc/middle/resolve_lifetime.rs
View file

@ -1666,7 +1666,7 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> {
GenericParamDefKind::Type(ty) => {
Some(ty.object_lifetime_default)
}
GenericParamDefKind::Lifetime(_) => None,
GenericParamDefKind::Lifetime => None,
}
})
.collect()

2
src/librustc/traits/auto_trait.rs
View file

@ -226,7 +226,7 @@ impl<'a, 'tcx> AutoTraitFinder<'a, 'tcx> {
.iter()
.filter_map(|param| {
match param.kind {
ty::GenericParamDefKind::Lifetime(_) => Some(param.name.to_string()),
ty::GenericParamDefKind::Lifetime => Some(param.name.to_string()),
_ => None
}
})

2
src/librustc/traits/error_reporting.rs
View file

@ -386,7 +386,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
let ty = trait_ref.substs.type_for_def(&param);
ty.to_string()
},
GenericParamDefKind::Lifetime(_) => continue,
GenericParamDefKind::Lifetime => continue,
};
flags.push((name.clone(), Some(value.clone())));
}

2
src/librustc/traits/on_unimplemented.rs
View file

@ -293,7 +293,7 @@ impl<'a, 'gcx, 'tcx> OnUnimplementedFormatString {
Some((param.name.to_string(),
trait_ref.substs.type_for_def(&param).to_string()))
},
GenericParamDefKind::Lifetime(_) => None
GenericParamDefKind::Lifetime => None
}
}).collect::<FxHashMap<String, String>>();

39
src/librustc/ty/mod.rs
View file

@ -713,23 +713,9 @@ pub struct FloatVarValue(pub ast::FloatTy);
pub struct TypeParamDef {
pub has_default: bool,
pub object_lifetime_default: ObjectLifetimeDefault,
/// `pure_wrt_drop`, set by the (unsafe) `#[may_dangle]` attribute
/// on generic parameter `T`, asserts data behind the parameter
/// `T` won't be accessed during the parent type's `Drop` impl.
pub pure_wrt_drop: bool,
pub synthetic: Option<hir::SyntheticTyParamKind>,
}
#[derive(Copy, Clone, Debug, RustcEncodable, RustcDecodable)]
pub struct LifetimeParamDef {
/// `pure_wrt_drop`, set by the (unsafe) `#[may_dangle]` attribute
/// on generic parameter `'a`, asserts data of lifetime `'a`
/// won't be accessed during the parent type's `Drop` impl.
pub pure_wrt_drop: bool,
}
impl ty::EarlyBoundRegion {
pub fn to_bound_region(&self) -> ty::BoundRegion {
ty::BoundRegion::BrNamed(self.def_id, self.name)
@ -738,7 +724,7 @@ impl ty::EarlyBoundRegion {
#[derive(Clone, Debug, RustcEncodable, RustcDecodable)]
pub enum GenericParamDefKind {
Lifetime(LifetimeParamDef),
Lifetime,
Type(TypeParamDef),
}
@ -747,17 +733,16 @@ pub struct GenericParamDef {
pub name: InternedString,
pub def_id: DefId,
pub index: u32,
/// `pure_wrt_drop`, set by the (unsafe) `#[may_dangle]` attribute
/// on generic parameter `'a`/`T`, asserts data behind the parameter
/// `'a`/`T` won't be accessed during the parent type's `Drop` impl.
pub pure_wrt_drop: bool,
pub kind: GenericParamDefKind,
}
impl GenericParamDef {
pub fn to_lifetime(&self) -> LifetimeParamDef {
match self.kind {
GenericParamDefKind::Lifetime(lt) => lt,
_ => bug!("cannot convert a non-lifetime to a lifetime")
}
}
pub fn to_type(&self) -> TypeParamDef {
match self.kind {
GenericParamDefKind::Type(ty) => ty,
@ -767,7 +752,7 @@ impl GenericParamDef {
pub fn to_early_bound_region_data(&self) -> ty::EarlyBoundRegion {
match self.kind {
GenericParamDefKind::Lifetime(_) => {
GenericParamDefKind::Lifetime => {
ty::EarlyBoundRegion {
def_id: self.def_id,
index: self.index,
@ -780,7 +765,7 @@ impl GenericParamDef {
pub fn to_bound_region(&self) -> ty::BoundRegion {
match self.kind {
GenericParamDefKind::Lifetime(_) => {
GenericParamDefKind::Lifetime => {
self.to_early_bound_region_data().to_bound_region()
}
_ => bug!("cannot convert a non-lifetime parameter def to an early bound region")
@ -827,7 +812,7 @@ impl<'a, 'gcx, 'tcx> Generics {
for param in self.params.iter() {
match param.kind {
GenericParamDefKind::Lifetime(_) => param_counts.lifetimes += 1,
GenericParamDefKind::Lifetime => param_counts.lifetimes += 1,
GenericParamDefKind::Type(_) => param_counts.types += 1,
};
}
@ -839,7 +824,7 @@ impl<'a, 'gcx, 'tcx> Generics {
for param in self.params.iter() {
match param.kind {
GenericParamDefKind::Type(_) => return true,
GenericParamDefKind::Lifetime(_) => {}
GenericParamDefKind::Lifetime => {}
}
}
if let Some(parent_def_id) = self.parent {
@ -858,7 +843,7 @@ impl<'a, 'gcx, 'tcx> Generics {
if let Some(index) = param.index.checked_sub(self.parent_count as u32) {
let param = &self.params[index as usize];
match param.kind {
ty::GenericParamDefKind::Lifetime(_) => param,
ty::GenericParamDefKind::Lifetime => param,
_ => bug!("expected region parameter, but found another generic parameter")
}
} else {

2
src/librustc/ty/subst.rs
View file

@ -243,7 +243,7 @@ impl<'a, 'gcx, 'tcx> Substs<'tcx> {
FT: FnMut(&ty::GenericParamDef, &[Kind<'tcx>]) -> Ty<'tcx> {
for param in &defs.params {
let kind = match param.kind {
ty::GenericParamDefKind::Lifetime(_) => mk_region(param, substs).into(),
ty::GenericParamDefKind::Lifetime => mk_region(param, substs).into(),
ty::GenericParamDefKind::Type(_) => mk_type(param, substs).into(),
};
assert_eq!(param.index as usize, substs.len());

4
src/librustc/ty/util.rs
View file

@ -505,12 +505,12 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
.filter(|&(_, &k)| {
match k.unpack() {
UnpackedKind::Lifetime(&ty::RegionKind::ReEarlyBound(ref ebr)) => {
!impl_generics.region_param(ebr, self).to_lifetime().pure_wrt_drop
!impl_generics.region_param(ebr, self).pure_wrt_drop
}
UnpackedKind::Type(&ty::TyS {
sty: ty::TypeVariants::TyParam(ref pt), ..
}) => {
!impl_generics.type_param(pt, self).to_type().pure_wrt_drop
!impl_generics.type_param(pt, self).pure_wrt_drop
}
UnpackedKind::Lifetime(_) | UnpackedKind::Type(_) => {
// not a type or region param - this should be reported

4
src/librustc/util/ppaux.rs
View file

@ -340,7 +340,7 @@ impl PrintContext {
generics.params.iter().rev().filter_map(|param| {
match param.kind {
GenericParamDefKind::Type(ty) => Some((param.def_id, ty.has_default)),
GenericParamDefKind::Lifetime(_) => None,
GenericParamDefKind::Lifetime => None,
}
});
if let Some(last_ty) = type_params.next() {
@ -606,7 +606,7 @@ define_print! {
impl fmt::Debug for ty::GenericParamDef {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let type_name = match self.kind {
ty::GenericParamDefKind::Lifetime(_) => "Lifetime",
ty::GenericParamDefKind::Lifetime => "Lifetime",
ty::GenericParamDefKind::Type(_) => "Type",
};
write!(f, "{}({}, {:?}, {})",

4
src/librustc_privacy/lib.rs
View file

@ -406,7 +406,7 @@ impl<'b, 'a, 'tcx> ReachEverythingInTheInterfaceVisitor<'b, 'a, 'tcx> {
self.ev.tcx.type_of(param.def_id).visit_with(self);
}
}
GenericParamDefKind::Lifetime(_) => {}
GenericParamDefKind::Lifetime => {}
}
}
self
@ -1347,7 +1347,7 @@ impl<'a, 'tcx: 'a> SearchInterfaceForPrivateItemsVisitor<'a, 'tcx> {
self.tcx.type_of(param.def_id).visit_with(self);
}
}
GenericParamDefKind::Lifetime(_) => {}
GenericParamDefKind::Lifetime => {}
}
}
self

4
src/librustc_typeck/check/compare_method.rs
View file

@ -731,13 +731,13 @@ fn compare_synthetic_generics<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
let impl_m_type_params = impl_m_generics.params.iter().filter_map(|param| {
match param.kind {
GenericParamDefKind::Type(_) => Some(param),
GenericParamDefKind::Lifetime(_) => None,
GenericParamDefKind::Lifetime => None,
}
});
let trait_m_type_params = trait_m_generics.params.iter().filter_map(|param| {
match param.kind {
GenericParamDefKind::Type(_) => Some(param),
GenericParamDefKind::Lifetime(_) => None,
GenericParamDefKind::Lifetime => None,
}
});
for (impl_ty, trait_ty) in impl_m_type_params.zip(trait_m_type_params) {

4
src/librustc_typeck/check/wfcheck.rs
View file

@ -652,7 +652,7 @@ fn reject_shadowing_parameters(tcx: TyCtxt, def_id: DefId) {
parent.params.iter()
.flat_map(|param| {
match param.kind {
GenericParamDefKind::Lifetime(_) => None,
GenericParamDefKind::Lifetime => None,
GenericParamDefKind::Type(_) => Some((param.name, param.def_id)),
}
})
@ -661,7 +661,7 @@ fn reject_shadowing_parameters(tcx: TyCtxt, def_id: DefId) {
for method_param in generics.params.iter() {
match method_param.kind {
// Shadowing is checked in resolve_lifetime.
GenericParamDefKind::Lifetime(_) => continue,
GenericParamDefKind::Lifetime => continue,
_ => {},
};
if impl_params.contains_key(&method_param.name) {

13
src/librustc_typeck/collect.rs
View file

@ -844,10 +844,10 @@ fn generics_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
index: 0,
name: keywords::SelfType.name().as_interned_str(),
def_id: tcx.hir.local_def_id(param_id),
pure_wrt_drop: false,
kind: ty::GenericParamDefKind::Type(ty::TypeParamDef {
has_default: false,
object_lifetime_default: rl::Set1::Empty,
pure_wrt_drop: false,
synthetic: None,
}),
});
@ -892,9 +892,8 @@ fn generics_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
name: l.lifetime.name.name().as_interned_str(),
index: own_start + i as u32,
def_id: tcx.hir.local_def_id(l.lifetime.id),
kind: ty::GenericParamDefKind::Lifetime(ty::LifetimeParamDef {
pure_wrt_drop: l.pure_wrt_drop,
}),
pure_wrt_drop: l.pure_wrt_drop,
kind: ty::GenericParamDefKind::Lifetime,
}
}).collect::<Vec<_>>();
@ -923,11 +922,11 @@ fn generics_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
index: type_start + i as u32,
name: p.name.as_interned_str(),
def_id: tcx.hir.local_def_id(p.id),
pure_wrt_drop: p.pure_wrt_drop,
kind: ty::GenericParamDefKind::Type(ty::TypeParamDef {
has_default: p.default.is_some(),
object_lifetime_default:
object_lifetime_defaults.as_ref().map_or(rl::Set1::Empty, |o| o[i]),
pure_wrt_drop: p.pure_wrt_drop,
synthetic: p.synthetic,
}),
}
@ -948,10 +947,10 @@ fn generics_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
index: type_start + i as u32,
name: Symbol::intern(arg).as_interned_str(),
def_id,
pure_wrt_drop: false,
kind: ty::GenericParamDefKind::Type(ty::TypeParamDef {
has_default: false,
object_lifetime_default: rl::Set1::Empty,
pure_wrt_drop: false,
synthetic: None,
}),
});
@ -963,10 +962,10 @@ fn generics_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
index: type_start + i,
name: Symbol::intern("<upvar>").as_interned_str(),
def_id,
pure_wrt_drop: false,
kind: ty::GenericParamDefKind::Type(ty::TypeParamDef {
has_default: false,
object_lifetime_default: rl::Set1::Empty,
pure_wrt_drop: false,
synthetic: None,
}),
}

4
src/librustc_typeck/impl_wf_check.rs
View file

@ -125,7 +125,7 @@ fn enforce_impl_params_are_constrained<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
report_unused_parameter(tcx, hir_ty.span, "type", &param_ty.to_string());
}
}
(&ty::GenericParamDefKind::Lifetime(_), hir::GenericParam::Lifetime(hir_lt)) => {
(&ty::GenericParamDefKind::Lifetime, hir::GenericParam::Lifetime(hir_lt)) => {
let param = ctp::Parameter::from(ty_param.to_early_bound_region_data());
if lifetimes_in_associated_types.contains(&param) && // (*)
!input_parameters.contains(&param) {
@ -134,7 +134,7 @@ fn enforce_impl_params_are_constrained<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
}
}
(&ty::GenericParamDefKind::Type(_), _) => continue,
(&ty::GenericParamDefKind::Lifetime(_), _) => continue,
(&ty::GenericParamDefKind::Lifetime, _) => continue,
}
}

2
src/librustdoc/clean/auto_trait.rs
View file

@ -229,7 +229,7 @@ impl<'a, 'tcx, 'rcx> AutoTraitFinder<'a, 'tcx, 'rcx> {
for param in generics.params.iter() {
match param.kind {
ty::GenericParamDefKind::Lifetime(_) => {
ty::GenericParamDefKind::Lifetime => {
let name = if param.name == "" {
hir::LifetimeName::Static
} else {

2
src/librustdoc/clean/mod.rs
View file

@ -1855,7 +1855,7 @@ impl<'a, 'tcx> Clean<Generics> for (&'a ty::Generics,
params: gens.params
.iter()
.flat_map(|param| {
if let ty::GenericParamDefKind::Lifetime(_) = param.kind {
if let ty::GenericParamDefKind::Lifetime = param.kind {
Some(GenericParamDef::Lifetime(param.clean(cx)))
} else {
None