From 8e039a887df4265e9f20b2a29f12d6708965cc63 Mon Sep 17 00:00:00 2001 From: Ms2ger Date: Fri, 22 May 2015 15:25:42 +0200 Subject: [PATCH 1/3] Introduce TaggedDocsIterator and use it to implement reader::tagged_docs. --- src/librbml/lib.rs | 32 ++++++++++++++++++++------------ 1 file changed, 20 insertions(+), 12 deletions(-) diff --git a/src/librbml/lib.rs b/src/librbml/lib.rs index 65433c528bc..0ee322b06c1 100644 --- a/src/librbml/lib.rs +++ b/src/librbml/lib.rs @@ -436,23 +436,31 @@ pub mod reader { } } - pub fn tagged_docs(d: Doc, tg: usize, mut it: F) -> bool where + pub fn tagged_docs(d: Doc, tg: usize, it: F) -> bool where F: FnMut(Doc) -> bool, { - let mut pos = d.start; - while pos < d.end { - let elt_tag = try_or!(tag_at(d.data, pos), false); - let elt_size = try_or!(tag_len_at(d.data, elt_tag), false); - pos = elt_size.next + elt_size.val; - if elt_tag.val == tg { - let doc = Doc { data: d.data, start: elt_size.next, - end: pos }; - if !it(doc) { - return false; + TaggedDocsIterator { + iter: docs(d), + tag: tg, + }.all(it) + } + + pub struct TaggedDocsIterator<'a> { + iter: DocsIterator<'a>, + tag: usize, + } + + impl<'a> Iterator for TaggedDocsIterator<'a> { + type Item = Doc<'a>; + + fn next(&mut self) -> Option> { + while let Some((tag, doc)) = self.iter.next() { + if tag == self.tag { + return Some(doc); } } + None } - return true; } pub fn with_doc_data(d: Doc, f: F) -> T where From 37dd4174d56431e97adf06ecaf6395376ab2ebbc Mon Sep 17 00:00:00 2001 From: Ms2ger Date: Sun, 24 May 2015 12:23:29 +0200 Subject: [PATCH 2/3] Return TaggedDocsIterator from reader::tagged_docs. --- src/librbml/lib.rs | 8 +- src/librustc/metadata/decoder.rs | 403 ++++++++++++------------------- 2 files changed, 155 insertions(+), 256 deletions(-) diff --git a/src/librbml/lib.rs b/src/librbml/lib.rs index 0ee322b06c1..41ae0f2d5e2 100644 --- a/src/librbml/lib.rs +++ b/src/librbml/lib.rs @@ -436,13 +436,11 @@ pub mod reader { } } - pub fn tagged_docs(d: Doc, tg: usize, it: F) -> bool where - F: FnMut(Doc) -> bool, - { + pub fn tagged_docs<'a>(d: Doc<'a>, tag: usize) -> TaggedDocsIterator<'a> { TaggedDocsIterator { iter: docs(d), - tag: tg, - }.all(it) + tag: tag, + } } pub struct TaggedDocsIterator<'a> { diff --git a/src/librustc/metadata/decoder.rs b/src/librustc/metadata/decoder.rs index ee5fd0202d6..13cee09b472 100644 --- a/src/librustc/metadata/decoder.rs +++ b/src/librustc/metadata/decoder.rs @@ -77,19 +77,12 @@ fn lookup_hash<'a, F>(d: rbml::Doc<'a>, mut eq_fn: F, hash: u64) -> Option(item_id: ast::NodeId, @@ -192,12 +185,9 @@ fn fn_constness(item: rbml::Doc) -> ast::Constness { } fn item_sort(item: rbml::Doc) -> Option { - let mut ret = None; - reader::tagged_docs(item, tag_item_trait_item_sort, |doc| { - ret = Some(doc.as_str_slice().as_bytes()[0] as char); - false - }); - ret + reader::tagged_docs(item, tag_item_trait_item_sort).nth(0).map(|doc| { + doc.as_str_slice().as_bytes()[0] as char + }) } fn item_symbol(item: rbml::Doc) -> String { @@ -211,12 +201,9 @@ fn translated_def_id(cdata: Cmd, d: rbml::Doc) -> ast::DefId { } fn item_parent_item(cdata: Cmd, d: rbml::Doc) -> Option { - let mut ret = None; - reader::tagged_docs(d, tag_items_data_parent_item, |did| { - ret = Some(translated_def_id(cdata, did)); - false - }); - ret + reader::tagged_docs(d, tag_items_data_parent_item).nth(0).map(|did| { + translated_def_id(cdata, did) + }) } fn item_require_parent_item(cdata: Cmd, d: rbml::Doc) -> ast::DefId { @@ -233,10 +220,16 @@ fn get_provided_source(d: rbml::Doc, cdata: Cmd) -> Option { }) } -fn each_reexport(d: rbml::Doc, f: F) -> bool where +fn each_reexport(d: rbml::Doc, mut f: F) -> bool where F: FnMut(rbml::Doc) -> bool, { - reader::tagged_docs(d, tag_items_data_item_reexport, f) + for doc in reader::tagged_docs(d, tag_items_data_item_reexport) { + if !f(doc) { + return false; + } + } + + true } fn variant_disr_val(d: rbml::Doc) -> Option { @@ -278,12 +271,9 @@ fn item_trait_ref<'tcx>(doc: rbml::Doc, tcx: &ty::ctxt<'tcx>, cdata: Cmd) } fn enum_variant_ids(item: rbml::Doc, cdata: Cmd) -> Vec { - let mut ids = vec![]; - reader::tagged_docs(item, tag_items_data_item_variant, |p| { - ids.push(translated_def_id(cdata, p)); - true - }); - ids + reader::tagged_docs(item, tag_items_data_item_variant) + .map(|p| translated_def_id(cdata, p)) + .collect() } fn item_path(item_doc: rbml::Doc) -> Vec { @@ -400,13 +390,9 @@ fn parse_polarity(item_doc: rbml::Doc) -> ast::ImplPolarity { fn parse_associated_type_names(item_doc: rbml::Doc) -> Vec { let names_doc = reader::get_doc(item_doc, tag_associated_type_names); - let mut names = Vec::new(); - reader::tagged_docs(names_doc, tag_associated_type_name, |name_doc| { - let name = token::intern(name_doc.as_str_slice()); - names.push(name); - true - }); - names + reader::tagged_docs(names_doc, tag_associated_type_name) + .map(|name_doc| token::intern(name_doc.as_str_slice())) + .collect() } pub fn get_trait_def<'tcx>(cdata: Cmd, @@ -552,7 +538,7 @@ pub fn each_lang_item(cdata: Cmd, mut f: F) -> bool where { let root = rbml::Doc::new(cdata.data()); let lang_items = reader::get_doc(root, tag_lang_items); - reader::tagged_docs(lang_items, tag_lang_items_item, |item_doc| { + reader::tagged_docs(lang_items, tag_lang_items_item).all(|item_doc| { let id_doc = reader::get_doc(item_doc, tag_lang_items_item_id); let id = reader::doc_as_u32(id_doc) as usize; let node_id_doc = reader::get_doc(item_doc, @@ -572,7 +558,7 @@ fn each_child_of_item_or_crate(intr: Rc, G: FnMut(ast::CrateNum) -> Rc, { // Iterate over all children. - let _ = reader::tagged_docs(item_doc, tag_mod_child, |child_info_doc| { + for child_info_doc in reader::tagged_docs(item_doc, tag_mod_child) { let child_def_id = translated_def_id(cdata, child_info_doc); // This item may be in yet another crate if it was the child of a @@ -598,26 +584,20 @@ fn each_child_of_item_or_crate(intr: Rc, let def_like = item_to_def_like(crate_data, child_item_doc, child_def_id); let visibility = item_visibility(child_item_doc); callback(def_like, child_name, visibility); - } } - - true - }); + } // As a special case, iterate over all static methods of // associated implementations too. This is a bit of a botch. // --pcwalton - let _ = reader::tagged_docs(item_doc, - tag_items_data_item_inherent_impl, - |inherent_impl_def_id_doc| { - let inherent_impl_def_id = item_def_id(inherent_impl_def_id_doc, - cdata); + for inherent_impl_def_id_doc in reader::tagged_docs(item_doc, + tag_items_data_item_inherent_impl) { + let inherent_impl_def_id = item_def_id(inherent_impl_def_id_doc, cdata); let items = reader::get_doc(rbml::Doc::new(cdata.data()), tag_items); if let Some(inherent_impl_doc) = maybe_find_item(inherent_impl_def_id.node, items) { - let _ = reader::tagged_docs(inherent_impl_doc, - tag_item_impl_item, - |impl_item_def_id_doc| { + for impl_item_def_id_doc in reader::tagged_docs(inherent_impl_doc, + tag_item_impl_item) { let impl_item_def_id = item_def_id(impl_item_def_id_doc, cdata); if let Some(impl_method_doc) = maybe_find_item(impl_item_def_id.node, items) { @@ -631,11 +611,9 @@ fn each_child_of_item_or_crate(intr: Rc, item_visibility(impl_method_doc)); } } - true - }); + } } - true - }); + } // Iterate over all reexports. let _ = each_reexport(item_doc, |reexport_doc| { @@ -847,22 +825,15 @@ fn get_explicit_self(item: rbml::Doc) -> ty::ExplicitSelfCategory { /// Returns the def IDs of all the items in the given implementation. pub fn get_impl_items(cdata: Cmd, impl_id: ast::NodeId) -> Vec { - let mut impl_items = Vec::new(); - reader::tagged_docs(lookup_item(impl_id, cdata.data()), - tag_item_impl_item, |doc| { + reader::tagged_docs(lookup_item(impl_id, cdata.data()), tag_item_impl_item).map(|doc| { let def_id = item_def_id(doc, cdata); match item_sort(doc) { - Some('C') => impl_items.push(ty::ConstTraitItemId(def_id)), - Some('r') | Some('p') => { - impl_items.push(ty::MethodTraitItemId(def_id)) - } - Some('t') => impl_items.push(ty::TypeTraitItemId(def_id)), + Some('C') => ty::ConstTraitItemId(def_id), + Some('r') | Some('p') => ty::MethodTraitItemId(def_id), + Some('t') => ty::TypeTraitItemId(def_id), _ => panic!("unknown impl item sort"), } - true - }); - - impl_items + }).collect() } pub fn get_trait_name(intr: Rc, @@ -948,20 +919,15 @@ pub fn get_trait_item_def_ids(cdata: Cmd, id: ast::NodeId) -> Vec { let data = cdata.data(); let item = lookup_item(id, data); - let mut result = Vec::new(); - reader::tagged_docs(item, tag_item_trait_item, |mth| { + reader::tagged_docs(item, tag_item_trait_item).map(|mth| { let def_id = item_def_id(mth, cdata); match item_sort(mth) { - Some('C') => result.push(ty::ConstTraitItemId(def_id)), - Some('r') | Some('p') => { - result.push(ty::MethodTraitItemId(def_id)); - } - Some('t') => result.push(ty::TypeTraitItemId(def_id)), + Some('C') => ty::ConstTraitItemId(def_id), + Some('r') | Some('p') => ty::MethodTraitItemId(def_id), + Some('t') => ty::TypeTraitItemId(def_id), _ => panic!("unknown trait item sort"), } - true - }); - result + }).collect() } pub fn get_item_variances(cdata: Cmd, id: ast::NodeId) -> ty::ItemVariances { @@ -979,9 +945,8 @@ pub fn get_provided_trait_methods<'tcx>(intr: Rc, -> Vec>> { let data = cdata.data(); let item = lookup_item(id, data); - let mut result = Vec::new(); - reader::tagged_docs(item, tag_item_trait_item, |mth_id| { + reader::tagged_docs(item, tag_item_trait_item).filter_map(|mth_id| { let did = item_def_id(mth_id, cdata); let mth = lookup_item(did.node, data); @@ -991,13 +956,14 @@ pub fn get_provided_trait_methods<'tcx>(intr: Rc, did.node, tcx); if let ty::MethodTraitItem(ref method) = trait_item { - result.push((*method).clone()) + Some((*method).clone()) + } else { + None } + } else { + None } - true - }); - - return result; + }).collect() } pub fn get_associated_consts<'tcx>(intr: Rc, @@ -1007,10 +973,9 @@ pub fn get_associated_consts<'tcx>(intr: Rc, -> Vec>> { let data = cdata.data(); let item = lookup_item(id, data); - let mut result = Vec::new(); - for &tag in &[tag_item_trait_item, tag_item_impl_item] { - reader::tagged_docs(item, tag, |ac_id| { + [tag_item_trait_item, tag_item_impl_item].iter().flat_map(|&tag| { + reader::tagged_docs(item, tag).filter_map(|ac_id| { let did = item_def_id(ac_id, cdata); let ac_doc = lookup_item(did.node, data); @@ -1020,14 +985,15 @@ pub fn get_associated_consts<'tcx>(intr: Rc, did.node, tcx); if let ty::ConstTraitItem(ref ac) = trait_item { - result.push((*ac).clone()) + Some((*ac).clone()) + } else { + None } + } else { + None } - true - }); - } - - return result; + }) + }).collect() } pub fn get_type_name_if_impl(cdata: Cmd, @@ -1037,13 +1003,9 @@ pub fn get_type_name_if_impl(cdata: Cmd, return None; } - let mut ret = None; - reader::tagged_docs(item, tag_item_impl_type_basename, |doc| { - ret = Some(token::intern(doc.as_str_slice())); - false - }); - - ret + reader::tagged_docs(item, tag_item_impl_type_basename).nth(0).map(|doc| { + token::intern(doc.as_str_slice()) + }) } pub fn get_methods_if_impl(intr: Rc, @@ -1056,20 +1018,15 @@ pub fn get_methods_if_impl(intr: Rc, } // If this impl implements a trait, don't consider it. - let ret = reader::tagged_docs(item, tag_item_trait_ref, |_doc| { - false - }); + if reader::tagged_docs(item, tag_item_trait_ref).next().is_some() { + return None; + } - if !ret { return None } - - let mut impl_method_ids = Vec::new(); - reader::tagged_docs(item, tag_item_impl_item, |impl_method_doc| { - impl_method_ids.push(item_def_id(impl_method_doc, cdata)); - true - }); + let impl_method_ids = reader::tagged_docs(item, tag_item_impl_item) + .map(|impl_method_doc| item_def_id(impl_method_doc, cdata)); let mut impl_methods = Vec::new(); - for impl_method_id in &impl_method_ids { + for impl_method_id in impl_method_ids { let impl_method_doc = lookup_item(impl_method_id.node, cdata.data()); let family = item_family(impl_method_doc); match family { @@ -1094,12 +1051,9 @@ pub fn get_tuple_struct_definition_if_ctor(cdata: Cmd, -> Option { let item = lookup_item(node_id, cdata.data()); - let mut ret = None; - reader::tagged_docs(item, tag_items_data_item_is_tuple_struct_ctor, |_| { - ret = Some(item_require_parent_item(cdata, item)); - false - }); - ret + reader::tagged_docs(item, tag_items_data_item_is_tuple_struct_ctor).next().map(|_| { + item_require_parent_item(cdata, item) + }) } pub fn get_item_attrs(cdata: Cmd, @@ -1117,14 +1071,11 @@ pub fn get_item_attrs(cdata: Cmd, pub fn get_struct_field_attrs(cdata: Cmd) -> HashMap> { let data = rbml::Doc::new(cdata.data()); let fields = reader::get_doc(data, tag_struct_fields); - let mut map = HashMap::new(); - reader::tagged_docs(fields, tag_struct_field, |field| { + reader::tagged_docs(fields, tag_struct_field).map(|field| { let id = reader::doc_as_u32(reader::get_doc(field, tag_struct_field_id)); let attrs = get_attributes(field); - map.insert(id, attrs); - true - }); - map + (id, attrs) + }).collect() } fn struct_field_family_to_visibility(family: Family) -> ast::Visibility { @@ -1139,81 +1090,69 @@ pub fn get_struct_fields(intr: Rc, cdata: Cmd, id: ast::NodeId) -> Vec { let data = cdata.data(); let item = lookup_item(id, data); - let mut result = Vec::new(); - reader::tagged_docs(item, tag_item_field, |an_item| { + reader::tagged_docs(item, tag_item_field).filter_map(|an_item| { let f = item_family(an_item); if f == PublicField || f == InheritedField { let name = item_name(&*intr, an_item); let did = item_def_id(an_item, cdata); let tagdoc = reader::get_doc(an_item, tag_item_field_origin); let origin_id = translated_def_id(cdata, tagdoc); - result.push(ty::field_ty { + Some(ty::field_ty { name: name, id: did, vis: struct_field_family_to_visibility(f), origin: origin_id, - }); + }) + } else { + None } - true - }); - reader::tagged_docs(item, tag_item_unnamed_field, |an_item| { + }).chain(reader::tagged_docs(item, tag_item_unnamed_field).map(|an_item| { let did = item_def_id(an_item, cdata); let tagdoc = reader::get_doc(an_item, tag_item_field_origin); let f = item_family(an_item); let origin_id = translated_def_id(cdata, tagdoc); - result.push(ty::field_ty { + ty::field_ty { name: special_idents::unnamed_field.name, id: did, vis: struct_field_family_to_visibility(f), origin: origin_id, - }); - true - }); - result + } + })).collect() } fn get_meta_items(md: rbml::Doc) -> Vec> { - let mut items: Vec> = Vec::new(); - reader::tagged_docs(md, tag_meta_item_word, |meta_item_doc| { + 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()); - items.push(attr::mk_word_item(n)); - true - }); - reader::tagged_docs(md, tag_meta_item_name_value, |meta_item_doc| { + 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 MetaNameValue variants, // but currently the encoder just drops them - items.push(attr::mk_name_value_item_str(n, v)); - true - }); - reader::tagged_docs(md, tag_meta_item_list, |meta_item_doc| { + 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); - items.push(attr::mk_list_item(n, subitems.into_iter().collect())); - true - }); - return items; + attr::mk_list_item(n, subitems) + })).collect() } fn get_attributes(md: rbml::Doc) -> Vec { - let mut attrs: Vec = Vec::new(); match reader::maybe_get_doc(md, tag_attributes) { - Some(attrs_d) => { - reader::tagged_docs(attrs_d, tag_attribute, |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(); - attrs.push( + 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(); codemap::Spanned { node: ast::Attribute_ { id: attr::mk_attr_id(), @@ -1222,13 +1161,11 @@ fn get_attributes(md: rbml::Doc) -> Vec { is_sugared_doc: is_sugared_doc, }, span: codemap::DUMMY_SP - }); - true - }); - } - None => () + } + }).collect() + }, + None => vec![], } - return attrs; } fn list_crate_attributes(md: rbml::Doc, hash: &Svh, @@ -1255,26 +1192,23 @@ pub struct CrateDep { } pub fn get_crate_deps(data: &[u8]) -> Vec { - let mut deps: Vec = Vec::new(); let cratedoc = rbml::Doc::new(data); let depsdoc = reader::get_doc(cratedoc, tag_crate_deps); - let mut crate_num = 1; + fn docstr(doc: rbml::Doc, tag_: usize) -> String { let d = reader::get_doc(doc, tag_); d.as_str_slice().to_string() } - reader::tagged_docs(depsdoc, tag_crate_dep, |depdoc| { + + reader::tagged_docs(depsdoc, tag_crate_dep).enumerate().map(|(crate_num, depdoc)| { let name = docstr(depdoc, tag_crate_dep_crate_name); let hash = Svh::new(&docstr(depdoc, tag_crate_dep_hash)); - deps.push(CrateDep { - cnum: crate_num, + CrateDep { + cnum: crate_num as u32 + 1, name: name, hash: hash, - }); - crate_num += 1; - true - }); - return deps; + } + }).collect() } fn list_crate_deps(data: &[u8], out: &mut io::Write) -> io::Result<()> { @@ -1366,14 +1300,11 @@ pub fn each_inherent_implementation_for_type(cdata: Cmd, where F: FnMut(ast::DefId), { let item_doc = lookup_item(id, cdata.data()); - reader::tagged_docs(item_doc, - tag_items_data_item_inherent_impl, - |impl_doc| { + for impl_doc in reader::tagged_docs(item_doc, tag_items_data_item_inherent_impl) { if reader::maybe_get_doc(impl_doc, tag_item_trait_ref).is_none() { callback(item_def_id(impl_doc, cdata)); } - true - }); + } } pub fn each_implementation_for_trait(cdata: Cmd, @@ -1383,12 +1314,9 @@ pub fn each_implementation_for_trait(cdata: Cmd, { if cdata.cnum == def_id.krate { let item_doc = lookup_item(def_id.node, cdata.data()); - let _ = reader::tagged_docs(item_doc, - tag_items_data_item_extension_impl, - |impl_doc| { + for impl_doc in reader::tagged_docs(item_doc, tag_items_data_item_extension_impl) { callback(item_def_id(impl_doc, cdata)); - true - }); + } return; } @@ -1398,13 +1326,12 @@ pub fn each_implementation_for_trait(cdata: Cmd, let def_id_u64 = def_to_u64(crate_local_did); let impls_doc = reader::get_doc(rbml::Doc::new(cdata.data()), tag_impls); - let _ = reader::tagged_docs(impls_doc, tag_impls_impl, |impl_doc| { + for impl_doc in reader::tagged_docs(impls_doc, tag_impls_impl) { let impl_trait = reader::get_doc(impl_doc, tag_impls_impl_trait_def_id); if reader::doc_as_u64(impl_trait) == def_id_u64 { callback(item_def_id(impl_doc, cdata)); } - true - }); + } } } @@ -1431,17 +1358,14 @@ pub fn get_native_libraries(cdata: Cmd) -> Vec<(cstore::NativeLibraryKind, String)> { let libraries = reader::get_doc(rbml::Doc::new(cdata.data()), tag_native_libraries); - let mut result = Vec::new(); - reader::tagged_docs(libraries, tag_native_libraries_lib, |lib_doc| { + reader::tagged_docs(libraries, tag_native_libraries_lib).map(|lib_doc| { let kind_doc = reader::get_doc(lib_doc, tag_native_libraries_kind); let name_doc = reader::get_doc(lib_doc, tag_native_libraries_name); let kind: cstore::NativeLibraryKind = cstore::NativeLibraryKind::from_u32(reader::doc_as_u32(kind_doc)).unwrap(); let name = name_doc.as_str().to_string(); - result.push((kind, name)); - true - }); - return result; + (kind, name) + }).collect() } pub fn get_plugin_registrar_fn(data: &[u8]) -> Option { @@ -1453,12 +1377,14 @@ pub fn each_exported_macro(data: &[u8], intr: &IdentInterner, mut f: F) where F: FnMut(ast::Name, Vec, String) -> bool, { let macros = reader::get_doc(rbml::Doc::new(data), tag_macro_defs); - reader::tagged_docs(macros, tag_macro_def, |macro_doc| { + for macro_doc in reader::tagged_docs(macros, tag_macro_def) { let name = item_name(intr, macro_doc); let attrs = get_attributes(macro_doc); let body = reader::get_doc(macro_doc, tag_macro_def_body); - f(name, attrs, body.as_str().to_string()) - }); + if !f(name, attrs, body.as_str().to_string()) { + break; + } + } } pub fn get_dylib_dependency_formats(cdata: Cmd) @@ -1491,43 +1417,32 @@ pub fn get_missing_lang_items(cdata: Cmd) -> Vec { let items = reader::get_doc(rbml::Doc::new(cdata.data()), tag_lang_items); - let mut result = Vec::new(); - reader::tagged_docs(items, tag_lang_items_missing, |missing_docs| { - let item: lang_items::LangItem = - lang_items::LangItem::from_u32(reader::doc_as_u32(missing_docs)).unwrap(); - result.push(item); - true - }); - return result; + reader::tagged_docs(items, tag_lang_items_missing).map(|missing_docs| { + lang_items::LangItem::from_u32(reader::doc_as_u32(missing_docs)).unwrap() + }).collect() } pub fn get_method_arg_names(cdata: Cmd, id: ast::NodeId) -> Vec { - let mut ret = Vec::new(); let method_doc = lookup_item(id, cdata.data()); match reader::maybe_get_doc(method_doc, tag_method_argument_names) { Some(args_doc) => { - reader::tagged_docs(args_doc, tag_method_argument_name, |name_doc| { - ret.push(name_doc.as_str_slice().to_string()); - true - }); - } - None => {} + reader::tagged_docs(args_doc, tag_method_argument_name).map(|name_doc| { + name_doc.as_str_slice().to_string() + }).collect() + }, + None => vec![], } - return ret; } pub fn get_reachable_extern_fns(cdata: Cmd) -> Vec { - let mut ret = Vec::new(); let items = reader::get_doc(rbml::Doc::new(cdata.data()), tag_reachable_extern_fns); - reader::tagged_docs(items, tag_reachable_extern_fn_id, |doc| { - ret.push(ast::DefId { + reader::tagged_docs(items, tag_reachable_extern_fn_id).map(|doc| { + ast::DefId { krate: cdata.cnum, node: reader::doc_as_u32(doc), - }); - true - }); - return ret; + } + }).collect() } pub fn is_typedef(cdata: Cmd, id: ast::NodeId) -> bool { @@ -1555,16 +1470,15 @@ fn doc_generics<'tcx>(base_doc: rbml::Doc, let doc = reader::get_doc(base_doc, tag); let mut types = subst::VecPerParamSpace::empty(); - reader::tagged_docs(doc, tag_type_param_def, |p| { + for p in reader::tagged_docs(doc, tag_type_param_def) { let bd = parse_type_param_def_data( p.data, p.start, cdata.cnum, tcx, |_, did| translate_def_id(cdata, did)); types.push(bd.space, bd); - true - }); + } let mut regions = subst::VecPerParamSpace::empty(); - reader::tagged_docs(doc, tag_region_param_def, |rp_doc| { + for rp_doc in reader::tagged_docs(doc, tag_region_param_def) { let ident_str_doc = reader::get_doc(rp_doc, tag_region_param_def_ident); let name = item_name(&*token::get_ident_interner(), ident_str_doc); @@ -1578,23 +1492,17 @@ fn doc_generics<'tcx>(base_doc: rbml::Doc, let doc = reader::get_doc(rp_doc, tag_region_param_def_index); let index = reader::doc_as_u64(doc) as u32; - let mut bounds = Vec::new(); - reader::tagged_docs(rp_doc, tag_items_data_region, |p| { - bounds.push( - parse_region_data( - p.data, cdata.cnum, p.start, tcx, - |_, did| translate_def_id(cdata, did))); - true - }); + let bounds = reader::tagged_docs(rp_doc, tag_items_data_region).map(|p| { + parse_region_data(p.data, cdata.cnum, p.start, tcx, + |_, did| translate_def_id(cdata, did)) + }).collect(); regions.push(space, ty::RegionParameterDef { name: name, def_id: def_id, space: space, index: index, bounds: bounds }); - - true - }); + } ty::Generics { types: types, regions: regions } } @@ -1608,7 +1516,7 @@ fn doc_predicates<'tcx>(base_doc: rbml::Doc, let doc = reader::get_doc(base_doc, tag); let mut predicates = subst::VecPerParamSpace::empty(); - reader::tagged_docs(doc, tag_predicate, |predicate_doc| { + for predicate_doc in reader::tagged_docs(doc, tag_predicate) { let space_doc = reader::get_doc(predicate_doc, tag_predicate_space); let space = subst::ParamSpace::from_uint(reader::doc_as_u8(space_doc) as usize); @@ -1617,8 +1525,7 @@ fn doc_predicates<'tcx>(base_doc: rbml::Doc, |_, did| translate_def_id(cdata, did)); predicates.push(space, data); - true - }); + } ty::GenericPredicates { predicates: predicates } } @@ -1647,14 +1554,8 @@ pub fn get_imported_filemaps(metadata: &[u8]) -> Vec { let crate_doc = rbml::Doc::new(metadata); let cm_doc = reader::get_doc(crate_doc, tag_codemap); - let mut filemaps = vec![]; - - reader::tagged_docs(cm_doc, tag_codemap_filemap, |filemap_doc| { + reader::tagged_docs(cm_doc, tag_codemap_filemap).map(|filemap_doc| { let mut decoder = reader::Decoder::new(filemap_doc); - let filemap: codemap::FileMap = Decodable::decode(&mut decoder).unwrap(); - filemaps.push(filemap); - true - }); - - return filemaps; + Decodable::decode(&mut decoder).unwrap() + }).collect() } From b700b37094a7215e4ac344f691b26c2e5fc81734 Mon Sep 17 00:00:00 2001 From: Ms2ger Date: Tue, 26 May 2015 22:26:35 -0700 Subject: [PATCH 3/3] Return a TaggedDocsIterator from each_reexport. --- src/librustc/metadata/decoder.rs | 19 ++++--------------- 1 file changed, 4 insertions(+), 15 deletions(-) diff --git a/src/librustc/metadata/decoder.rs b/src/librustc/metadata/decoder.rs index 13cee09b472..f4f9a34f728 100644 --- a/src/librustc/metadata/decoder.rs +++ b/src/librustc/metadata/decoder.rs @@ -220,16 +220,8 @@ fn get_provided_source(d: rbml::Doc, cdata: Cmd) -> Option { }) } -fn each_reexport(d: rbml::Doc, mut f: F) -> bool where - F: FnMut(rbml::Doc) -> bool, -{ - for doc in reader::tagged_docs(d, tag_items_data_item_reexport) { - if !f(doc) { - return false; - } - } - - true +fn reexports<'a>(d: rbml::Doc<'a>) -> reader::TaggedDocsIterator<'a> { + reader::tagged_docs(d, tag_items_data_item_reexport) } fn variant_disr_val(d: rbml::Doc) -> Option { @@ -615,8 +607,7 @@ fn each_child_of_item_or_crate(intr: Rc, } } - // Iterate over all reexports. - let _ = each_reexport(item_doc, |reexport_doc| { + for reexport_doc in reexports(item_doc) { let def_id_doc = reader::get_doc(reexport_doc, tag_items_data_item_reexport_def_id); let child_def_id = translated_def_id(cdata, def_id_doc); @@ -646,9 +637,7 @@ fn each_child_of_item_or_crate(intr: Rc, // a public re-export. callback(def_like, token::intern(name), ast::Public); } - - true - }); + } } /// Iterates over each child of the given item.