use rustc::mir;
use rustc::mir::visit::MutVisitor;
+use rustc::mir::repr::Location;
use std::cell::Cell;
use std::io;
use syntax::ast;
use syntax::codemap;
use syntax::print::pprust;
-use syntax::ptr::P;
use syntax_pos::{self, Span, BytePos, NO_EXPANSION};
pub type Cmd<'a> = &'a CrateMetadata;
pub fn crate_rustc_version(data: &[u8]) -> Option<String> {
let doc = rbml::Doc::new(data);
- reader::maybe_get_doc(doc, tag_rustc_version).map(|s| s.as_str())
+ reader::maybe_get_doc(doc, tag_rustc_version).map(|s| s.to_string())
}
pub fn load_xrefs(data: &[u8]) -> index::DenseIndex {
fn item_sort(item: rbml::Doc) -> Option<char> {
reader::tagged_docs(item, tag_item_trait_item_sort).nth(0).map(|doc| {
- doc.as_str_slice().as_bytes()[0] as char
+ doc.as_str().as_bytes()[0] as char
})
}
fn maybe_item_name(item: rbml::Doc) -> Option<ast::Name> {
reader::maybe_get_doc(item, tag_paths_data_name).map(|name| {
- let string = name.as_str_slice();
+ let string = name.as_str();
token::intern(string)
})
}
fn parse_associated_type_names(item_doc: rbml::Doc) -> Vec<ast::Name> {
let names_doc = reader::get_doc(item_doc, tag_associated_type_names);
reader::tagged_docs(names_doc, tag_associated_type_name)
- .map(|name_doc| token::intern(name_doc.as_str_slice()))
+ .map(|name_doc| token::intern(name_doc.as_str()))
.collect()
}
let name_doc = reader::get_doc(reexport_doc,
tag_items_data_item_reexport_name);
- let name = name_doc.as_str_slice();
+ let name = name_doc.as_str();
// This reexport may be in yet another crate.
let crate_data = if child_def_id.krate == cdata.cnum {
impl<'v, 'cdata, 'codemap> mir::visit::MutVisitor<'v>
for MirDefIdAndSpanTranslator<'cdata, 'codemap>
{
- fn visit_def_id(&mut self, def_id: &mut DefId) {
+ fn visit_def_id(&mut self, def_id: &mut DefId, _: Location) {
*def_id = translate_def_id(self.crate_metadata, *def_id);
}
}
}
-fn get_explicit_self(item: rbml::Doc) -> ty::ExplicitSelfCategory {
+fn get_explicit_self<'a, 'tcx>(item: rbml::Doc, tcx: TyCtxt<'a, 'tcx, 'tcx>)
+ -> ty::ExplicitSelfCategory<'tcx> {
fn get_mutability(ch: u8) -> hir::Mutability {
match ch as char {
'i' => hir::MutImmutable,
}
let explicit_self_doc = reader::get_doc(item, tag_item_trait_method_explicit_self);
- let string = explicit_self_doc.as_str_slice();
+ let string = explicit_self_doc.as_str();
let explicit_self_kind = string.as_bytes()[0];
match explicit_self_kind as char {
// FIXME(#4846) expl. region
'&' => {
ty::ExplicitSelfCategory::ByReference(
- ty::ReEmpty,
+ tcx.mk_region(ty::ReEmpty),
get_mutability(string.as_bytes()[1]))
}
_ => bug!("unknown self type code: `{}`", explicit_self_kind as char)
item_name(doc)
}
-pub fn is_static_method(cdata: Cmd, id: DefIndex) -> bool {
- let doc = cdata.lookup_item(id);
- match item_sort(doc) {
- Some('r') | Some('p') => {
- get_explicit_self(doc) == ty::ExplicitSelfCategory::Static
- }
- _ => false
- }
-}
-
pub fn get_impl_or_trait_item<'a, 'tcx>(cdata: Cmd, id: DefIndex, tcx: TyCtxt<'a, 'tcx, 'tcx>)
-> Option<ty::ImplOrTraitItem<'tcx>> {
let item_doc = cdata.lookup_item(id);
"the type {:?} of the method {:?} is not a function?",
ity, name)
};
- let explicit_self = get_explicit_self(item_doc);
+ let explicit_self = get_explicit_self(item_doc, tcx);
ty::MethodTraitItem(Rc::new(ty::Method::new(name,
generics,
}).collect()
}
-pub fn get_item_variances(cdata: Cmd, id: DefIndex) -> ty::ItemVariances {
+pub fn get_item_variances(cdata: Cmd, id: DefIndex) -> Vec<ty::Variance> {
let item_doc = cdata.lookup_item(id);
let variance_doc = reader::get_doc(item_doc, tag_item_variances);
let mut decoder = reader::Decoder::new(variance_doc);
})).collect()
}
-fn get_meta_items(md: rbml::Doc) -> Vec<P<ast::MetaItem>> {
- reader::tagged_docs(md, tag_meta_item_word).map(|meta_item_doc| {
- let nd = reader::get_doc(meta_item_doc, tag_meta_item_name);
- let n = token::intern_and_get_ident(nd.as_str_slice());
- attr::mk_word_item(n)
- }).chain(reader::tagged_docs(md, tag_meta_item_name_value).map(|meta_item_doc| {
- let nd = reader::get_doc(meta_item_doc, tag_meta_item_name);
- let vd = reader::get_doc(meta_item_doc, tag_meta_item_value);
- let n = token::intern_and_get_ident(nd.as_str_slice());
- let v = token::intern_and_get_ident(vd.as_str_slice());
- // FIXME (#623): Should be able to decode MetaItemKind::NameValue variants,
- // but currently the encoder just drops them
- attr::mk_name_value_item_str(n, v)
- })).chain(reader::tagged_docs(md, tag_meta_item_list).map(|meta_item_doc| {
- let nd = reader::get_doc(meta_item_doc, tag_meta_item_name);
- let n = token::intern_and_get_ident(nd.as_str_slice());
- let subitems = get_meta_items(meta_item_doc);
- attr::mk_list_item(n, subitems)
- })).collect()
-}
-
fn get_attributes(md: rbml::Doc) -> Vec<ast::Attribute> {
- match reader::maybe_get_doc(md, tag_attributes) {
- Some(attrs_d) => {
- reader::tagged_docs(attrs_d, tag_attribute).map(|attr_doc| {
- let is_sugared_doc = reader::doc_as_u8(
- reader::get_doc(attr_doc, tag_attribute_is_sugared_doc)
- ) == 1;
- let meta_items = get_meta_items(attr_doc);
- // Currently it's only possible to have a single meta item on
- // an attribute
- assert_eq!(meta_items.len(), 1);
- let meta_item = meta_items.into_iter().nth(0).unwrap();
- attr::mk_doc_attr_outer(attr::mk_attr_id(), meta_item, is_sugared_doc)
- }).collect()
- },
- None => vec![],
- }
+ reader::maybe_get_doc(md, tag_attributes).map_or(vec![], |attrs_doc| {
+ let mut decoder = reader::Decoder::new(attrs_doc);
+ let mut attrs: Vec<ast::Attribute> = decoder.read_opaque(|opaque_decoder, _| {
+ Decodable::decode(opaque_decoder)
+ }).unwrap();
+
+ // Need new unique IDs: old thread-local IDs won't map to new threads.
+ for attr in attrs.iter_mut() {
+ attr.node.id = attr::mk_attr_id();
+ }
+
+ attrs
+ })
}
fn list_crate_attributes(md: rbml::Doc, hash: &Svh,
fn docstr(doc: rbml::Doc, tag_: usize) -> String {
let d = reader::get_doc(doc, tag_);
- d.as_str_slice().to_string()
+ d.as_str().to_string()
}
reader::tagged_docs(depsdoc, tag_crate_dep).enumerate().map(|(crate_num, depdoc)| {
pub fn maybe_get_crate_name(data: &[u8]) -> Option<&str> {
let cratedoc = rbml::Doc::new(data);
reader::maybe_get_doc(cratedoc, tag_crate_crate_name).map(|doc| {
- doc.as_str_slice()
+ doc.as_str()
})
}
pub fn get_crate_disambiguator<'a>(data: &'a [u8]) -> &'a str {
let crate_doc = rbml::Doc::new(data);
let disambiguator_doc = reader::get_doc(crate_doc, tag_crate_disambiguator);
- let slice: &'a str = disambiguator_doc.as_str_slice();
+ let slice: &'a str = disambiguator_doc.as_str();
slice
}
tag_dylib_dependency_formats);
let mut result = Vec::new();
- debug!("found dylib deps: {}", formats.as_str_slice());
- for spec in formats.as_str_slice().split(',') {
+ debug!("found dylib deps: {}", formats.as_str());
+ for spec in formats.as_str().split(',') {
if spec.is_empty() { continue }
- let cnum = spec.split(':').nth(0).unwrap();
- let link = spec.split(':').nth(1).unwrap();
+ let mut split = spec.split(':');
+ let cnum = split.next().unwrap();
+ let link = split.next().unwrap();
let cnum: ast::CrateNum = cnum.parse().unwrap();
let cnum = cdata.cnum_map.borrow()[cnum];
result.push((cnum, if link == "d" {
match reader::maybe_get_doc(method_doc, tag_method_argument_names) {
Some(args_doc) => {
reader::tagged_docs(args_doc, tag_method_argument_name).map(|name_doc| {
- name_doc.as_str_slice().to_string()
+ name_doc.as_str().to_string()
}).collect()
},
None => vec![],
let mut decoder = reader::Decoder::new(def_key_doc);
let simple_key = def_key::DefKey::decode(&mut decoder).unwrap();
let name = reader::maybe_get_doc(item_doc, tag_paths_data_name).map(|name| {
- token::intern(name.as_str_slice()).as_str()
+ token::intern(name.as_str()).as_str()
});
def_key::recover_def_key(simple_key, name)
}
projects / rust.git / blobdiff