Remove all traces of lifetimes() and types() methods

Author: varkor

src/librustc/hir/lowering.rs

@@ -1731,7 +1731,11 @@ impl<'a> LoweringContext<'a> {
             self.lower_angle_bracketed_parameter_data(&Default::default(), param_mode, itctx)
         };
 
-        if !generic_args.parenthesized && generic_args.lifetimes().count() == 0 {
+        let has_lifetimes = generic_args.args.iter().any(|arg| match arg {
+            GenericArg::Lifetime(_) => true,
+            _ => false,
+        });
+        if !generic_args.parenthesized && !has_lifetimes {
             generic_args.args =
                 self.elided_path_lifetimes(path_span, expected_lifetimes)
                     .into_iter()
@@ -1763,7 +1767,7 @@ impl<'a> LoweringContext<'a> {
             bindings: bindings.iter().map(|b| self.lower_ty_binding(b, itctx)).collect(),
             parenthesized: false,
         },
-        has_types && param_mode == ParamMode::Optional)
+        !has_types && param_mode == ParamMode::Optional)
     }
 
     fn lower_parenthesized_parameter_data(

src/librustc/hir/mod.rs

@@ -400,34 +400,20 @@ impl GenericArgs {
 
     pub fn inputs(&self) -> &[P<Ty>] {
         if self.parenthesized {
-            if let Some(ref ty) = self.types().next() {
-                if let TyTup(ref tys) = ty.node {
-                    return tys;
+            for arg in &self.args {
+                match arg {
+                    GenericArg::Lifetime(_) => {}
+                    GenericArg::Type(ref ty) => {
+                        if let TyTup(ref tys) = ty.node {
+                            return tys;
+                        }
+                        break;
+                    }
                 }
             }
         }
         bug!("GenericArgs::inputs: not a `Fn(T) -> U`");
     }
-
-    pub fn lifetimes(&self) -> impl DoubleEndedIterator<Item = &Lifetime> {
-        self.args.iter().filter_map(|p| {
-            if let GenericArg::Lifetime(lt) = p {
-                Some(lt)
-            } else {
-                None
-            }
-        })
-    }
-
-    pub fn types(&self) -> impl DoubleEndedIterator<Item = &P<Ty>> {
-        self.args.iter().filter_map(|p| {
-            if let GenericArg::Type(ty) = p {
-                Some(ty)
-            } else {
-                None
-            }
-        })
-    }
 }
 
 /// The AST represents all type param bounds as types.

src/librustc/hir/print.rs

@@ -1731,20 +1731,31 @@ impl<'a> State<'a> {
                 }
             };
 
-            let elide_lifetimes = generic_args.lifetimes().all(|lt| lt.is_elided());
+            let mut types = vec![];
+            let mut elide_lifetimes = true;
+            for arg in &generic_args.args {
+                match arg {
+                    GenericArg::Lifetime(lt) => {
+                        if !lt.is_elided() {
+                            elide_lifetimes = false;
+                        }
+                    }
+                    GenericArg::Type(ty) => {
+                        types.push(ty);
+                    }
+                }
+            }
             if !elide_lifetimes {
                 start_or_comma(self)?;
                 self.commasep(Inconsistent, &generic_args.args, |s, generic_arg| {
                     match generic_arg {
                         GenericArg::Lifetime(lt) => s.print_lifetime(lt),
                         GenericArg::Type(ty) => s.print_type(ty),
-                }
+                    }
                 })?;
-            } else if generic_args.types().count() != 0 {
+            } else if !types.is_empty() {
                 start_or_comma(self)?;
-                self.commasep(Inconsistent,
-                              &generic_args.types().collect::<Vec<_>>(),
-                              |s, ty| s.print_type(&ty))?;
+                self.commasep(Inconsistent, &types, |s, ty| s.print_type(&ty))?;
             }
 
             // FIXME(eddyb) This would leak into error messages, e.g.: