Iterate over items by default in Punctuated
diff --git a/src/expr.rs b/src/expr.rs
index 18c0fdf..3cf9fa6 100644
--- a/src/expr.rs
+++ b/src/expr.rs
@@ -2868,7 +2868,7 @@
             tokens.append_all(self.attrs.outer());
             self.capture.to_tokens(tokens);
             self.or1_token.to_tokens(tokens);
-            for input in self.inputs.iter() {
+            for input in self.inputs.elements() {
                 match **input.item() {
                     FnArg::Captured(ArgCaptured {
                         ref pat,
diff --git a/src/gen/visit.rs b/src/gen/visit.rs
index 14a0d1a..2770a7b 100644
--- a/src/gen/visit.rs
+++ b/src/gen/visit.rs
@@ -10,6 +10,7 @@
 #![cfg_attr(feature = "cargo-clippy", allow(match_same_arms))]
 
 use *;
+use punctuated::Punctuated;
 use proc_macro2::Span;
 use gen::helper::visit::*;
 
@@ -411,7 +412,7 @@
 pub fn visit_angle_bracketed_generic_arguments<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast AngleBracketedGenericArguments) {
     if let Some(ref it) = _i . colon2_token { tokens_helper(_visitor, &(it).0) };
     tokens_helper(_visitor, &(& _i . lt_token).0);
-    for el in & _i . args { let it = el.item(); _visitor.visit_generic_argument(it) };
+    for el in Punctuated::elements(& _i . args) { let it = el.item(); _visitor.visit_generic_argument(it) };
     tokens_helper(_visitor, &(& _i . gt_token).0);
 }
 # [ cfg ( feature = "full" ) ]
@@ -435,7 +436,7 @@
 # [ cfg ( feature = "full" ) ]
 pub fn visit_arm<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Arm) {
     for it in & _i . attrs { _visitor.visit_attribute(it) };
-    for el in & _i . pats { let it = el.item(); _visitor.visit_pat(it) };
+    for el in Punctuated::elements(& _i . pats) { let it = el.item(); _visitor.visit_pat(it) };
     if let Some(ref it) = _i . guard { 
             tokens_helper(_visitor, &(& ( it ) . 0).0);
             _visitor.visit_expr(& * ( it ) . 1);
@@ -585,7 +586,7 @@
 pub fn visit_bound_lifetimes<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast BoundLifetimes) {
     tokens_helper(_visitor, &(& _i . for_token).0);
     tokens_helper(_visitor, &(& _i . lt_token).0);
-    for el in & _i . lifetimes { let it = el.item(); _visitor.visit_lifetime_def(it) };
+    for el in Punctuated::elements(& _i . lifetimes) { let it = el.item(); _visitor.visit_lifetime_def(it) };
     tokens_helper(_visitor, &(& _i . gt_token).0);
 }
 
@@ -616,7 +617,7 @@
 pub fn visit_data_enum<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast DataEnum) {
     tokens_helper(_visitor, &(& _i . enum_token).0);
     tokens_helper(_visitor, &(& _i . brace_token).0);
-    for el in & _i . variants { let it = el.item(); _visitor.visit_variant(it) };
+    for el in Punctuated::elements(& _i . variants) { let it = el.item(); _visitor.visit_variant(it) };
 }
 
 pub fn visit_data_struct<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast DataStruct) {
@@ -773,7 +774,7 @@
 pub fn visit_expr_array<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprArray) {
     for it in & _i . attrs { _visitor.visit_attribute(it) };
     tokens_helper(_visitor, &(& _i . bracket_token).0);
-    for el in & _i . elems { let it = el.item(); _visitor.visit_expr(it) };
+    for el in Punctuated::elements(& _i . elems) { let it = el.item(); _visitor.visit_expr(it) };
 }
 # [ cfg ( feature = "full" ) ]
 pub fn visit_expr_assign<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprAssign) {
@@ -819,7 +820,7 @@
     for it in & _i . attrs { _visitor.visit_attribute(it) };
     _visitor.visit_expr(& * _i . func);
     tokens_helper(_visitor, &(& _i . paren_token).0);
-    for el in & _i . args { let it = el.item(); _visitor.visit_expr(it) };
+    for el in Punctuated::elements(& _i . args) { let it = el.item(); _visitor.visit_expr(it) };
 }
 
 pub fn visit_expr_cast<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprCast) {
@@ -840,7 +841,7 @@
     for it in & _i . attrs { _visitor.visit_attribute(it) };
     if let Some(ref it) = _i . capture { tokens_helper(_visitor, &(it).0) };
     tokens_helper(_visitor, &(& _i . or1_token).0);
-    for el in & _i . inputs { let it = el.item(); _visitor.visit_fn_arg(it) };
+    for el in Punctuated::elements(& _i . inputs) { let it = el.item(); _visitor.visit_fn_arg(it) };
     tokens_helper(_visitor, &(& _i . or2_token).0);
     _visitor.visit_return_type(& _i . output);
     _visitor.visit_expr(& * _i . body);
@@ -946,7 +947,7 @@
     _visitor.visit_ident(& _i . method);
     if let Some(ref it) = _i . turbofish { _visitor.visit_method_turbofish(it) };
     tokens_helper(_visitor, &(& _i . paren_token).0);
-    for el in & _i . args { let it = el.item(); _visitor.visit_expr(it) };
+    for el in Punctuated::elements(& _i . args) { let it = el.item(); _visitor.visit_expr(it) };
 }
 # [ cfg ( feature = "full" ) ]
 pub fn visit_expr_paren<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprParen) {
@@ -986,7 +987,7 @@
     for it in & _i . attrs { _visitor.visit_attribute(it) };
     _visitor.visit_path(& _i . path);
     tokens_helper(_visitor, &(& _i . brace_token).0);
-    for el in & _i . fields { let it = el.item(); _visitor.visit_field_value(it) };
+    for el in Punctuated::elements(& _i . fields) { let it = el.item(); _visitor.visit_field_value(it) };
     if let Some(ref it) = _i . dot2_token { tokens_helper(_visitor, &(it).0) };
     if let Some(ref it) = _i . rest { _visitor.visit_expr(& * * it) };
 }
