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

Take advantage of the lifetime refactoring

Browse Source
This commit is contained in:
varkor 2018-05-31 15:52:17 +01:00
parent 6015edf9af
commit 831b5c02df
8 changed files with 50 additions and 66 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
src/librustc/hir/intravisit.rs
View File

@ -743,20 +743,19 @@ pub fn walk_param_bound<'v, V: Visitor<'v>>(visitor: &mut V, bound: &'v ParamBou
pub fn walk_generic_param<'v, V: Visitor<'v>>(visitor: &mut V, param: &'v GenericParam) {
visitor.visit_id(param.id);
match param.kind {
GenericParamKind::Lifetime { ref bounds, ref lifetime, .. } => {
match lifetime.name {
GenericParamKind::Lifetime { ref lt_name, .. } => {
match lt_name {
LifetimeName::Name(name) => {
visitor.visit_name(param.span, name);
visitor.visit_name(param.span, *name);
}
LifetimeName::Fresh(_) |
LifetimeName::Static |
LifetimeName::Implicit |
LifetimeName::Underscore => {}
}
walk_list!(visitor, visit_lifetime, bounds);
}
GenericParamKind::Type { name, ref bounds, ref default, ref attrs, .. } => {
visitor.visit_name(param.span, name);
GenericParamKind::Type { ref default, ref attrs, .. } => {
visitor.visit_name(param.span, param.name);
walk_list!(visitor, visit_ty, default);
walk_list!(visitor, visit_attribute, attrs.iter());
}

8
src/librustc/hir/lowering.rs
View File

@ -1747,8 +1747,8 @@ impl<'a> LoweringContext<'a> {
fn lower_parenthesized_parameter_data(
&mut self,
data: &ParenthesizedParameterData,
) -> (hir::PathParameters, bool) {
data: &ParenthesizedArgData,
) -> (hir::GenericArgs, bool) {
// Switch to `PassThrough` mode for anonymous lifetimes: this
// means that we permit things like `&Ref<T>`, where `Ref` has
// a hidden lifetime parameter. This is needed for backwards
@ -1758,7 +1758,7 @@ impl<'a> LoweringContext<'a> {
AnonymousLifetimeMode::PassThrough,
|this| {
const DISALLOWED: ImplTraitContext = ImplTraitContext::Disallowed;
let &ParenthesizedParameterData { ref inputs, ref output, span } = data;
let &ParenthesizedArgData { ref inputs, ref output, span } = data;
let inputs = inputs.iter().map(|ty| this.lower_ty(ty, DISALLOWED)).collect();
let mk_tup = |this: &mut Self, tys, span| {
let LoweredNodeId { node_id, hir_id } = this.next_id();
@ -1767,7 +1767,7 @@ impl<'a> LoweringContext<'a> {
(
hir::GenericArgs {
parameters: hir_vec![GenericArg::Type(mk_tup(this, inputs, span))],
args: hir_vec![GenericArg::Type(mk_tup(this, inputs, span))],
bindings: hir_vec![
hir::TypeBinding {
id: this.next_id().node_id,

9
src/librustc/hir/map/collector.rs
View File

@ -347,14 +347,7 @@ impl<'a, 'hir> Visitor<'hir> for NodeCollector<'a, 'hir> {
}
fn visit_generic_param(&mut self, param: &'hir GenericParam) {
match param.kind {
GenericParamKind::Lifetime { ref lifetime_deprecated, .. } => {
self.insert(param.id, NodeLifetime(lifetime_deprecated));
}
GenericParamKind::Type { .. } => {
self.insert(param.id, NodeGenericParam(param));
}
}
self.insert(param.id, NodeGenericParam(param));
intravisit::walk_generic_param(self, param);
}

11
src/librustc/middle/resolve_lifetime.rs
View File

@ -110,8 +110,8 @@ impl Region {
let depth = ty::INNERMOST;
let (name, def_id, origin) = new_region(hir_map, param);
debug!(
"Region::late: def={:?} depth={:?} def_id={:?} origin={:?}",
def,
"Region::late: param={:?} depth={:?} def_id={:?} origin={:?}",
param,
depth,
def_id,
origin,
@ -2243,8 +2243,7 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> {
for (i, (lifetime_i, lifetime_i_name)) in lifetimes.iter().enumerate() {
match lifetime_i_name {
hir::LifetimeName::Static | hir::LifetimeName::Underscore => {
let lifetime = lifetime_i.lifetime;
let name = lifetime_i.name();
let name = lifetime_i.name;
let mut err = struct_span_err!(
self.tcx.sess,
lifetime_i.span,
@ -2518,10 +2517,10 @@ fn insert_late_bound_lifetimes(
for param in &generics.params {
match param.kind {
hir::GenericParamKind::Lifetime { .. } => {
hir::GenericParamKind::Lifetime { lt_name, .. } => {
if !param.bounds.is_empty() {
// `'a: 'b` means both `'a` and `'b` are referenced
appears_in_where_clause.regions.insert(lifetime_def.lifetime.name);
appears_in_where_clause.regions.insert(lt_name);
}
}
hir::GenericParamKind::Type { .. } => {}

4
src/librustc_passes/ast_validation.rs
View File

@ -431,8 +431,8 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
}
fn visit_generic_param(&mut self, param: &'a GenericParam) {
if let GenericParam::Lifetime(ref ld) = *param {
self.check_lifetime(ld.lifetime.ident);
if let GenericParamKind::Lifetime { .. } = param.kind {
self.check_lifetime(param.ident);
}
visit::walk_generic_param(self, param);
}

2
src/libsyntax/ast.rs
View File

@ -309,8 +309,8 @@ pub enum GenericParamKind {
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
pub struct GenericParam {
pub ident: Ident,
pub id: NodeId,
pub ident: Ident,
pub attrs: ThinVec<Attribute>,
pub bounds: ParamBounds,

60
src/libsyntax/fold.rs
View File

@ -143,6 +143,10 @@ pub trait Folder : Sized {
noop_fold_ty(t, self)
}
fn fold_lifetime(&mut self, l: Lifetime) -> Lifetime {
noop_fold_lifetime(l, self)
}
fn fold_ty_binding(&mut self, t: TypeBinding) -> TypeBinding {
noop_fold_ty_binding(t, self)
}
@ -240,10 +244,6 @@ pub trait Folder : Sized {
noop_fold_variant_data(vdata, self)
}
fn fold_ty_param(&mut self, tp: TyParam) -> TyParam {
noop_fold_ty_param(tp, self)
}
fn fold_generic_param(&mut self, param: GenericParam) -> GenericParam {
noop_fold_generic_param(param, self)
}
@ -268,17 +268,16 @@ pub trait Folder : Sized {
noop_fold_interpolated(nt, self)
}
fn fold_opt_bounds(&mut self, b: Option<TyParamBounds>) -> Option<TyParamBounds> {
fn fold_opt_bounds(&mut self, b: Option<ParamBounds>) -> Option<ParamBounds> {
noop_fold_opt_bounds(b, self)
}
fn fold_bounds(&mut self, b: ParamBounds)
-> ParamBounds {
fn fold_bounds(&mut self, b: ParamBounds) -> ParamBounds {
noop_fold_bounds(b, self)
}
fn fold_ty_param_bound(&mut self, tpb: ParamBound) -> ParamBound {
noop_fold_ty_param_bound(tpb, self)
fn fold_param_bound(&mut self, tpb: ParamBound) -> ParamBound {
noop_fold_param_bound(tpb, self)
}
fn fold_mt(&mut self, mt: MutTy) -> MutTy {
@ -391,10 +390,10 @@ pub fn noop_fold_ty<T: Folder>(t: P<Ty>, fld: &mut T) -> P<Ty> {
TyKind::Typeof(fld.fold_anon_const(expr))
}
TyKind::TraitObject(bounds, syntax) => {
TyKind::TraitObject(bounds.move_map(|b| fld.fold_ty_param_bound(b)), syntax)
TyKind::TraitObject(bounds.move_map(|b| fld.fold_param_bound(b)), syntax)
}
TyKind::ImplTrait(bounds) => {
TyKind::ImplTrait(bounds.move_map(|b| fld.fold_ty_param_bound(b)))
TyKind::ImplTrait(bounds.move_map(|b| fld.fold_param_bound(b)))
}
TyKind::Mac(mac) => {
TyKind::Mac(fld.fold_mac(mac))
@ -677,32 +676,31 @@ pub fn noop_fold_fn_decl<T: Folder>(decl: P<FnDecl>, fld: &mut T) -> P<FnDecl> {
})
}
pub fn noop_fold_ty_param_bound<T>(tpb: ParamBound, fld: &mut T)
-> ParamBound
where T: Folder {
match tpb {
TraitTyParamBound(ty, modifier) => TraitTyParamBound(fld.fold_poly_trait_ref(ty), modifier),
pub fn noop_fold_param_bound<T>(pb: ParamBound, fld: &mut T) -> ParamBound where T: Folder {
match pb {
TraitTyParamBound(ty, modifier) => {
TraitTyParamBound(fld.fold_poly_trait_ref(ty), modifier)
}
Outlives(lifetime) => Outlives(noop_fold_lifetime(lifetime, fld)),
}
}
pub fn noop_fold_generic_param<T: Folder>(param: GenericParam, fld: &mut T) -> GenericParam {
match param.kind {
GenericParamKind::Lifetime { bounds, lifetime } => {
let attrs: Vec<_> = param.attrs.into();
GenericParamKind::Lifetime(LifetimeDef {
attrs: attrs.into_iter()
let attrs: Vec<_> = param.attrs.into();
GenericParam {
ident: fld.fold_ident(param.ident),
id: fld.new_id(param.id),
attrs: attrs.into_iter()
.flat_map(|x| fld.fold_attribute(x).into_iter())
.collect::<Vec<_>>()
.into(),
lifetime: Lifetime {
id: fld.new_id(param.id),
ident: fld.fold_ident(param.ident),
},
bounds: bounds.move_map(|l| noop_fold_lifetime(l, fld)),
})
bounds: param.bounds.move_map(|l| noop_fold_param_bound(l, fld)),
kind: match param.kind {
GenericParamKind::Lifetime => GenericParamKind::Lifetime,
GenericParamKind::Type { default } => GenericParamKind::Type {
default: default.map(|ty| fld.fold_ty(ty))
}
}
GenericParamKind::Type { .. } => GenericParamKind::Type(fld.fold_ty_param(param)),
}
}
@ -760,7 +758,7 @@ pub fn noop_fold_where_predicate<T: Folder>(
ast::WherePredicate::BoundPredicate(ast::WhereBoundPredicate {
bound_generic_params: fld.fold_generic_params(bound_generic_params),
bounded_ty: fld.fold_ty(bounded_ty),
bounds: bounds.move_map(|x| fld.fold_ty_param_bound(x)),
bounds: bounds.move_map(|x| fld.fold_param_bound(x)),
span: fld.new_span(span)
})
}
@ -770,7 +768,7 @@ pub fn noop_fold_where_predicate<T: Folder>(
ast::WherePredicate::RegionPredicate(ast::WhereRegionPredicate {
span: fld.new_span(span),
lifetime: noop_fold_lifetime(lifetime, fld),
bounds: bounds.move_map(|bound| noop_fold_lifetime(bound, fld))
bounds: bounds.move_map(|bound| noop_fold_param_bound(bound, fld))
})
}
ast::WherePredicate::EqPredicate(ast::WhereEqPredicate{id,
@ -856,7 +854,7 @@ pub fn noop_fold_opt_bounds<T: Folder>(b: Option<ParamBounds>, folder: &mut T)
fn noop_fold_bounds<T: Folder>(bounds: ParamBounds, folder: &mut T)
-> ParamBounds {
bounds.move_map(|bound| folder.fold_ty_param_bound(bound))
bounds.move_map(|bound| folder.fold_param_bound(bound))
}
pub fn noop_fold_block<T: Folder>(b: P<Block>, folder: &mut T) -> P<Block> {

11
src/libsyntax/visit.rs
View File

@ -492,15 +492,10 @@ pub fn walk_param_bound<'a, V: Visitor<'a>>(visitor: &mut V, bound: &'a ParamBou
pub fn walk_generic_param<'a, V: Visitor<'a>>(visitor: &mut V, param: &'a GenericParam) {
visitor.visit_ident(param.ident);
walk_list!(visitor, visit_param_bound, &param.bounds);
match param.kind {
GenericParamKind::Lifetime { ref bounds, ref lifetime } => {
walk_list!(visitor, visit_lifetime, bounds);
}
GenericParamKind::Type { ref bounds, ref default } => {
visitor.visit_ident(t.ident);
walk_list!(visitor, visit_ty_param_bound, bounds);
walk_list!(visitor, visit_ty, default);
}
GenericParamKind::Lifetime => {}
GenericParamKind::Type { ref default } => walk_list!(visitor, visit_ty, default),
}
walk_list!(visitor, visit_attribute, param.attrs.iter());
}