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;
///////////////////////////////////////////////////////////////////////////
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);
}
///////////////////////////////////////////////////////////////////////////
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(..) => {
}
_ => { }
}
-
- visit::walk_item(self, i);
}
}
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);
}
}
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);
}
}
// 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,
ccx.method_ty(trait_item.id),
tcx.mk_self_type(),
&sig.explicit_self,
- it.id)
+ the_scope,
+ the_id)
}
},
hir::ItemStruct(ref struct_def, _) => {
def: ty::AdtDefMaster<'tcx>,
scheme: ty::TypeScheme<'tcx>,
predicates: ty::GenericPredicates<'tcx>,
- variants: &[P<hir::Variant>]) {
+ 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()) {
ast_generics: &hir::Generics,
trait_predicates: &ty::GenericPredicates<'tcx>,
self_trait_ref: ty::TraitRef<'tcx>,
- trait_items: &[P<hir::TraitItem>])
+ trait_items: &[hir::TraitItem])
-> Vec<ty::Predicate<'tcx>>
{
trait_items.iter().flat_map(|trait_item| {
method_type: Rc<ty::Method<'tcx>>,
required_type: Ty<'tcx>,
explicit_self: &hir::ExplicitSelf,
+ body_scope: region::CodeExtent,
body_id: ast::NodeId)
{
let tcx = ccx.tcx;
_ => 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
// 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,
fn enforce_impl_lifetimes_are_constrained<'tcx>(tcx: &ty::ctxt<'tcx>,
ast_generics: &hir::Generics,
impl_def_id: DefId,
- impl_items: &[P<hir::ImplItem>])
+ impl_items: &[hir::ImplItem])
{
// Every lifetime used in an associated type must be constrained.
let impl_scheme = tcx.lookup_item_type(impl_def_id);
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);
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),