@@ -1000,7 +1001,7 @@
 pub fn visit_expr_tuple<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprTuple) {
     for it in & _i . attrs { _visitor.visit_attribute(it) };
     tokens_helper(_visitor, &(& _i . paren_token).0);
-    for el in & _i . elems { let it = el.item(); _visitor.visit_expr(it) };
+    for el in Punctuated::elements(& _i . elems) { let it = el.item(); _visitor.visit_expr(it) };
 }
 # [ cfg ( feature = "full" ) ]
 pub fn visit_expr_type<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprType) {
@@ -1087,12 +1088,12 @@
 
 pub fn visit_fields_named<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast FieldsNamed) {
     tokens_helper(_visitor, &(& _i . brace_token).0);
-    for el in & _i . named { let it = el.item(); _visitor.visit_field(it) };
+    for el in Punctuated::elements(& _i . named) { let it = el.item(); _visitor.visit_field(it) };
 }
 
 pub fn visit_fields_unnamed<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast FieldsUnnamed) {
     tokens_helper(_visitor, &(& _i . paren_token).0);
-    for el in & _i . unnamed { let it = el.item(); _visitor.visit_field(it) };
+    for el in Punctuated::elements(& _i . unnamed) { let it = el.item(); _visitor.visit_field(it) };
 }
 # [ cfg ( feature = "full" ) ]
 pub fn visit_file<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast File) {
@@ -1125,7 +1126,7 @@
     tokens_helper(_visitor, &(& _i . fn_token).0);
     _visitor.visit_generics(& _i . generics);
     tokens_helper(_visitor, &(& _i . paren_token).0);
-    for el in & _i . inputs { let it = el.item(); _visitor.visit_fn_arg(it) };
+    for el in Punctuated::elements(& _i . inputs) { let it = el.item(); _visitor.visit_fn_arg(it) };
     if let Some(ref it) = _i . variadic { tokens_helper(_visitor, &(it).0) };
     _visitor.visit_return_type(& _i . output);
 }
@@ -1222,7 +1223,7 @@
 
 pub fn visit_generics<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Generics) {
     if let Some(ref it) = _i . lt_token { tokens_helper(_visitor, &(it).0) };
-    for el in & _i . params { let it = el.item(); _visitor.visit_generic_param(it) };
+    for el in Punctuated::elements(& _i . params) { let it = el.item(); _visitor.visit_generic_param(it) };
     if let Some(ref it) = _i . gt_token { tokens_helper(_visitor, &(it).0) };
     if let Some(ref it) = _i . where_clause { _visitor.visit_where_clause(it) };
 }
@@ -1372,7 +1373,7 @@
     _visitor.visit_ident(& _i . ident);
     _visitor.visit_generics(& _i . generics);
     tokens_helper(_visitor, &(& _i . brace_token).0);
-    for el in & _i . variants { let it = el.item(); _visitor.visit_variant(it) };
+    for el in Punctuated::elements(& _i . variants) { let it = el.item(); _visitor.visit_variant(it) };
 }
 # [ cfg ( feature = "full" ) ]
 pub fn visit_item_extern_crate<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ItemExternCrate) {
@@ -1484,7 +1485,7 @@
     _visitor.visit_ident(& _i . ident);
     _visitor.visit_generics(& _i . generics);
     if let Some(ref it) = _i . colon_token { tokens_helper(_visitor, &(it).0) };
-    for el in & _i . supertraits { let it = el.item(); _visitor.visit_type_param_bound(it) };
+    for el in Punctuated::elements(& _i . supertraits) { let it = el.item(); _visitor.visit_type_param_bound(it) };
     tokens_helper(_visitor, &(& _i . brace_token).0);
     for it in & _i . items { _visitor.visit_trait_item(it) };
 }
@@ -1514,7 +1515,7 @@
     _visitor.visit_visibility(& _i . vis);
     tokens_helper(_visitor, &(& _i . use_token).0);
     if let Some(ref it) = _i . leading_colon { tokens_helper(_visitor, &(it).0) };
-    for el in & _i . prefix { let it = el.item(); _visitor.visit_ident(it) };
+    for el in Punctuated::elements(& _i . prefix) { let it = el.item(); _visitor.visit_ident(it) };
     _visitor.visit_use_tree(& _i . tree);
     tokens_helper(_visitor, &(& _i . semi_token).0);
 }
@@ -1537,7 +1538,7 @@
     for it in & _i . attrs { _visitor.visit_attribute(it) };
     _visitor.visit_lifetime(& _i . lifetime);
     if let Some(ref it) = _i . colon_token { tokens_helper(_visitor, &(it).0) };
-    for el in & _i . bounds { let it = el.item(); _visitor.visit_lifetime(it) };
+    for el in Punctuated::elements(& _i . bounds) { let it = el.item(); _visitor.visit_lifetime(it) };
 }
 
 pub fn visit_lit<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Lit) {
@@ -1609,7 +1610,7 @@
 pub fn visit_meta_item_list<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast MetaItemList) {
     _visitor.visit_ident(& _i . ident);
     tokens_helper(_visitor, &(& _i . paren_token).0);
-    for el in & _i . nested { let it = el.item(); _visitor.visit_nested_meta_item(it) };
+    for el in Punctuated::elements(& _i . nested) { let it = el.item(); _visitor.visit_nested_meta_item(it) };
 }
 
 pub fn visit_meta_name_value<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast MetaNameValue) {
@@ -1629,7 +1630,7 @@
 pub fn visit_method_turbofish<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast MethodTurbofish) {
     tokens_helper(_visitor, &(& _i . colon2_token).0);
     tokens_helper(_visitor, &(& _i . lt_token).0);
-    for el in & _i . args { let it = el.item(); _visitor.visit_generic_method_argument(it) };
+    for el in Punctuated::elements(& _i . args) { let it = el.item(); _visitor.visit_generic_method_argument(it) };
     tokens_helper(_visitor, &(& _i . gt_token).0);
 }
 
@@ -1646,7 +1647,7 @@
 
 pub fn visit_parenthesized_generic_arguments<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ParenthesizedGenericArguments) {
     tokens_helper(_visitor, &(& _i . paren_token).0);
-    for el in & _i . inputs { let it = el.item(); _visitor.visit_type(it) };
+    for el in Punctuated::elements(& _i . inputs) { let it = el.item(); _visitor.visit_type(it) };
     _visitor.visit_return_type(& _i . output);
 }
 # [ cfg ( feature = "full" ) ]
@@ -1736,26 +1737,26 @@
 # [ cfg ( feature = "full" ) ]
 pub fn visit_pat_slice<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PatSlice) {
     tokens_helper(_visitor, &(& _i . bracket_token).0);
-    for el in & _i . front { let it = el.item(); _visitor.visit_pat(it) };
+    for el in Punctuated::elements(& _i . front) { let it = el.item(); _visitor.visit_pat(it) };
     if let Some(ref it) = _i . middle { _visitor.visit_pat(& * * it) };
     if let Some(ref it) = _i . dot2_token { tokens_helper(_visitor, &(it).0) };
     if let Some(ref it) = _i . comma_token { tokens_helper(_visitor, &(it).0) };
-    for el in & _i . back { let it = el.item(); _visitor.visit_pat(it) };
+    for el in Punctuated::elements(& _i . back) { let it = el.item(); _visitor.visit_pat(it) };
 }
 # [ cfg ( feature = "full" ) ]
 pub fn visit_pat_struct<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PatStruct) {
     _visitor.visit_path(& _i . path);
     tokens_helper(_visitor, &(& _i . brace_token).0);
-    for el in & _i . fields { let it = el.item(); _visitor.visit_field_pat(it) };
+    for el in Punctuated::elements(& _i . fields) { let it = el.item(); _visitor.visit_field_pat(it) };
     if let Some(ref it) = _i . dot2_token { tokens_helper(_visitor, &(it).0) };
 }
 # [ cfg ( feature = "full" ) ]
 pub fn visit_pat_tuple<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PatTuple) {
     tokens_helper(_visitor, &(& _i . paren_token).0);
-    for el in & _i . front { let it = el.item(); _visitor.visit_pat(it) };
+    for el in Punctuated::elements(& _i . front) { let it = el.item(); _visitor.visit_pat(it) };
     if let Some(ref it) = _i . dot2_token { tokens_helper(_visitor, &(it).0) };
     if let Some(ref it) = _i . comma_token { tokens_helper(_visitor, &(it).0) };
-    for el in & _i . back { let it = el.item(); _visitor.visit_pat(it) };
+    for el in Punctuated::elements(& _i . back) { let it = el.item(); _visitor.visit_pat(it) };
 }
 # [ cfg ( feature = "full" ) ]
 pub fn visit_pat_tuple_struct<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PatTupleStruct) {
@@ -1773,7 +1774,7 @@
 
 pub fn visit_path<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Path) {
     if let Some(ref it) = _i . leading_colon { tokens_helper(_visitor, &(it).0) };
-    for el in & _i . segments { let it = el.item(); _visitor.visit_path_segment(it) };
+    for el in Punctuated::elements(& _i . segments) { let it = el.item(); _visitor.visit_path_segment(it) };
 }
 
 pub fn visit_path_arguments<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PathArguments) {
@@ -1807,14 +1808,14 @@
 pub fn visit_predicate_lifetime<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PredicateLifetime) {
     _visitor.visit_lifetime(& _i . lifetime);
     if let Some(ref it) = _i . colon_token { tokens_helper(_visitor, &(it).0) };
-    for el in & _i . bounds { let it = el.item(); _visitor.visit_lifetime(it) };
+    for el in Punctuated::elements(& _i . bounds) { let it = el.item(); _visitor.visit_lifetime(it) };
 }
 
 pub fn visit_predicate_type<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PredicateType) {
     if let Some(ref it) = _i . bound_lifetimes { _visitor.visit_bound_lifetimes(it) };
     _visitor.visit_type(& _i . bounded_ty);
     tokens_helper(_visitor, &(& _i . colon_token).0);
-    for el in & _i . bounds { let it = el.item(); _visitor.visit_type_param_bound(it) };
+    for el in Punctuated::elements(& _i . bounds) { let it = el.item(); _visitor.visit_type_param_bound(it) };
 }
 
 pub fn visit_qself<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast QSelf) {
@@ -1928,7 +1929,7 @@
     _visitor.visit_ident(& _i . ident);
     _visitor.visit_generics(& _i . generics);
     if let Some(ref it) = _i . colon_token { tokens_helper(_visitor, &(it).0) };
-    for el in & _i . bounds { let it = el.item(); _visitor.visit_type_param_bound(it) };
+    for el in Punctuated::elements(& _i . bounds) { let it = el.item(); _visitor.visit_type_param_bound(it) };
     if let Some(ref it) = _i . default { 
             tokens_helper(_visitor, &(& ( it ) . 0).0);
             _visitor.visit_type(& ( it ) . 1);
@@ -2003,7 +2004,7 @@
     tokens_helper(_visitor, &(& _i . fn_token).0);
     if let Some(ref it) = _i . lifetimes { _visitor.visit_bound_lifetimes(it) };
     tokens_helper(_visitor, &(& _i . paren_token).0);
-    for el in & _i . inputs { let it = el.item(); _visitor.visit_bare_fn_arg(it) };
+    for el in Punctuated::elements(& _i . inputs) { let it = el.item(); _visitor.visit_bare_fn_arg(it) };
     if let Some(ref it) = _i . variadic { tokens_helper(_visitor, &(it).0) };
     _visitor.visit_return_type(& _i . output);
 }
@@ -2015,7 +2016,7 @@
 
 pub fn visit_type_impl_trait<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast TypeImplTrait) {
     tokens_helper(_visitor, &(& _i . impl_token).0);
-    for el in & _i . bounds { let it = el.item(); _visitor.visit_type_param_bound(it) };
+    for el in Punctuated::elements(& _i . bounds) { let it = el.item(); _visitor.visit_type_param_bound(it) };
 }
 
 pub fn visit_type_infer<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast TypeInfer) {
@@ -2034,7 +2035,7 @@
     for it in & _i . attrs { _visitor.visit_attribute(it) };
     _visitor.visit_ident(& _i . ident);
     if let Some(ref it) = _i . colon_token { tokens_helper(_visitor, &(it).0) };
-    for el in & _i . bounds { let it = el.item(); _visitor.visit_type_param_bound(it) };
+    for el in Punctuated::elements(& _i . bounds) { let it = el.item(); _visitor.visit_type_param_bound(it) };
     if let Some(ref it) = _i . eq_token { tokens_helper(_visitor, &(it).0) };
     if let Some(ref it) = _i . default { _visitor.visit_type(it) };
 }
