X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Flibrustc_typeck%2Fcollect.rs;h=bfe4151da5c91c3c99cff4b6b722ed057b9a47a9;hb=4af427881405f95b8d87efea844cbd695fb55986;hp=80f90182992458f0f31608855d83cd56056537b6;hpb=fb6687150c9e89e0b0876e986a954fd647781499;p=rust.git diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs index 80f90182992..bfe4151da5c 100644 --- a/src/librustc_typeck/collect.rs +++ b/src/librustc_typeck/collect.rs @@ -98,7 +98,7 @@ use syntax::parse::token::special_idents; use syntax::ptr::P; use rustc_front::hir; -use rustc_front::visit; +use rustc_front::intravisit; use rustc_front::print::pprust; /////////////////////////////////////////////////////////////////////////// @@ -108,10 +108,10 @@ pub fn collect_item_types(tcx: &ty::ctxt) { let ccx = &CrateCtxt { tcx: tcx, stack: RefCell::new(Vec::new()) }; let mut visitor = CollectTraitDefVisitor{ ccx: ccx }; - visit::walk_crate(&mut visitor, ccx.tcx.map.krate()); + ccx.tcx.map.krate().visit_all_items(&mut visitor); let mut visitor = CollectItemTypesVisitor{ ccx: ccx }; - visit::walk_crate(&mut visitor, ccx.tcx.map.krate()); + ccx.tcx.map.krate().visit_all_items(&mut visitor); } /////////////////////////////////////////////////////////////////////////// @@ -157,7 +157,7 @@ struct CollectTraitDefVisitor<'a, 'tcx: 'a> { ccx: &'a CrateCtxt<'a, 'tcx> } -impl<'a, 'tcx, 'v> visit::Visitor<'v> for CollectTraitDefVisitor<'a, 'tcx> { +impl<'a, 'tcx, 'v> intravisit::Visitor<'v> for CollectTraitDefVisitor<'a, 'tcx> { fn visit_item(&mut self, i: &hir::Item) { match i.node { hir::ItemTrait(..) => { @@ -166,8 +166,6 @@ fn visit_item(&mut self, i: &hir::Item) { } _ => { } } - - visit::walk_item(self, i); } } @@ -178,14 +176,14 @@ struct CollectItemTypesVisitor<'a, 'tcx: 'a> { ccx: &'a CrateCtxt<'a, 'tcx> } -impl<'a, 'tcx, 'v> visit::Visitor<'v> for CollectItemTypesVisitor<'a, 'tcx> { +impl<'a, 'tcx, 'v> intravisit::Visitor<'v> for CollectItemTypesVisitor<'a, 'tcx> { fn visit_item(&mut self, i: &hir::Item) { convert_item(self.ccx, i); - visit::walk_item(self, i); + intravisit::walk_item(self, i); } fn visit_foreign_item(&mut self, i: &hir::ForeignItem) { convert_foreign_item(self.ccx, i); - visit::walk_foreign_item(self, i); + intravisit::walk_foreign_item(self, i); } } @@ -891,11 +889,13 @@ fn convert_item(ccx: &CrateCtxt, it: &hir::Item) { for impl_item in impl_items { if let hir::ImplItemKind::Method(ref sig, ref body) = impl_item.node { let body_id = body.id; + let body_scope = ccx.tcx.region_maps.call_site_extent(impl_item.id, body_id); check_method_self_type(ccx, &BindingRscope::new(), ccx.method_ty(impl_item.id), selfty, &sig.explicit_self, + body_scope, body_id); } } @@ -990,8 +990,16 @@ fn convert_item(ccx: &CrateCtxt, it: &hir::Item) { // This must be done after `collect_trait_methods` so that // we have a method type stored for every method. for trait_item in trait_items { - let sig = match trait_item.node { - hir::MethodTraitItem(ref sig, _) => sig, + let (sig, the_scope, the_id) = match trait_item.node { + hir::MethodTraitItem(ref sig, Some(ref body)) => { + let body_scope = + ccx.tcx.region_maps.call_site_extent(trait_item.id, body.id); + (sig, body_scope, body.id) + } + hir::MethodTraitItem(ref sig, None) => { + let item_scope = ccx.tcx.region_maps.item_extent(trait_item.id); + (sig, item_scope, it.id) + } _ => continue }; check_method_self_type(ccx, @@ -999,7 +1007,8 @@ fn convert_item(ccx: &CrateCtxt, it: &hir::Item) { ccx.method_ty(trait_item.id), tcx.mk_self_type(), &sig.explicit_self, - it.id) + the_scope, + the_id) } }, hir::ItemStruct(ref struct_def, _) => { @@ -1063,7 +1072,7 @@ fn convert_enum_variant_types<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>, def: ty::AdtDefMaster<'tcx>, scheme: ty::TypeScheme<'tcx>, predicates: ty::GenericPredicates<'tcx>, - variants: &[P]) { + variants: &[hir::Variant]) { // fill the field types for (variant, ty_variant) in variants.iter().zip(def.variants.iter()) { for (f, ty_f) in variant.node.data.fields().iter().zip(ty_variant.fields.iter()) { @@ -1481,7 +1490,7 @@ fn predicates_for_associated_types<'a, 'tcx>(ccx: &CrateCtxt<'a, 'tcx>, ast_generics: &hir::Generics, trait_predicates: &ty::GenericPredicates<'tcx>, self_trait_ref: ty::TraitRef<'tcx>, - trait_items: &[P]) + trait_items: &[hir::TraitItem]) -> Vec> { trait_items.iter().flat_map(|trait_item| { @@ -2284,6 +2293,7 @@ fn check_method_self_type<'a, 'tcx, RS:RegionScope>( method_type: Rc>, required_type: Ty<'tcx>, explicit_self: &hir::ExplicitSelf, + body_scope: region::CodeExtent, body_id: ast::NodeId) { let tcx = ccx.tcx; @@ -2295,8 +2305,6 @@ fn check_method_self_type<'a, 'tcx, RS:RegionScope>( _ => typ, }; - let body_scope = tcx.region_maps.item_extent(body_id); - // "Required type" comes from the trait definition. It may // contain late-bound regions from the method, but not the // trait (since traits only have early-bound region @@ -2389,9 +2397,9 @@ fn enforce_impl_params_are_constrained<'tcx>(tcx: &ty::ctxt<'tcx>, // reachable from there, to start (if this is an inherent impl, // then just examine the self type). let mut input_parameters: HashSet<_> = - ctp::parameters_for_type(impl_scheme.ty).into_iter().collect(); + ctp::parameters_for_type(impl_scheme.ty, false).into_iter().collect(); if let Some(ref trait_ref) = impl_trait_ref { - input_parameters.extend(ctp::parameters_for_trait_ref(trait_ref)); + input_parameters.extend(ctp::parameters_for_trait_ref(trait_ref, false)); } ctp::setup_constraining_predicates(tcx, @@ -2412,7 +2420,7 @@ fn enforce_impl_params_are_constrained<'tcx>(tcx: &ty::ctxt<'tcx>, fn enforce_impl_lifetimes_are_constrained<'tcx>(tcx: &ty::ctxt<'tcx>, ast_generics: &hir::Generics, impl_def_id: DefId, - impl_items: &[P]) + impl_items: &[hir::ImplItem]) { // Every lifetime used in an associated type must be constrained. let impl_scheme = tcx.lookup_item_type(impl_def_id); @@ -2420,9 +2428,9 @@ fn enforce_impl_lifetimes_are_constrained<'tcx>(tcx: &ty::ctxt<'tcx>, let impl_trait_ref = tcx.impl_trait_ref(impl_def_id); let mut input_parameters: HashSet<_> = - ctp::parameters_for_type(impl_scheme.ty).into_iter().collect(); + ctp::parameters_for_type(impl_scheme.ty, false).into_iter().collect(); if let Some(ref trait_ref) = impl_trait_ref { - input_parameters.extend(ctp::parameters_for_trait_ref(trait_ref)); + input_parameters.extend(ctp::parameters_for_trait_ref(trait_ref, false)); } ctp::identify_constrained_type_params(tcx, &impl_predicates.predicates.as_slice(), impl_trait_ref, &mut input_parameters); @@ -2434,7 +2442,7 @@ fn enforce_impl_lifetimes_are_constrained<'tcx>(tcx: &ty::ctxt<'tcx>, ty::TypeTraitItem(ref assoc_ty) => assoc_ty.ty, ty::ConstTraitItem(..) | ty::MethodTraitItem(..) => None }) - .flat_map(|ty| ctp::parameters_for_type(ty)) + .flat_map(|ty| ctp::parameters_for_type(ty, true)) .filter_map(|p| match p { ctp::Parameter::Type(_) => None, ctp::Parameter::Region(r) => Some(r),