Simply joint lifetime/type iteration

3 files changed, 22 insertions, 58 deletions

diff --git a/src/libsyntax_ext/deriving/generic/mod.rs b/src/libsyntax_ext/deriving/generic/mod.rs
index 6c9aea51c7c..1024d445cdb 100644
--- a/src/libsyntax_ext/deriving/generic/mod.rs
+++ b/src/libsyntax_ext/deriving/generic/mod.rs
@@ -665,35 +665,18 @@ impl<'a> TraitDef<'a> {
         // Create the reference to the trait.
         let trait_ref = cx.trait_ref(trait_path);
 
-        // Create the type parameters on the `self` path.
-        let self_ty_params: Vec<P<ast::Ty>> = generics.params
-            .iter()
-            .filter_map(|param| match param.kind {
-                GenericParamKind::Type { .. } => Some(cx.ty_ident(self.span, param.ident)),
-                _ => None,
-            })
-            .collect();
-
-        let self_lifetimes: Vec<ast::Lifetime> = generics.params
-            .iter()
-            .filter_map(|param| match param.kind {
-                GenericParamKind::Lifetime { ref lifetime, .. } => Some(*lifetime),
-                _ => None,
-            })
-            .collect();
-
-        let self_params = self_lifetimes.into_iter()
-                                        .map(|lt| GenericArg::Lifetime(lt))
-                                        .chain(self_ty_params.into_iter().map(|ty|
-                                            GenericArg::Type(ty)))
-                                        .collect();
+        let self_params: Vec<_> = generics.params.iter().map(|param| match param.kind {
+            GenericParamKind::Lifetime { ref lifetime, .. } => {
+                GenericArg::Lifetime(*lifetime)
+            }
+            GenericParamKind::Type { .. } => {
+                GenericArg::Type(cx.ty_ident(self.span, param.ident))
+            }
+        }).collect();
 
         // Create the type of `self`.
-        let self_type = cx.ty_path(cx.path_all(self.span,
-                                               false,
-                                               vec![type_ident],
-                                               self_params,
-                                               Vec::new()));
+        let path = cx.path_all(self.span, false, vec![type_ident], self_params, vec![]);
+        let self_type = cx.ty_path(path);
 
         let attr = cx.attribute(self.span,
                                 cx.meta_word(self.span,
diff --git a/src/libsyntax_ext/deriving/generic/ty.rs b/src/libsyntax_ext/deriving/generic/ty.rs
index 78f6a9b9137..127ed62b8c5 100644
--- a/src/libsyntax_ext/deriving/generic/ty.rs
+++ b/src/libsyntax_ext/deriving/generic/ty.rs
@@ -185,41 +185,22 @@ impl<'a> Ty<'a> {
                    cx: &ExtCtxt,
                    span: Span,
                    self_ty: Ident,
-                   self_generics: &Generics)
+                   generics: &Generics)
                    -> ast::Path {
         match *self {
             Self_ => {
-                let ty_params: Vec<P<ast::Ty>> = self_generics.params
-                    .iter()
-                    .filter_map(|param| match param.kind {
-                        GenericParamKind::Type { .. } => {
-                            Some(cx.ty_ident(span, param.ident))
-                        }
-                        _ => None,
-                    })
-                    .collect();
-
-                let lifetimes: Vec<ast::Lifetime> = self_generics.params
-                    .iter()
-                    .filter_map(|param| match param.kind {
-                        GenericParamKind::Lifetime { ref lifetime, .. } => Some(*lifetime),
-                        _ => None,
-                    })
-                    .collect();
-
-                let params = lifetimes.into_iter()
-                                      .map(|lt| GenericArg::Lifetime(lt))
-                                      .chain(ty_params.into_iter().map(|ty|
-                                            GenericArg::Type(ty)))
-                                      .collect();
+                let params: Vec<_> = generics.params.iter().map(|param| match param.kind {
+                    GenericParamKind::Lifetime { ref lifetime, .. } => {
+                        GenericArg::Lifetime(*lifetime)
+                    }
+                    GenericParamKind::Type { .. } => {
+                        GenericArg::Type(cx.ty_ident(span, param.ident))
+                    }
+                }).collect();
 
-                cx.path_all(span,
-                            false,
-                            vec![self_ty],
-                            params,
-                            Vec::new())
+                cx.path_all(span, false, vec![self_ty], params, vec![])
             }
-            Literal(ref p) => p.to_path(cx, span, self_ty, self_generics),
+            Literal(ref p) => p.to_path(cx, span, self_ty, generics),
             Ptr(..) => cx.span_bug(span, "pointer in a path in generic `derive`"),
             Tuple(..) => cx.span_bug(span, "tuple in a path in generic `derive`"),
         }
diff --git a/src/libsyntax_ext/env.rs b/src/libsyntax_ext/env.rs
index 5c3080260cc..bbc5b03d688 100644
--- a/src/libsyntax_ext/env.rs
+++ b/src/libsyntax_ext/env.rs
@@ -43,7 +43,7 @@ pub fn expand_option_env<'cx>(cx: &'cx mut ExtCtxt,
                                                      cx.ty_ident(sp, Ident::from_str("str")),
                                                      Some(lt),
                                                      ast::Mutability::Immutable))],
-                                     Vec::new()))
+                                     vec![]))
         }
         Ok(s) => {
             cx.expr_call_global(sp,