@@ -2082,12 +2083,12 @@
 
 pub fn visit_type_trait_object<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast TypeTraitObject) {
     if let Some(ref it) = _i . dyn_token { tokens_helper(_visitor, &(it).0) };
-    for el in & _i . bounds { let it = el.item(); _visitor.visit_type_param_bound(it) };
+    for el in Punctuated::elements(& _i . bounds) { let it = el.item(); _visitor.visit_type_param_bound(it) };
 }
 
 pub fn visit_type_tuple<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast TypeTuple) {
     tokens_helper(_visitor, &(& _i . paren_token).0);
-    for el in & _i . elems { let it = el.item(); _visitor.visit_type(it) };
+    for el in Punctuated::elements(& _i . elems) { let it = el.item(); _visitor.visit_type(it) };
 }
 
 pub fn visit_type_verbatim<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast TypeVerbatim) {
@@ -2114,7 +2115,7 @@
 # [ cfg ( feature = "full" ) ]
 pub fn visit_use_list<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast UseList) {
     tokens_helper(_visitor, &(& _i . brace_token).0);
-    for el in & _i . items { let it = el.item(); _visitor.visit_use_tree(it) };
+    for el in Punctuated::elements(& _i . items) { let it = el.item(); _visitor.visit_use_tree(it) };
 }
 # [ cfg ( feature = "full" ) ]
 pub fn visit_use_path<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast UsePath) {
@@ -2183,7 +2184,7 @@
 
 pub fn visit_where_clause<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast WhereClause) {
     tokens_helper(_visitor, &(& _i . where_token).0);
-    for el in & _i . predicates { let it = el.item(); _visitor.visit_where_predicate(it) };
+    for el in Punctuated::elements(& _i . predicates) { let it = el.item(); _visitor.visit_where_predicate(it) };
 }
 
 pub fn visit_where_predicate<'ast, V: Visitor<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast WherePredicate) {
diff --git a/src/gen/visit_mut.rs b/src/gen/visit_mut.rs
index 99dec91..4019815 100644
--- a/src/gen/visit_mut.rs
+++ b/src/gen/visit_mut.rs
@@ -10,6 +10,7 @@
 #![cfg_attr(feature = "cargo-clippy", allow(match_same_arms))]
 
 use *;
+use punctuated::Punctuated;
 use proc_macro2::Span;
 use gen::helper::visit_mut::*;
 
@@ -411,7 +412,7 @@
 pub fn visit_angle_bracketed_generic_arguments_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut AngleBracketedGenericArguments) {
     if let Some(ref mut it) = _i . colon2_token { tokens_helper(_visitor, &mut (it).0) };
     tokens_helper(_visitor, &mut (& mut _i . lt_token).0);
-    for mut el in & mut _i . args { let it = el.item_mut(); _visitor.visit_generic_argument_mut(it) };
+    for mut el in Punctuated::elements_mut(& mut _i . args) { let it = el.item_mut(); _visitor.visit_generic_argument_mut(it) };
     tokens_helper(_visitor, &mut (& mut _i . gt_token).0);
 }
 # [ cfg ( feature = "full" ) ]
@@ -435,7 +436,7 @@
 # [ cfg ( feature = "full" ) ]
 pub fn visit_arm_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Arm) {
     for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
-    for mut el in & mut _i . pats { let it = el.item_mut(); _visitor.visit_pat_mut(it) };
+    for mut el in Punctuated::elements_mut(& mut _i . pats) { let it = el.item_mut(); _visitor.visit_pat_mut(it) };
     if let Some(ref mut it) = _i . guard { 
             tokens_helper(_visitor, &mut (& mut ( it ) . 0).0);
             _visitor.visit_expr_mut(& mut * ( it ) . 1);
@@ -585,7 +586,7 @@
 pub fn visit_bound_lifetimes_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut BoundLifetimes) {
     tokens_helper(_visitor, &mut (& mut _i . for_token).0);
     tokens_helper(_visitor, &mut (& mut _i . lt_token).0);
-    for mut el in & mut _i . lifetimes { let it = el.item_mut(); _visitor.visit_lifetime_def_mut(it) };
+    for mut el in Punctuated::elements_mut(& mut _i . lifetimes) { let it = el.item_mut(); _visitor.visit_lifetime_def_mut(it) };
     tokens_helper(_visitor, &mut (& mut _i . gt_token).0);
 }
 
@@ -616,7 +617,7 @@
 pub fn visit_data_enum_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut DataEnum) {
     tokens_helper(_visitor, &mut (& mut _i . enum_token).0);
     tokens_helper(_visitor, &mut (& mut _i . brace_token).0);
-    for mut el in & mut _i . variants { let it = el.item_mut(); _visitor.visit_variant_mut(it) };
+    for mut el in Punctuated::elements_mut(& mut _i . variants) { let it = el.item_mut(); _visitor.visit_variant_mut(it) };
 }
 
 pub fn visit_data_struct_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut DataStruct) {
@@ -773,7 +774,7 @@
 pub fn visit_expr_array_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprArray) {
     for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
     tokens_helper(_visitor, &mut (& mut _i . bracket_token).0);
-    for mut el in & mut _i . elems { let it = el.item_mut(); _visitor.visit_expr_mut(it) };
+    for mut el in Punctuated::elements_mut(& mut _i . elems) { let it = el.item_mut(); _visitor.visit_expr_mut(it) };
 }
 # [ cfg ( feature = "full" ) ]
 pub fn visit_expr_assign_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprAssign) {
@@ -819,7 +820,7 @@
     for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
     _visitor.visit_expr_mut(& mut * _i . func);
     tokens_helper(_visitor, &mut (& mut _i . paren_token).0);
-    for mut el in & mut _i . args { let it = el.item_mut(); _visitor.visit_expr_mut(it) };
+    for mut el in Punctuated::elements_mut(& mut _i . args) { let it = el.item_mut(); _visitor.visit_expr_mut(it) };
 }
 
 pub fn visit_expr_cast_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprCast) {
@@ -840,7 +841,7 @@
     for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
     if let Some(ref mut it) = _i . capture { tokens_helper(_visitor, &mut (it).0) };
     tokens_helper(_visitor, &mut (& mut _i . or1_token).0);
-    for mut el in & mut _i . inputs { let it = el.item_mut(); _visitor.visit_fn_arg_mut(it) };
+    for mut el in Punctuated::elements_mut(& mut _i . inputs) { let it = el.item_mut(); _visitor.visit_fn_arg_mut(it) };
     tokens_helper(_visitor, &mut (& mut _i . or2_token).0);
     _visitor.visit_return_type_mut(& mut _i . output);
     _visitor.visit_expr_mut(& mut * _i . body);
@@ -946,7 +947,7 @@
     _visitor.visit_ident_mut(& mut _i . method);
     if let Some(ref mut it) = _i . turbofish { _visitor.visit_method_turbofish_mut(it) };
     tokens_helper(_visitor, &mut (& mut _i . paren_token).0);
-    for mut el in & mut _i . args { let it = el.item_mut(); _visitor.visit_expr_mut(it) };
+    for mut el in Punctuated::elements_mut(& mut _i . args) { let it = el.item_mut(); _visitor.visit_expr_mut(it) };
 }
 # [ cfg ( feature = "full" ) ]
 pub fn visit_expr_paren_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprParen) {
@@ -986,7 +987,7 @@
     for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
     _visitor.visit_path_mut(& mut _i . path);
     tokens_helper(_visitor, &mut (& mut _i . brace_token).0);
-    for mut el in & mut _i . fields { let it = el.item_mut(); _visitor.visit_field_value_mut(it) };
+    for mut el in Punctuated::elements_mut(& mut _i . fields) { let it = el.item_mut(); _visitor.visit_field_value_mut(it) };
     if let Some(ref mut it) = _i . dot2_token { tokens_helper(_visitor, &mut (it).0) };
     if let Some(ref mut it) = _i . rest { _visitor.visit_expr_mut(& mut * * it) };
 }
