rust-lang/rust
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

auto merge of #21052 : nick29581/rust/methods-ext, r=sfackler

Browse Source 
Allows modifiers to be used on methods, associated types, etc.

r? @sfackler
This commit is contained in:
bors
2015-01-15 22:42:58 +00:00
parent 9ade482b3b 98d471120a
commit 8903c21d61
7 changed files with 419 additions and 121 deletions
Download Patch File Download Diff File Expand all files Collapse all files

87
src/libsyntax/fold.rs
View File

@@ -102,6 +102,14 @@ pub trait Folder : Sized {
noop_fold_item_underscore(i, self)
}
fn fold_trait_item(&mut self, i: TraitItem) -> SmallVector<TraitItem> {
noop_fold_trait_item(i, self)
}
fn fold_impl_item(&mut self, i: ImplItem) -> SmallVector<ImplItem> {
noop_fold_impl_item(i, self)
}
fn fold_fn_decl(&mut self, d: P<FnDecl>) -> P<FnDecl> {
noop_fold_fn_decl(d, self)
}
@@ -1007,21 +1015,9 @@ pub fn noop_fold_item_underscore<T: Folder>(i: Item_, folder: &mut T) -> Item_ {
ItemStruct(struct_def, folder.fold_generics(generics))
}
ItemImpl(unsafety, polarity, generics, ifce, ty, impl_items) => {
let mut new_impl_items = Vec::new();
for impl_item in impl_items.iter() {
match *impl_item {
MethodImplItem(ref x) => {
for method in folder.fold_method((*x).clone())
.into_iter() {
new_impl_items.push(MethodImplItem(method))
}
}
TypeImplItem(ref t) => {
new_impl_items.push(TypeImplItem(
P(folder.fold_typedef((**t).clone()))));
}
}
}
let new_impl_items = impl_items.into_iter().flat_map(|item| {
folder.fold_impl_item(item).into_iter()
}).collect();
let ifce = match ifce {
None => None,
Some(ref trait_ref) => {
@@ -1035,43 +1031,50 @@ pub fn noop_fold_item_underscore<T: Folder>(i: Item_, folder: &mut T) -> Item_ {
folder.fold_ty(ty),
new_impl_items)
}
ItemTrait(unsafety, generics, bounds, methods) => {
ItemTrait(unsafety, generics, bounds, items) => {
let bounds = folder.fold_bounds(bounds);
let methods = methods.into_iter().flat_map(|method| {
let r = match method {
RequiredMethod(m) => {
SmallVector::one(RequiredMethod(
folder.fold_type_method(m)))
.into_iter()
}
ProvidedMethod(method) => {
// the awkward collect/iter idiom here is because
// even though an iter and a map satisfy the same
// trait bound, they're not actually the same type, so
// the method arms don't unify.
let methods: SmallVector<ast::TraitItem> =
folder.fold_method(method).into_iter()
.map(|m| ProvidedMethod(m)).collect();
methods.into_iter()
}
TypeTraitItem(at) => {
SmallVector::one(TypeTraitItem(P(
folder.fold_associated_type(
(*at).clone()))))
.into_iter()
}
};
r
let items = items.into_iter().flat_map(|item| {
folder.fold_trait_item(item).into_iter()
}).collect();
ItemTrait(unsafety,
folder.fold_generics(generics),
bounds,
methods)
items)
}
ItemMac(m) => ItemMac(folder.fold_mac(m)),
}
}
pub fn noop_fold_trait_item<T: Folder>(i: TraitItem, folder: &mut T) -> SmallVector<TraitItem> {
match i {
RequiredMethod(m) => {
SmallVector::one(RequiredMethod(
folder.fold_type_method(m)))
}
ProvidedMethod(method) => {
folder.fold_method(method).into_iter()
.map(|m| ProvidedMethod(m)).collect()
}
TypeTraitItem(at) => {
SmallVector::one(TypeTraitItem(P(
folder.fold_associated_type(
(*at).clone()))))
}
}
}
pub fn noop_fold_impl_item<T: Folder>(i: ImplItem, folder: &mut T) -> SmallVector<ImplItem> {
match i {
MethodImplItem(ref x) => {
folder.fold_method((*x).clone()).into_iter().map(|m| MethodImplItem(m)).collect()
}
TypeImplItem(ref t) => {
SmallVector::one(TypeImplItem(
P(folder.fold_typedef((**t).clone()))))
}
}
}
pub fn noop_fold_type_method<T: Folder>(m: TypeMethod, fld: &mut T) -> TypeMethod {
let TypeMethod {
id,