})
}
+ pub fn opt_associated_item(self, def_id: DefId) -> Option<AssociatedItem> {
+ let is_associated_item = if let Some(node_id) = self.hir.as_local_node_id(def_id) {
+ match self.hir.get(node_id) {
+ hir_map::NodeTraitItem(_) | hir_map::NodeImplItem(_) => true,
+ _ => false,
+ }
+ } else {
+ match self.sess.cstore.describe_def(def_id).expect("no def for def-id") {
+ Def::AssociatedConst(_) | Def::Method(_) | Def::AssociatedTy(_) => true,
+ _ => false,
+ }
+ };
+
+ if is_associated_item {
+ Some(self.associated_item(def_id))
+ } else {
+ None
+ }
+ }
+
fn associated_item_from_trait_item_ref(self,
parent_def_id: DefId,
parent_vis: &hir::Visibility,
None
}
} else {
- self.maps.associated_item.borrow().get(&def_id).cloned()
+ self.opt_associated_item(def_id)
};
match item {
if def_id.krate != LOCAL_CRATE {
return self.sess.cstore.trait_of_item(def_id);
}
- match self.maps.associated_item.borrow().get(&def_id) {
- Some(associated_item) => {
+ self.opt_associated_item(def_id)
+ .and_then(|associated_item| {
match associated_item.container {
TraitContainer(def_id) => Some(def_id),
ImplContainer(_) => None
}
- }
- None => None
- }
+ })
}
/// Construct a parameter environment suitable for static contexts or other contexts where there
}
}
- ref r => {
- panic!("unexpected container of associated items: {:?}", r)
- }
+ _ => { }
}
- panic!("associated item not found for def_id: {:?}", def_id);
+
+ span_bug!(parent_item.span,
+ "unexpected parent of trait or impl item or item not found: {:?}",
+ parent_item.node)
}
/// Calculates the Sized-constraint.
PlainImpl,
}
-pub fn method_context(cx: &LateContext, id: ast::NodeId, span: Span) -> MethodLateContext {
+pub fn method_context(cx: &LateContext, id: ast::NodeId) -> MethodLateContext {
let def_id = cx.tcx.hir.local_def_id(id);
- match cx.tcx.maps.associated_item.borrow().get(&def_id) {
- None => span_bug!(span, "missing method descriptor?!"),
- Some(item) => {
- match item.container {
- ty::TraitContainer(..) => MethodLateContext::TraitDefaultImpl,
- ty::ImplContainer(cid) => {
- match cx.tcx.impl_trait_ref(cid) {
- Some(_) => MethodLateContext::TraitImpl,
- None => MethodLateContext::PlainImpl,
- }
- }
+ let item = cx.tcx.associated_item(def_id);
+ match item.container {
+ ty::TraitContainer(..) => MethodLateContext::TraitDefaultImpl,
+ ty::ImplContainer(cid) => {
+ match cx.tcx.impl_trait_ref(cid) {
+ Some(_) => MethodLateContext::TraitImpl,
+ None => MethodLateContext::PlainImpl,
}
}
}
id: ast::NodeId) {
match fk {
FnKind::Method(name, ..) => {
- match method_context(cx, id, span) {
+ match method_context(cx, id) {
MethodLateContext::PlainImpl => {
self.check_snake_case(cx, "method", &name.as_str(), Some(span))
}
fn check_impl_item(&mut self, cx: &LateContext, impl_item: &hir::ImplItem) {
// If the method is an impl for a trait, don't doc.
- if method_context(cx, impl_item.id, impl_item.span) == MethodLateContext::TraitImpl {
+ if method_context(cx, impl_item.id) == MethodLateContext::TraitImpl {
return;
}
EntryKind::AssociatedType(container) => {
(ty::AssociatedKind::Type, container, false)
}
- _ => bug!()
+ _ => bug!("cannot get associated-item of `{:?}`", def_key)
};
ty::AssociatedItem {