@@ -1000,7 +1001,7 @@
 pub fn visit_expr_tuple_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprTuple) {
     for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
     tokens_helper(_visitor, &mut (& mut _i . paren_token).0);
-    for mut el in & mut _i . elems { let it = el.item_mut(); _visitor.visit_expr_mut(it) };
+    for mut el in Punctuated::elements_mut(& mut _i . elems) { let it = el.item_mut(); _visitor.visit_expr_mut(it) };
 }
 # [ cfg ( feature = "full" ) ]
 pub fn visit_expr_type_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprType) {
@@ -1087,12 +1088,12 @@
 
 pub fn visit_fields_named_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut FieldsNamed) {
     tokens_helper(_visitor, &mut (& mut _i . brace_token).0);
-    for mut el in & mut _i . named { let it = el.item_mut(); _visitor.visit_field_mut(it) };
+    for mut el in Punctuated::elements_mut(& mut _i . named) { let it = el.item_mut(); _visitor.visit_field_mut(it) };
 }
 
 pub fn visit_fields_unnamed_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut FieldsUnnamed) {
     tokens_helper(_visitor, &mut (& mut _i . paren_token).0);
-    for mut el in & mut _i . unnamed { let it = el.item_mut(); _visitor.visit_field_mut(it) };
+    for mut el in Punctuated::elements_mut(& mut _i . unnamed) { let it = el.item_mut(); _visitor.visit_field_mut(it) };
 }
 # [ cfg ( feature = "full" ) ]
 pub fn visit_file_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut File) {
@@ -1125,7 +1126,7 @@
     tokens_helper(_visitor, &mut (& mut _i . fn_token).0);
     _visitor.visit_generics_mut(& mut _i . generics);
     tokens_helper(_visitor, &mut (& mut _i . paren_token).0);
-    for mut el in & mut _i . inputs { let it = el.item_mut(); _visitor.visit_fn_arg_mut(it) };
+    for mut el in Punctuated::elements_mut(& mut _i . inputs) { let it = el.item_mut(); _visitor.visit_fn_arg_mut(it) };
     if let Some(ref mut it) = _i . variadic { tokens_helper(_visitor, &mut (it).0) };
     _visitor.visit_return_type_mut(& mut _i . output);
 }
@@ -1222,7 +1223,7 @@
 
 pub fn visit_generics_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Generics) {
     if let Some(ref mut it) = _i . lt_token { tokens_helper(_visitor, &mut (it).0) };
-    for mut el in & mut _i . params { let it = el.item_mut(); _visitor.visit_generic_param_mut(it) };
+    for mut el in Punctuated::elements_mut(& mut _i . params) { let it = el.item_mut(); _visitor.visit_generic_param_mut(it) };
     if let Some(ref mut it) = _i . gt_token { tokens_helper(_visitor, &mut (it).0) };
     if let Some(ref mut it) = _i . where_clause { _visitor.visit_where_clause_mut(it) };
 }
@@ -1372,7 +1373,7 @@
     _visitor.visit_ident_mut(& mut _i . ident);
     _visitor.visit_generics_mut(& mut _i . generics);
     tokens_helper(_visitor, &mut (& mut _i . brace_token).0);
-    for mut el in & mut _i . variants { let it = el.item_mut(); _visitor.visit_variant_mut(it) };
+    for mut el in Punctuated::elements_mut(& mut _i . variants) { let it = el.item_mut(); _visitor.visit_variant_mut(it) };
 }
 # [ cfg ( feature = "full" ) ]
 pub fn visit_item_extern_crate_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ItemExternCrate) {
@@ -1484,7 +1485,7 @@
     _visitor.visit_ident_mut(& mut _i . ident);
     _visitor.visit_generics_mut(& mut _i . generics);
     if let Some(ref mut it) = _i . colon_token { tokens_helper(_visitor, &mut (it).0) };
-    for mut el in & mut _i . supertraits { let it = el.item_mut(); _visitor.visit_type_param_bound_mut(it) };
+    for mut el in Punctuated::elements_mut(& mut _i . supertraits) { let it = el.item_mut(); _visitor.visit_type_param_bound_mut(it) };
     tokens_helper(_visitor, &mut (& mut _i . brace_token).0);
     for it in & mut _i . items { _visitor.visit_trait_item_mut(it) };
 }
@@ -1514,7 +1515,7 @@
     _visitor.visit_visibility_mut(& mut _i . vis);
     tokens_helper(_visitor, &mut (& mut _i . use_token).0);
     if let Some(ref mut it) = _i . leading_colon { tokens_helper(_visitor, &mut (it).0) };
-    for mut el in & mut _i . prefix { let it = el.item_mut(); _visitor.visit_ident_mut(it) };
+    for mut el in Punctuated::elements_mut(& mut _i . prefix) { let it = el.item_mut(); _visitor.visit_ident_mut(it) };
     _visitor.visit_use_tree_mut(& mut _i . tree);
     tokens_helper(_visitor, &mut (& mut _i . semi_token).0);
 }
@@ -1537,7 +1538,7 @@
     for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
     _visitor.visit_lifetime_mut(& mut _i . lifetime);
     if let Some(ref mut it) = _i . colon_token { tokens_helper(_visitor, &mut (it).0) };
-    for mut el in & mut _i . bounds { let it = el.item_mut(); _visitor.visit_lifetime_mut(it) };
+    for mut el in Punctuated::elements_mut(& mut _i . bounds) { let it = el.item_mut(); _visitor.visit_lifetime_mut(it) };
 }
 
 pub fn visit_lit_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Lit) {
@@ -1609,7 +1610,7 @@
 pub fn visit_meta_item_list_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut MetaItemList) {
     _visitor.visit_ident_mut(& mut _i . ident);
     tokens_helper(_visitor, &mut (& mut _i . paren_token).0);
-    for mut el in & mut _i . nested { let it = el.item_mut(); _visitor.visit_nested_meta_item_mut(it) };
+    for mut el in Punctuated::elements_mut(& mut _i . nested) { let it = el.item_mut(); _visitor.visit_nested_meta_item_mut(it) };
 }
 
 pub fn visit_meta_name_value_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut MetaNameValue) {
@@ -1629,7 +1630,7 @@
 pub fn visit_method_turbofish_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut MethodTurbofish) {
     tokens_helper(_visitor, &mut (& mut _i . colon2_token).0);
     tokens_helper(_visitor, &mut (& mut _i . lt_token).0);
-    for mut el in & mut _i . args { let it = el.item_mut(); _visitor.visit_generic_method_argument_mut(it) };
+    for mut el in Punctuated::elements_mut(& mut _i . args) { let it = el.item_mut(); _visitor.visit_generic_method_argument_mut(it) };
     tokens_helper(_visitor, &mut (& mut _i . gt_token).0);
 }
 
@@ -1646,7 +1647,7 @@
 
 pub fn visit_parenthesized_generic_arguments_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ParenthesizedGenericArguments) {
     tokens_helper(_visitor, &mut (& mut _i . paren_token).0);
-    for mut el in & mut _i . inputs { let it = el.item_mut(); _visitor.visit_type_mut(it) };
+    for mut el in Punctuated::elements_mut(& mut _i . inputs) { let it = el.item_mut(); _visitor.visit_type_mut(it) };
     _visitor.visit_return_type_mut(& mut _i . output);
 }
 # [ cfg ( feature = "full" ) ]
@@ -1736,26 +1737,26 @@
 # [ cfg ( feature = "full" ) ]
 pub fn visit_pat_slice_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut PatSlice) {
     tokens_helper(_visitor, &mut (& mut _i . bracket_token).0);
-    for mut el in & mut _i . front { let it = el.item_mut(); _visitor.visit_pat_mut(it) };
+    for mut el in Punctuated::elements_mut(& mut _i . front) { let it = el.item_mut(); _visitor.visit_pat_mut(it) };
     if let Some(ref mut it) = _i . middle { _visitor.visit_pat_mut(& mut * * it) };
     if let Some(ref mut it) = _i . dot2_token { tokens_helper(_visitor, &mut (it).0) };
     if let Some(ref mut it) = _i . comma_token { tokens_helper(_visitor, &mut (it).0) };
-    for mut el in & mut _i . back { let it = el.item_mut(); _visitor.visit_pat_mut(it) };
+    for mut el in Punctuated::elements_mut(& mut _i . back) { let it = el.item_mut(); _visitor.visit_pat_mut(it) };
 }
 # [ cfg ( feature = "full" ) ]
 pub fn visit_pat_struct_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut PatStruct) {
     _visitor.visit_path_mut(& mut _i . path);
     tokens_helper(_visitor, &mut (& mut _i . brace_token).0);
-    for mut el in & mut _i . fields { let it = el.item_mut(); _visitor.visit_field_pat_mut(it) };
+    for mut el in Punctuated::elements_mut(& mut _i . fields) { let it = el.item_mut(); _visitor.visit_field_pat_mut(it) };
     if let Some(ref mut it) = _i . dot2_token { tokens_helper(_visitor, &mut (it).0) };
 }
 # [ cfg ( feature = "full" ) ]
 pub fn visit_pat_tuple_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut PatTuple) {
     tokens_helper(_visitor, &mut (& mut _i . paren_token).0);
-    for mut el in & mut _i . front { let it = el.item_mut(); _visitor.visit_pat_mut(it) };
+    for mut el in Punctuated::elements_mut(& mut _i . front) { let it = el.item_mut(); _visitor.visit_pat_mut(it) };
     if let Some(ref mut it) = _i . dot2_token { tokens_helper(_visitor, &mut (it).0) };
     if let Some(ref mut it) = _i . comma_token { tokens_helper(_visitor, &mut (it).0) };
-    for mut el in & mut _i . back { let it = el.item_mut(); _visitor.visit_pat_mut(it) };
+    for mut el in Punctuated::elements_mut(& mut _i . back) { let it = el.item_mut(); _visitor.visit_pat_mut(it) };
 }
 # [ cfg ( feature = "full" ) ]
 pub fn visit_pat_tuple_struct_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut PatTupleStruct) {
@@ -1773,7 +1774,7 @@
 
 pub fn visit_path_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Path) {
     if let Some(ref mut it) = _i . leading_colon { tokens_helper(_visitor, &mut (it).0) };
-    for mut el in & mut _i . segments { let it = el.item_mut(); _visitor.visit_path_segment_mut(it) };
+    for mut el in Punctuated::elements_mut(& mut _i . segments) { let it = el.item_mut(); _visitor.visit_path_segment_mut(it) };
 }
 
 pub fn visit_path_arguments_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut PathArguments) {
@@ -1807,14 +1808,14 @@
 pub fn visit_predicate_lifetime_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut PredicateLifetime) {
     _visitor.visit_lifetime_mut(& mut _i . lifetime);
     if let Some(ref mut it) = _i . colon_token { tokens_helper(_visitor, &mut (it).0) };
-    for mut el in & mut _i . bounds { let it = el.item_mut(); _visitor.visit_lifetime_mut(it) };
+    for mut el in Punctuated::elements_mut(& mut _i . bounds) { let it = el.item_mut(); _visitor.visit_lifetime_mut(it) };
 }
 
 pub fn visit_predicate_type_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut PredicateType) {
     if let Some(ref mut it) = _i . bound_lifetimes { _visitor.visit_bound_lifetimes_mut(it) };
     _visitor.visit_type_mut(& mut _i . bounded_ty);
     tokens_helper(_visitor, &mut (& mut _i . colon_token).0);
-    for mut el in & mut _i . bounds { let it = el.item_mut(); _visitor.visit_type_param_bound_mut(it) };
+    for mut el in Punctuated::elements_mut(& mut _i . bounds) { let it = el.item_mut(); _visitor.visit_type_param_bound_mut(it) };
 }
 
 pub fn visit_qself_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut QSelf) {
@@ -1928,7 +1929,7 @@
     _visitor.visit_ident_mut(& mut _i . ident);
     _visitor.visit_generics_mut(& mut _i . generics);
     if let Some(ref mut it) = _i . colon_token { tokens_helper(_visitor, &mut (it).0) };
-    for mut el in & mut _i . bounds { let it = el.item_mut(); _visitor.visit_type_param_bound_mut(it) };
+    for mut el in Punctuated::elements_mut(& mut _i . bounds) { let it = el.item_mut(); _visitor.visit_type_param_bound_mut(it) };
     if let Some(ref mut it) = _i . default { 
             tokens_helper(_visitor, &mut (& mut ( it ) . 0).0);
             _visitor.visit_type_mut(& mut ( it ) . 1);
@@ -2003,7 +2004,7 @@
     tokens_helper(_visitor, &mut (& mut _i . fn_token).0);
     if let Some(ref mut it) = _i . lifetimes { _visitor.visit_bound_lifetimes_mut(it) };
     tokens_helper(_visitor, &mut (& mut _i . paren_token).0);
-    for mut el in & mut _i . inputs { let it = el.item_mut(); _visitor.visit_bare_fn_arg_mut(it) };
+    for mut el in Punctuated::elements_mut(& mut _i . inputs) { let it = el.item_mut(); _visitor.visit_bare_fn_arg_mut(it) };
     if let Some(ref mut it) = _i . variadic { tokens_helper(_visitor, &mut (it).0) };
     _visitor.visit_return_type_mut(& mut _i . output);
 }
@@ -2015,7 +2016,7 @@
 
 pub fn visit_type_impl_trait_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut TypeImplTrait) {
     tokens_helper(_visitor, &mut (& mut _i . impl_token).0);
-    for mut el in & mut _i . bounds { let it = el.item_mut(); _visitor.visit_type_param_bound_mut(it) };
+    for mut el in Punctuated::elements_mut(& mut _i . bounds) { let it = el.item_mut(); _visitor.visit_type_param_bound_mut(it) };
 }
 
 pub fn visit_type_infer_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut TypeInfer) {
@@ -2034,7 +2035,7 @@
     for it in & mut _i . attrs { _visitor.visit_attribute_mut(it) };
     _visitor.visit_ident_mut(& mut _i . ident);
     if let Some(ref mut it) = _i . colon_token { tokens_helper(_visitor, &mut (it).0) };
-    for mut el in & mut _i . bounds { let it = el.item_mut(); _visitor.visit_type_param_bound_mut(it) };
+    for mut el in Punctuated::elements_mut(& mut _i . bounds) { let it = el.item_mut(); _visitor.visit_type_param_bound_mut(it) };
     if let Some(ref mut it) = _i . eq_token { tokens_helper(_visitor, &mut (it).0) };
     if let Some(ref mut it) = _i . default { _visitor.visit_type_mut(it) };
 }
