use syntax::attr;
use syntax::ast::{self, Ident};
use syntax::codemap;
-use syntax::symbol::{InternedString, Symbol};
+use syntax::symbol::InternedString;
use syntax::ext::base::MacroKind;
use syntax_pos::{self, Span, BytePos, Pos, DUMMY_SP, NO_EXPANSION};
ty::VariantDef {
did: self.local_def_id(data.struct_ctor.unwrap_or(index)),
- name: Symbol::intern(&self.item_name(index)),
+ name: self.item_name(index).as_symbol(),
fields: item.children.decode(self).map(|index| {
let f = self.entry(index);
ty::FieldDef {
did: self.local_def_id(index),
- name: Symbol::intern(&self.item_name(index)),
+ name: self.item_name(index).as_symbol(),
vis: f.visibility.decode(self)
}
}).collect(),
if let Some(def) = self.get_def(child_index) {
callback(def::Export {
def,
- ident: Ident::from_str(&self.item_name(child_index)),
+ ident: Ident::from_interned_str(self.item_name(child_index)),
vis: self.get_visibility(child_index),
span: self.entry(child_index).span.decode((self, sess)),
is_import: false,
let span = child.span.decode((self, sess));
if let (Some(def), Some(name)) =
(self.get_def(child_index), def_key.disambiguated_data.data.get_opt_name()) {
- let ident = Ident::from_str(&name);
+ let ident = Ident::from_interned_str(name);
let vis = self.get_visibility(child_index);
let is_import = false;
callback(def::Export { def, ident, vis, span, is_import });
};
ty::AssociatedItem {
- name: Symbol::intern(&name),
+ name: name.as_symbol(),
kind,
vis: item.visibility.decode(self),
defaultness: container.defaultness(),
self.entry(id)
.children
.decode(self)
- .map(|index| Symbol::intern(&self.item_name(index)))
+ .map(|index| self.item_name(index).as_symbol())
.collect()
}
}
pub fn get_trait_of_item(&self, id: DefIndex) -> Option<DefId> {
- self.def_key(id).parent.and_then(|parent_index| {
+ let def_key = self.def_key(id);
+ match def_key.disambiguated_data.data {
+ DefPathData::TypeNs(..) | DefPathData::ValueNs(..) => (),
+ // Not an associated item
+ _ => return None,
+ }
+ def_key.parent.and_then(|parent_index| {
match self.entry(parent_index).kind {
EntryKind::Trait(_) => Some(self.local_def_id(parent_index)),
_ => None,
DefKey {
parent: Some(CRATE_DEF_INDEX),
disambiguated_data: DisambiguatedDefPathData {
- data: DefPathData::MacroDef(name.as_str()),
+ data: DefPathData::MacroDef(name.as_interned_str()),
disambiguator: 0,
}
}