use middle::subst::{self, Subst};
use middle::traits;
use middle::ty::{self, Ty};
+use util::nodemap::FnvHashSet;
use syntax::ast;
use syntax::codemap::{self, Span};
if let Err(_) = infer::mk_eqty(&infcx, true, infer::TypeOrigin::Misc(drop_impl_span),
named_type, fresh_impl_self_ty) {
- span_err!(tcx.sess, drop_impl_span, E0366,
- "Implementations of Drop cannot be specialized");
let item_span = tcx.map.span(self_type_node_id);
- tcx.sess.span_note(item_span,
- "Use same sequence of generic type and region \
- parameters that is on the struct/enum definition");
+ struct_span_err!(tcx.sess, drop_impl_span, E0366,
+ "Implementations of Drop cannot be specialized")
+ .span_note(item_span,
+ "Use same sequence of generic type and region \
+ parameters that is on the struct/enum definition")
+ .emit();
return Err(());
}
if !assumptions_in_impl_context.contains(&predicate) {
let item_span = tcx.map.span(self_type_node_id);
- span_err!(tcx.sess, drop_impl_span, E0367,
- "The requirement `{}` is added only by the Drop impl.", predicate);
- tcx.sess.span_note(item_span,
- "The same requirement must be part of \
- the struct/enum definition");
+ struct_span_err!(tcx.sess, drop_impl_span, E0367,
+ "The requirement `{}` is added only by the Drop impl.", predicate)
+ .span_note(item_span,
+ "The same requirement must be part of \
+ the struct/enum definition")
+ .emit();
}
}
rcx: rcx,
span: span,
parent_scope: parent_scope,
- breadcrumbs: Vec::new(),
+ breadcrumbs: FnvHashSet()
},
TypeContext::Root,
typ,
Ok(()) => {}
Err(Error::Overflow(ref ctxt, ref detected_on_typ)) => {
let tcx = rcx.tcx();
- span_err!(tcx.sess, span, E0320,
- "overflow while adding drop-check rules for {}", typ);
+ let mut err = struct_span_err!(tcx.sess, span, E0320,
+ "overflow while adding drop-check rules for {}", typ);
match *ctxt {
TypeContext::Root => {
// no need for an additional note if the overflow
format!("`{}`", field)
};
span_note!(
- rcx.tcx().sess,
+ &mut err,
span,
"overflowed on {} field {} type: {}",
variant_name,
detected_on_typ);
}
}
+ err.emit();
}
}
}
struct DropckContext<'a, 'b: 'a, 'tcx: 'b> {
rcx: &'a mut Rcx<'b, 'tcx>,
/// types that have already been traversed
- breadcrumbs: Vec<Ty<'tcx>>,
+ breadcrumbs: FnvHashSet<Ty<'tcx>>,
/// span for error reporting
span: Span,
/// the scope reachable dtorck types must outlive
depth: usize) -> Result<(), Error<'tcx>>
{
let tcx = cx.rcx.tcx();
- let ty = cx.rcx.infcx().resolve_type_and_region_vars_if_possible(&ty);
-
// Issue #22443: Watch out for overflow. While we are careful to
// handle regular types properly, non-regular ones cause problems.
let recursion_limit = tcx.sess.recursion_limit.get();
return Err(Error::Overflow(context, ty))
}
- for breadcrumb in &mut cx.breadcrumbs {
- *breadcrumb =
- cx.rcx.infcx().resolve_type_and_region_vars_if_possible(breadcrumb);
- if *breadcrumb == ty {
- debug!("iterate_over_potentially_unsafe_regions_in_type \
- {}ty: {} scope: {:?} - cached",
- (0..depth).map(|_| ' ').collect::<String>(),
- ty, cx.parent_scope);
- return Ok(()); // we already visited this type
- }
- }
- cx.breadcrumbs.push(ty);
+ // canoncialize the regions in `ty` before inserting - infinitely many
+ // region variables can refer to the same region.
+ let ty = cx.rcx.infcx().resolve_type_and_region_vars_if_possible(&ty);
+ if !cx.breadcrumbs.insert(ty) {
+ debug!("iterate_over_potentially_unsafe_regions_in_type \
+ {}ty: {} scope: {:?} - cached",
+ (0..depth).map(|_| ' ').collect::<String>(),
+ ty, cx.parent_scope);
+ return Ok(()); // we already visited this type
+ }
debug!("iterate_over_potentially_unsafe_regions_in_type \
{}ty: {} scope: {:?}",
(0..depth).map(|_| ' ').collect::<String>(),