@@ -2082,12 +2083,12 @@
 
 pub fn visit_type_trait_object_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut TypeTraitObject) {
     if let Some(ref mut it) = _i . dyn_token { tokens_helper(_visitor, &mut (it).0) };
-    for mut el in & mut _i . bounds { let it = el.item_mut(); _visitor.visit_type_param_bound_mut(it) };
+    for mut el in Punctuated::elements_mut(& mut _i . bounds) { let it = el.item_mut(); _visitor.visit_type_param_bound_mut(it) };
 }
 
 pub fn visit_type_tuple_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut TypeTuple) {
     tokens_helper(_visitor, &mut (& mut _i . paren_token).0);
-    for mut el in & mut _i . elems { let it = el.item_mut(); _visitor.visit_type_mut(it) };
+    for mut el in Punctuated::elements_mut(& mut _i . elems) { let it = el.item_mut(); _visitor.visit_type_mut(it) };
 }
 
 pub fn visit_type_verbatim_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut TypeVerbatim) {
@@ -2114,7 +2115,7 @@
 # [ cfg ( feature = "full" ) ]
 pub fn visit_use_list_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut UseList) {
     tokens_helper(_visitor, &mut (& mut _i . brace_token).0);
-    for mut el in & mut _i . items { let it = el.item_mut(); _visitor.visit_use_tree_mut(it) };
+    for mut el in Punctuated::elements_mut(& mut _i . items) { let it = el.item_mut(); _visitor.visit_use_tree_mut(it) };
 }
 # [ cfg ( feature = "full" ) ]
 pub fn visit_use_path_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut UsePath) {
@@ -2183,7 +2184,7 @@
 
 pub fn visit_where_clause_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut WhereClause) {
     tokens_helper(_visitor, &mut (& mut _i . where_token).0);
-    for mut el in & mut _i . predicates { let it = el.item_mut(); _visitor.visit_where_predicate_mut(it) };
+    for mut el in Punctuated::elements_mut(& mut _i . predicates) { let it = el.item_mut(); _visitor.visit_where_predicate_mut(it) };
 }
 
 pub fn visit_where_predicate_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut WherePredicate) {
diff --git a/src/gen_helper.rs b/src/gen_helper.rs
index 36139c5..5754ac3 100644
--- a/src/gen_helper.rs
+++ b/src/gen_helper.rs
@@ -19,7 +19,7 @@
     impl<T, U> FoldHelper for Punctuated<T, U> {
         type Item = T;
         fn lift<F>(self, mut f: F) -> Self where F: FnMut(Self::Item) -> Self::Item {
-            self.into_iter()
+            self.into_elements()
                 .map(Element::into_tuple)
                 .map(|(t, u)| Element::new(f(t), u))
                 .collect()
diff --git a/src/generics.rs b/src/generics.rs
index 509fcd2..4260f18 100644
--- a/src/generics.rs
+++ b/src/generics.rs
@@ -215,11 +215,11 @@
             ),
             |(lifetimes, ty_params, lt, gt)| Generics {
                 lt_token: lt,
-                params: lifetimes.into_iter()
+                params: lifetimes.into_elements()
                     .map(Element::into_tuple)
                     .map(|(life, comma)| Element::new(GenericParam::Lifetime(life), comma))
                     .chain(ty_params.unwrap_or_default()
-                        .into_iter()
+                        .into_elements()
                         .map(Element::into_tuple)
                         .map(|(ty, comma)| Element::new(GenericParam::Type(ty), comma)))
                     .collect(),
@@ -438,7 +438,7 @@
             }
 
             TokensOrDefault(&self.0.lt_token).to_tokens(tokens);
-            for param in self.0.params.iter() {
+            for param in self.0.params.elements() {
                 match **param.item() {
                     GenericParam::Lifetime(ref param) => {
                         param.to_tokens(tokens);
@@ -474,7 +474,7 @@
             }
 
             TokensOrDefault(&self.0.lt_token).to_tokens(tokens);
-            for param in self.0.params.iter() {
+            for param in self.0.params.elements() {
                 match **param.item() {
                     GenericParam::Lifetime(ref param) => {
                         // Leave off the lifetime bounds and attributes
diff --git a/src/punctuated.rs b/src/punctuated.rs
index a4b884d..e8e6bd7 100644
--- a/src/punctuated.rs
+++ b/src/punctuated.rs
@@ -52,12 +52,24 @@
         }
     }
 
-    pub fn iter_mut(&mut self) -> IterMut<T, P> {
-        IterMut {
+    pub fn elements(&self) -> Elements<T, P> {
+        Elements {
+            inner: self.inner.iter(),
+        }
+    }
+
+    pub fn elements_mut(&mut self) -> ElementsMut<T, P> {
+        ElementsMut {
             inner: self.inner.iter_mut(),
         }
     }
 
+    pub fn into_elements(self) -> IntoElements<T, P> {
+        IntoElements {
+            inner: self.inner.into_iter(),
+        }
+    }
+
     pub fn push(&mut self, token: T) {
         assert!(self.empty_or_trailing());
         self.inner.push((token, None));
@@ -113,26 +125,8 @@
     }
 }
 
-impl<'a, T, P> IntoIterator for &'a Punctuated<T, P> {
-    type Item = Element<&'a T, &'a P>;
-    type IntoIter = Iter<'a, T, P>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        Punctuated::iter(self)
-    }
-}
-
-impl<'a, T, P> IntoIterator for &'a mut Punctuated<T, P> {
-    type Item = Element<&'a mut T, &'a mut P>;
-    type IntoIter = IterMut<'a, T, P>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        Punctuated::iter_mut(self)
-    }
-}
-
 impl<T, P> IntoIterator for Punctuated<T, P> {
-    type Item = Element<T, P>;
+    type Item = T;
     type IntoIter = IntoIter<T, P>;
 
     fn into_iter(self) -> Self::IntoIter {
@@ -142,20 +136,29 @@
     }
 }
 
+impl<'a, T, P> IntoIterator for &'a Punctuated<T, P> {
+    type Item = &'a T;
+    type IntoIter = Iter<'a, T, P>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        Punctuated::iter(self)
+    }
+}
+
 impl<T, P> Default for Punctuated<T, P> {
     fn default() -> Self {
         Punctuated::new()
     }
 }
 
-pub struct Iter<'a, T: 'a, P: 'a> {
+pub struct Elements<'a, T: 'a, P: 'a> {
     inner: slice::Iter<'a, (T, Option<P>)>,
 }
 
-impl<'a, T, P> Iterator for Iter<'a, T, P> {
+impl<'a, T, P> Iterator for Elements<'a, T, P> {
     type Item = Element<&'a T, &'a P>;
 
-    fn next(&mut self) -> Option<Element<&'a T, &'a P>> {
+    fn next(&mut self) -> Option<Self::Item> {
         self.inner.next().map(|pair| match pair.1 {
             Some(ref p) => Element::Punctuated(&pair.0, p),
             None => Element::End(&pair.0),
@@ -163,14 +166,14 @@
     }
 }
 
-pub struct IterMut<'a, T: 'a, P: 'a> {
+pub struct ElementsMut<'a, T: 'a, P: 'a> {
     inner: slice::IterMut<'a, (T, Option<P>)>,
 }
 
-impl<'a, T, P> Iterator for IterMut<'a, T, P> {
+impl<'a, T, P> Iterator for ElementsMut<'a, T, P> {
     type Item = Element<&'a mut T, &'a mut P>;
 
-    fn next(&mut self) -> Option<Element<&'a mut T, &'a mut P>> {
+    fn next(&mut self) -> Option<Self::Item> {
         self.inner.next().map(|pair| match pair.1 {
             Some(ref mut p) => Element::Punctuated(&mut pair.0, p),
             None => Element::End(&mut pair.0),
@@ -178,18 +181,42 @@
     }
 }
 
+pub struct IntoElements<T, P> {
+    inner: vec::IntoIter<(T, Option<P>)>,
+}
+
+impl<T, P> Iterator for IntoElements<T, P> {
+    type Item = Element<T, P>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.inner.next().map(|pair| match pair.1 {
+            Some(p) => Element::Punctuated(pair.0, p),
+            None => Element::End(pair.0),
+        })
+    }
+}
+
 pub struct IntoIter<T, P> {
     inner: vec::IntoIter<(T, Option<P>)>,
 }
 
 impl<T, P> Iterator for IntoIter<T, P> {
-    type Item = Element<T, P>;
+    type Item = T;
 
-    fn next(&mut self) -> Option<Element<T, P>> {
-        self.inner.next().map(|pair| match pair.1 {
-            Some(v) => Element::Punctuated(pair.0, v),
-            None => Element::End(pair.0),
-        })
+    fn next(&mut self) -> Option<Self::Item> {
+        self.inner.next().map(|pair| pair.0)
+    }
+}
+
+pub struct Iter<'a, T: 'a, P: 'a> {
+    inner: slice::Iter<'a, (T, Option<P>)>,
+}
+
+impl<'a, T, P> Iterator for Iter<'a, T, P> {
+    type Item = &'a T;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.inner.next().map(|pair| &pair.0)
     }
 }
 
diff --git a/src/ty.rs b/src/ty.rs
index 4476eb3..b504b47 100644
--- a/src/ty.rs
+++ b/src/ty.rs
@@ -583,7 +583,7 @@
                     Some((as_, mut path)) => {
                         let pos = path.segments.len();
                         path.segments.push_trailing(colon2);
-                        path.segments.extend(rest);
+                        path.segments.extend(rest.into_elements());
                         (pos, Some(as_), path)
                     }
                     None => {
@@ -1016,11 +1016,11 @@
             } else {
                 qself.position
             };
-            let mut segments = self.1.segments.iter();
+            let mut segments = self.1.segments.elements();
             if pos > 0 {
                 TokensOrDefault(&qself.as_token).to_tokens(tokens);
                 self.1.leading_colon.to_tokens(tokens);
-                for (i, segment) in (&mut segments).take(pos).enumerate() {
+                for (i, segment) in segments.by_ref().take(pos).enumerate() {
                     if i + 1 == pos {
                         segment.item().to_tokens(tokens);
                         qself.gt_token.to_tokens(tokens);