diff --git a/codegen/src/main.rs b/codegen/src/main.rs
index 4a7ec38..0cf873e 100644
--- a/codegen/src/main.rs
+++ b/codegen/src/main.rs
@@ -351,6 +351,8 @@
     use proc_macro2::{Span, TokenStream};
     use quote::{ToTokens, TokenStreamExt};
     use syn::punctuated::Punctuated;
+    use syn::synom::ext::IdentExt;
+    use syn::synom::Parser;
     use syn::*;
 
     #[derive(Default)]
@@ -374,7 +376,9 @@
         Option(&'a Type),
         Tuple(&'a Punctuated<Type, Token![,]>),
         Simple(&'a AstItem),
-        Token(TokenStream),
+        TokenPunct(TokenStream),
+        TokenKeyword(TokenStream),
+        TokenGroup(Ident),
         Pass,
     }
 
@@ -391,7 +395,7 @@
                     "Punctuated" => RelevantType::Punctuated(first_arg(&last.arguments)),
                     "Option" => RelevantType::Option(first_arg(&last.arguments)),
                     "Brace" | "Bracket" | "Paren" | "Group" => {
-                        RelevantType::Token(last.ident.clone().into_token_stream())
+                        RelevantType::TokenGroup(last.ident.clone())
                     }
                     _ => {
                         if let Some(item) = lookup.get(&last.ident) {
@@ -406,7 +410,13 @@
             Type::Macro(TypeMacro { ref mac })
                 if mac.path.segments.last().unwrap().into_value().ident == "Token" =>
             {
-                RelevantType::Token(mac.into_token_stream())
+                let is_ident = Ident::parse_any.parse2(mac.tts.clone()).is_ok() ;
+                let is_underscore = parse2::<Token![_]>(mac.tts.clone()).is_ok();
+                if is_ident && !is_underscore {
+                    RelevantType::TokenKeyword(mac.into_token_stream())
+                } else {
+                    RelevantType::TokenPunct(mac.into_token_stream())
+                }
             }
             _ => RelevantType::Pass,
         }
@@ -642,17 +652,47 @@
         })
     }
 
-    fn token_visit(ty: TokenStream, kind: Kind, name: &Operand) -> TokenStream {
+    fn token_punct_visit(ty: TokenStream, kind: Kind, name: &Operand) -> TokenStream {
         let name = name.tokens();
         match kind {
             Fold => quote! {
-                #ty(tokens_helper(_visitor, &(#name).0))
+                #ty(tokens_helper(_visitor, &#name.spans))
             },
             Visit => quote! {
-                tokens_helper(_visitor, &(#name).0)
+                tokens_helper(_visitor, &#name.spans)
             },
             VisitMut => quote! {
-                tokens_helper(_visitor, &mut (#name).0)
+                tokens_helper(_visitor, &mut #name.spans)
+            },
+        }
+    }
+
+    fn token_keyword_visit(ty: TokenStream, kind: Kind, name: &Operand) -> TokenStream {
+        let name = name.tokens();
+        match kind {
+            Fold => quote! {
+                #ty(tokens_helper(_visitor, &#name.span))
+            },
+            Visit => quote! {
+                tokens_helper(_visitor, &#name.span)
+            },
+            VisitMut => quote! {
+                tokens_helper(_visitor, &mut #name.span)
+            },
+        }
+    }
+
+    fn token_group_visit(ty: Ident, kind: Kind, name: &Operand) -> TokenStream {
+        let name = name.tokens();
+        match kind {
+            Fold => quote! {
+                #ty(tokens_helper(_visitor, &#name.span))
+            },
+            Visit => quote! {
+                tokens_helper(_visitor, &#name.span)
+            },
+            VisitMut => quote! {
+                tokens_helper(_visitor, &mut #name.span)
             },
         }
     }
@@ -686,7 +726,9 @@
                     res
                 })
             }
-            RelevantType::Token(ty) => Some(token_visit(ty, kind, name)),
+            RelevantType::TokenPunct(ty) => Some(token_punct_visit(ty, kind, name)),
+            RelevantType::TokenKeyword(ty) => Some(token_keyword_visit(ty, kind, name)),
+            RelevantType::TokenGroup(ty) => Some(token_group_visit(ty, kind, name)),
             RelevantType::Pass => None,
         }
     }
diff --git a/src/attr.rs b/src/attr.rs
index d818b4f..6512412 100644
--- a/src/attr.rs
+++ b/src/attr.rs
@@ -435,14 +435,14 @@
                 |lit| {
                     let span = lit.span();
                     Attribute {
-                        style: AttrStyle::Inner(<Token![!]>::new(span)),
+                        style: AttrStyle::Inner(Token![!](span)),
                         path: Ident::new("doc", span).into(),
                         tts: vec![
                             eq(span),
                             lit,
                         ].into_iter().collect(),
                         is_sugared_doc: true,
-                        pound_token: <Token![#]>::new(span),
+                        pound_token: Token![#](span),
                         bracket_token: token::Bracket(span),
                     }
                 }
@@ -482,7 +482,7 @@
                             lit,
                         ].into_iter().collect(),
                         is_sugared_doc: true,
-                        pound_token: <Token![#]>::new(span),
+                        pound_token: Token![#](span),
                         bracket_token: token::Bracket(span),
                     }
                 }
diff --git a/src/expr.rs b/src/expr.rs
index 8f60c29..3de219c 100644
--- a/src/expr.rs
+++ b/src/expr.rs
@@ -2503,7 +2503,7 @@
             punct!(..=) => { RangeLimits::Closed }
             |
             // Must come before Dot2
-            punct!(...) => { |dot3| RangeLimits::Closed(Token![..=](dot3.0)) }
+            punct!(...) => { |dot3| RangeLimits::Closed(Token![..=](dot3.spans)) }
             |
             punct!(..) => { RangeLimits::HalfOpen }
         ));
@@ -3092,9 +3092,9 @@
                 let after: Option<Punctuated<Pat, Token![,]>> = after;
                 let middle: Option<(Token![..], Option<Token![,]>)> = middle;
                 PatSlice {
-                    dot2_token: middle.as_ref().map(|m| Token![..]((m.0).0)),
+                    dot2_token: middle.as_ref().map(|m| Token![..](m.0.spans)),
                     comma_token: middle.as_ref().and_then(|m| {
-                        m.1.as_ref().map(|m| Token![,](m.0))
+                        m.1.as_ref().map(|m| Token![,](m.spans))
                     }),
                     bracket_token: brackets,
                     middle: middle.and_then(|_| {
@@ -3810,7 +3810,7 @@
             self.lo.to_tokens(tokens);
             match self.limits {
                 RangeLimits::HalfOpen(ref t) => t.to_tokens(tokens),
-                RangeLimits::Closed(ref t) => Token![...](t.0).to_tokens(tokens),
+                RangeLimits::Closed(ref t) => Token![...](t.spans).to_tokens(tokens),
             }
             self.hi.to_tokens(tokens);
         }
diff --git a/src/gen/fold.rs b/src/gen/fold.rs
index 54eb51a..aac8f99 100644
--- a/src/gen/fold.rs
+++ b/src/gen/fold.rs
@@ -880,7 +880,7 @@
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn fold_abi<V: Fold + ?Sized>(_visitor: &mut V, _i: Abi) -> Abi {
     Abi {
-        extern_token: Token![extern](tokens_helper(_visitor, &(_i.extern_token).0)),
+        extern_token: Token![extern](tokens_helper(_visitor, &_i.extern_token.span)),
         name: (_i.name).map(|it| _visitor.fold_lit_str(it)),
     }
 }
@@ -890,34 +890,35 @@
     _i: AngleBracketedGenericArguments,
 ) -> AngleBracketedGenericArguments {
     AngleBracketedGenericArguments {
-        colon2_token: (_i.colon2_token).map(|it| Token ! [ :: ](tokens_helper(_visitor, &(it).0))),
-        lt_token: Token ! [ < ](tokens_helper(_visitor, &(_i.lt_token).0)),
+        colon2_token: (_i.colon2_token)
+            .map(|it| Token ! [ :: ](tokens_helper(_visitor, &it.spans))),
+        lt_token: Token ! [ < ](tokens_helper(_visitor, &_i.lt_token.spans)),
         args: FoldHelper::lift(_i.args, |it| _visitor.fold_generic_argument(it)),
-        gt_token: Token ! [ > ](tokens_helper(_visitor, &(_i.gt_token).0)),
+        gt_token: Token ! [ > ](tokens_helper(_visitor, &_i.gt_token.spans)),
     }
 }
 #[cfg(feature = "full")]
 pub fn fold_arg_captured<V: Fold + ?Sized>(_visitor: &mut V, _i: ArgCaptured) -> ArgCaptured {
     ArgCaptured {
         pat: _visitor.fold_pat(_i.pat),
-        colon_token: Token ! [ : ](tokens_helper(_visitor, &(_i.colon_token).0)),
+        colon_token: Token ! [ : ](tokens_helper(_visitor, &_i.colon_token.spans)),
         ty: _visitor.fold_type(_i.ty),
     }
 }
 #[cfg(feature = "full")]
 pub fn fold_arg_self<V: Fold + ?Sized>(_visitor: &mut V, _i: ArgSelf) -> ArgSelf {
     ArgSelf {
-        mutability: (_i.mutability).map(|it| Token ! [ mut ](tokens_helper(_visitor, &(it).0))),
-        self_token: Token![self](tokens_helper(_visitor, &(_i.self_token).0)),
+        mutability: (_i.mutability).map(|it| Token ! [ mut ](tokens_helper(_visitor, &it.span))),
+        self_token: Token![self](tokens_helper(_visitor, &_i.self_token.span)),
     }
 }
 #[cfg(feature = "full")]
 pub fn fold_arg_self_ref<V: Fold + ?Sized>(_visitor: &mut V, _i: ArgSelfRef) -> ArgSelfRef {
     ArgSelfRef {
-        and_token: Token ! [ & ](tokens_helper(_visitor, &(_i.and_token).0)),
+        and_token: Token ! [ & ](tokens_helper(_visitor, &_i.and_token.spans)),
         lifetime: (_i.lifetime).map(|it| _visitor.fold_lifetime(it)),
-        mutability: (_i.mutability).map(|it| Token ! [ mut ](tokens_helper(_visitor, &(it).0))),
-        self_token: Token![self](tokens_helper(_visitor, &(_i.self_token).0)),
+        mutability: (_i.mutability).map(|it| Token ! [ mut ](tokens_helper(_visitor, &it.span))),
+        self_token: Token![self](tokens_helper(_visitor, &_i.self_token.span)),
     }
 }
 #[cfg(any(feature = "full", feature = "derive"))]
@@ -925,17 +926,17 @@
 pub fn fold_arm<V: Fold + ?Sized>(_visitor: &mut V, _i: Arm) -> Arm {
     Arm {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
-        leading_vert: (_i.leading_vert).map(|it| Token ! [ | ](tokens_helper(_visitor, &(it).0))),
+        leading_vert: (_i.leading_vert).map(|it| Token ! [ | ](tokens_helper(_visitor, &it.spans))),
         pats: FoldHelper::lift(_i.pats, |it| _visitor.fold_pat(it)),
         guard: (_i.guard).map(|it| {
             (
-                Token ! [ if ](tokens_helper(_visitor, &((it).0).0)),
+                Token ! [ if ](tokens_helper(_visitor, &(it).0.span)),
                 Box::new(_visitor.fold_expr(*(it).1)),
             )
         }),
-        fat_arrow_token: Token ! [ => ](tokens_helper(_visitor, &(_i.fat_arrow_token).0)),
+        fat_arrow_token: Token ! [ => ](tokens_helper(_visitor, &_i.fat_arrow_token.spans)),
         body: Box::new(_visitor.fold_expr(*_i.body)),
-        comma: (_i.comma).map(|it| Token ! [ , ](tokens_helper(_visitor, &(it).0))),
+        comma: (_i.comma).map(|it| Token ! [ , ](tokens_helper(_visitor, &it.spans))),
     }
 }
 #[cfg(any(feature = "full", feature = "derive"))]
@@ -943,16 +944,16 @@
     match _i {
         AttrStyle::Outer => AttrStyle::Outer,
         AttrStyle::Inner(_binding_0) => {
-            AttrStyle::Inner(Token![!](tokens_helper(_visitor, &(_binding_0).0)))
+            AttrStyle::Inner(Token![!](tokens_helper(_visitor, &_binding_0.spans)))
         }
     }
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn fold_attribute<V: Fold + ?Sized>(_visitor: &mut V, _i: Attribute) -> Attribute {
     Attribute {
-        pound_token: Token ! [ # ](tokens_helper(_visitor, &(_i.pound_token).0)),
+        pound_token: Token ! [ # ](tokens_helper(_visitor, &_i.pound_token.spans)),
         style: _visitor.fold_attr_style(_i.style),
-        bracket_token: Bracket(tokens_helper(_visitor, &(_i.bracket_token).0)),
+        bracket_token: Bracket(tokens_helper(_visitor, &_i.bracket_token.span)),
         path: _visitor.fold_path(_i.path),
         tts: _i.tts,
         is_sugared_doc: _i.is_sugared_doc,
@@ -964,7 +965,7 @@
         name: (_i.name).map(|it| {
             (
                 _visitor.fold_bare_fn_arg_name((it).0),
-                Token ! [ : ](tokens_helper(_visitor, &((it).1).0)),
+                Token ! [ : ](tokens_helper(_visitor, &(it).1.spans)),
             )
         }),
         ty: _visitor.fold_type(_i.ty),
@@ -978,7 +979,7 @@
     match _i {
         BareFnArgName::Named(_binding_0) => BareFnArgName::Named(_visitor.fold_ident(_binding_0)),
         BareFnArgName::Wild(_binding_0) => {
-            BareFnArgName::Wild(Token![_](tokens_helper(_visitor, &(_binding_0).0)))
+            BareFnArgName::Wild(Token![_](tokens_helper(_visitor, &_binding_0.spans)))
         }
     }
 }
@@ -986,84 +987,88 @@
 pub fn fold_bin_op<V: Fold + ?Sized>(_visitor: &mut V, _i: BinOp) -> BinOp {
     match _i {
         BinOp::Add(_binding_0) => {
-            BinOp::Add(Token ! [ + ](tokens_helper(_visitor, &(_binding_0).0)))
+            BinOp::Add(Token ! [ + ](tokens_helper(_visitor, &_binding_0.spans)))
         }
         BinOp::Sub(_binding_0) => {
-            BinOp::Sub(Token ! [ - ](tokens_helper(_visitor, &(_binding_0).0)))
+            BinOp::Sub(Token ! [ - ](tokens_helper(_visitor, &_binding_0.spans)))
         }
         BinOp::Mul(_binding_0) => {
-            BinOp::Mul(Token ! [ * ](tokens_helper(_visitor, &(_binding_0).0)))
+            BinOp::Mul(Token ! [ * ](tokens_helper(_visitor, &_binding_0.spans)))
         }
         BinOp::Div(_binding_0) => {
-            BinOp::Div(Token ! [ / ](tokens_helper(_visitor, &(_binding_0).0)))
+            BinOp::Div(Token ! [ / ](tokens_helper(_visitor, &_binding_0.spans)))
         }
         BinOp::Rem(_binding_0) => {
-            BinOp::Rem(Token ! [ % ](tokens_helper(_visitor, &(_binding_0).0)))
+            BinOp::Rem(Token ! [ % ](tokens_helper(_visitor, &_binding_0.spans)))
         }
         BinOp::And(_binding_0) => {
-            BinOp::And(Token ! [ && ](tokens_helper(_visitor, &(_binding_0).0)))
+            BinOp::And(Token ! [ && ](tokens_helper(_visitor, &_binding_0.spans)))
         }
         BinOp::Or(_binding_0) => {
-            BinOp::Or(Token ! [ || ](tokens_helper(_visitor, &(_binding_0).0)))
+            BinOp::Or(Token ! [ || ](tokens_helper(_visitor, &_binding_0.spans)))
         }
         BinOp::BitXor(_binding_0) => {
-            BinOp::BitXor(Token ! [ ^ ](tokens_helper(_visitor, &(_binding_0).0)))
+            BinOp::BitXor(Token ! [ ^ ](tokens_helper(_visitor, &_binding_0.spans)))
         }
         BinOp::BitAnd(_binding_0) => {
-            BinOp::BitAnd(Token ! [ & ](tokens_helper(_visitor, &(_binding_0).0)))
+            BinOp::BitAnd(Token ! [ & ](tokens_helper(_visitor, &_binding_0.spans)))
         }
         BinOp::BitOr(_binding_0) => {
-            BinOp::BitOr(Token ! [ | ](tokens_helper(_visitor, &(_binding_0).0)))
+            BinOp::BitOr(Token ! [ | ](tokens_helper(_visitor, &_binding_0.spans)))
         }
         BinOp::Shl(_binding_0) => {
-            BinOp::Shl(Token ! [ << ](tokens_helper(_visitor, &(_binding_0).0)))
+            BinOp::Shl(Token ! [ << ](tokens_helper(_visitor, &_binding_0.spans)))
         }
         BinOp::Shr(_binding_0) => {
-            BinOp::Shr(Token ! [ >> ](tokens_helper(_visitor, &(_binding_0).0)))
+            BinOp::Shr(Token ! [ >> ](tokens_helper(_visitor, &_binding_0.spans)))
         }
         BinOp::Eq(_binding_0) => {
-            BinOp::Eq(Token ! [ == ](tokens_helper(_visitor, &(_binding_0).0)))
+            BinOp::Eq(Token ! [ == ](tokens_helper(_visitor, &_binding_0.spans)))
         }
-        BinOp::Lt(_binding_0) => BinOp::Lt(Token ! [ < ](tokens_helper(_visitor, &(_binding_0).0))),
+        BinOp::Lt(_binding_0) => {
+            BinOp::Lt(Token ! [ < ](tokens_helper(_visitor, &_binding_0.spans)))
+        }
         BinOp::Le(_binding_0) => {
-            BinOp::Le(Token ! [ <= ](tokens_helper(_visitor, &(_binding_0).0)))
+            BinOp::Le(Token ! [ <= ](tokens_helper(_visitor, &_binding_0.spans)))
         }
         BinOp::Ne(_binding_0) => {
-            BinOp::Ne(Token ! [ != ](tokens_helper(_visitor, &(_binding_0).0)))
+            BinOp::Ne(Token ! [ != ](tokens_helper(_visitor, &_binding_0.spans)))
         }
         BinOp::Ge(_binding_0) => {
-            BinOp::Ge(Token ! [ >= ](tokens_helper(_visitor, &(_binding_0).0)))
+            BinOp::Ge(Token ! [ >= ](tokens_helper(_visitor, &_binding_0.spans)))
         }
-        BinOp::Gt(_binding_0) => BinOp::Gt(Token ! [ > ](tokens_helper(_visitor, &(_binding_0).0))),
+        BinOp::Gt(_binding_0) => {
+            BinOp::Gt(Token ! [ > ](tokens_helper(_visitor, &_binding_0.spans)))
+        }
         BinOp::AddEq(_binding_0) => {
-            BinOp::AddEq(Token ! [ += ](tokens_helper(_visitor, &(_binding_0).0)))
+            BinOp::AddEq(Token ! [ += ](tokens_helper(_visitor, &_binding_0.spans)))
         }
         BinOp::SubEq(_binding_0) => {
-            BinOp::SubEq(Token ! [ -= ](tokens_helper(_visitor, &(_binding_0).0)))
+            BinOp::SubEq(Token ! [ -= ](tokens_helper(_visitor, &_binding_0.spans)))
         }
         BinOp::MulEq(_binding_0) => {
-            BinOp::MulEq(Token ! [ *= ](tokens_helper(_visitor, &(_binding_0).0)))
+            BinOp::MulEq(Token ! [ *= ](tokens_helper(_visitor, &_binding_0.spans)))
         }
         BinOp::DivEq(_binding_0) => {
-            BinOp::DivEq(Token ! [ /= ](tokens_helper(_visitor, &(_binding_0).0)))
+            BinOp::DivEq(Token ! [ /= ](tokens_helper(_visitor, &_binding_0.spans)))
         }
         BinOp::RemEq(_binding_0) => {
-            BinOp::RemEq(Token ! [ %= ](tokens_helper(_visitor, &(_binding_0).0)))
+            BinOp::RemEq(Token ! [ %= ](tokens_helper(_visitor, &_binding_0.spans)))
         }
         BinOp::BitXorEq(_binding_0) => {
-            BinOp::BitXorEq(Token ! [ ^= ](tokens_helper(_visitor, &(_binding_0).0)))
+            BinOp::BitXorEq(Token ! [ ^= ](tokens_helper(_visitor, &_binding_0.spans)))
         }
         BinOp::BitAndEq(_binding_0) => {
-            BinOp::BitAndEq(Token ! [ &= ](tokens_helper(_visitor, &(_binding_0).0)))
+            BinOp::BitAndEq(Token ! [ &= ](tokens_helper(_visitor, &_binding_0.spans)))
         }
         BinOp::BitOrEq(_binding_0) => {
-            BinOp::BitOrEq(Token ! [ |= ](tokens_helper(_visitor, &(_binding_0).0)))
+            BinOp::BitOrEq(Token ! [ |= ](tokens_helper(_visitor, &_binding_0.spans)))
         }
         BinOp::ShlEq(_binding_0) => {
-            BinOp::ShlEq(Token ! [ <<= ](tokens_helper(_visitor, &(_binding_0).0)))
+            BinOp::ShlEq(Token ! [ <<= ](tokens_helper(_visitor, &_binding_0.spans)))
         }
         BinOp::ShrEq(_binding_0) => {
-            BinOp::ShrEq(Token ! [ >>= ](tokens_helper(_visitor, &(_binding_0).0)))
+            BinOp::ShrEq(Token ! [ >>= ](tokens_helper(_visitor, &_binding_0.spans)))
         }
     }
 }
@@ -1071,7 +1076,7 @@
 pub fn fold_binding<V: Fold + ?Sized>(_visitor: &mut V, _i: Binding) -> Binding {
     Binding {
         ident: _visitor.fold_ident(_i.ident),
-        eq_token: Token ! [ = ](tokens_helper(_visitor, &(_i.eq_token).0)),
+        eq_token: Token ! [ = ](tokens_helper(_visitor, &_i.eq_token.spans)),
         ty: _visitor.fold_type(_i.ty),
     }
 }
@@ -1079,7 +1084,7 @@
 #[cfg(feature = "full")]
 pub fn fold_block<V: Fold + ?Sized>(_visitor: &mut V, _i: Block) -> Block {
     Block {
-        brace_token: Brace(tokens_helper(_visitor, &(_i.brace_token).0)),
+        brace_token: Brace(tokens_helper(_visitor, &_i.brace_token.span)),
         stmts: FoldHelper::lift(_i.stmts, |it| _visitor.fold_stmt(it)),
     }
 }
@@ -1089,21 +1094,21 @@
     _i: BoundLifetimes,
 ) -> BoundLifetimes {
     BoundLifetimes {
-        for_token: Token ! [ for ](tokens_helper(_visitor, &(_i.for_token).0)),
-        lt_token: Token ! [ < ](tokens_helper(_visitor, &(_i.lt_token).0)),
+        for_token: Token ! [ for ](tokens_helper(_visitor, &_i.for_token.span)),
+        lt_token: Token ! [ < ](tokens_helper(_visitor, &_i.lt_token.spans)),
         lifetimes: FoldHelper::lift(_i.lifetimes, |it| _visitor.fold_lifetime_def(it)),
-        gt_token: Token ! [ > ](tokens_helper(_visitor, &(_i.gt_token).0)),
+        gt_token: Token ! [ > ](tokens_helper(_visitor, &_i.gt_token.spans)),
     }
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn fold_const_param<V: Fold + ?Sized>(_visitor: &mut V, _i: ConstParam) -> ConstParam {
     ConstParam {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
-        const_token: Token ! [ const ](tokens_helper(_visitor, &(_i.const_token).0)),
+        const_token: Token ! [ const ](tokens_helper(_visitor, &_i.const_token.span)),
         ident: _visitor.fold_ident(_i.ident),
-        colon_token: Token ! [ : ](tokens_helper(_visitor, &(_i.colon_token).0)),
+        colon_token: Token ! [ : ](tokens_helper(_visitor, &_i.colon_token.spans)),
         ty: _visitor.fold_type(_i.ty),
-        eq_token: (_i.eq_token).map(|it| Token ! [ = ](tokens_helper(_visitor, &(it).0))),
+        eq_token: (_i.eq_token).map(|it| Token ! [ = ](tokens_helper(_visitor, &it.spans))),
         default: (_i.default).map(|it| _visitor.fold_expr(it)),
     }
 }
@@ -1118,23 +1123,23 @@
 #[cfg(feature = "derive")]
 pub fn fold_data_enum<V: Fold + ?Sized>(_visitor: &mut V, _i: DataEnum) -> DataEnum {
     DataEnum {
-        enum_token: Token ! [ enum ](tokens_helper(_visitor, &(_i.enum_token).0)),
-        brace_token: Brace(tokens_helper(_visitor, &(_i.brace_token).0)),
+        enum_token: Token ! [ enum ](tokens_helper(_visitor, &_i.enum_token.span)),
+        brace_token: Brace(tokens_helper(_visitor, &_i.brace_token.span)),
         variants: FoldHelper::lift(_i.variants, |it| _visitor.fold_variant(it)),
     }
 }
 #[cfg(feature = "derive")]
 pub fn fold_data_struct<V: Fold + ?Sized>(_visitor: &mut V, _i: DataStruct) -> DataStruct {
     DataStruct {
-        struct_token: Token ! [ struct ](tokens_helper(_visitor, &(_i.struct_token).0)),
+        struct_token: Token ! [ struct ](tokens_helper(_visitor, &_i.struct_token.span)),
         fields: _visitor.fold_fields(_i.fields),
-        semi_token: (_i.semi_token).map(|it| Token ! [ ; ](tokens_helper(_visitor, &(it).0))),
+        semi_token: (_i.semi_token).map(|it| Token ! [ ; ](tokens_helper(_visitor, &it.spans))),
     }
 }
 #[cfg(feature = "derive")]
 pub fn fold_data_union<V: Fold + ?Sized>(_visitor: &mut V, _i: DataUnion) -> DataUnion {
     DataUnion {
-        union_token: Token![union](tokens_helper(_visitor, &(_i.union_token).0)),
+        union_token: Token![union](tokens_helper(_visitor, &_i.union_token.span)),
         fields: _visitor.fold_fields_named(_i.fields),
     }
 }
@@ -1208,7 +1213,7 @@
 pub fn fold_expr_array<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprArray) -> ExprArray {
     ExprArray {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
-        bracket_token: Bracket(tokens_helper(_visitor, &(_i.bracket_token).0)),
+        bracket_token: Bracket(tokens_helper(_visitor, &_i.bracket_token.span)),
         elems: FoldHelper::lift(_i.elems, |it| _visitor.fold_expr(it)),
     }
 }
@@ -1218,7 +1223,7 @@
     ExprAssign {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
         left: Box::new(_visitor.fold_expr(*_i.left)),
-        eq_token: Token ! [ = ](tokens_helper(_visitor, &(_i.eq_token).0)),
+        eq_token: Token ! [ = ](tokens_helper(_visitor, &_i.eq_token.spans)),
         right: Box::new(_visitor.fold_expr(*_i.right)),
     }
 }
@@ -1254,7 +1259,7 @@
 pub fn fold_expr_box<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprBox) -> ExprBox {
     ExprBox {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
-        box_token: Token ! [ box ](tokens_helper(_visitor, &(_i.box_token).0)),
+        box_token: Token ! [ box ](tokens_helper(_visitor, &_i.box_token.span)),
         expr: Box::new(_visitor.fold_expr(*_i.expr)),
     }
 }
@@ -1263,7 +1268,7 @@
 pub fn fold_expr_break<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprBreak) -> ExprBreak {
     ExprBreak {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
-        break_token: Token![break](tokens_helper(_visitor, &(_i.break_token).0)),
+        break_token: Token![break](tokens_helper(_visitor, &_i.break_token.span)),
         label: (_i.label).map(|it| _visitor.fold_lifetime(it)),
         expr: (_i.expr).map(|it| Box::new(_visitor.fold_expr(*it))),
     }
@@ -1273,7 +1278,7 @@
     ExprCall {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
         func: Box::new(_visitor.fold_expr(*_i.func)),
-        paren_token: Paren(tokens_helper(_visitor, &(_i.paren_token).0)),
+        paren_token: Paren(tokens_helper(_visitor, &_i.paren_token.span)),
         args: FoldHelper::lift(_i.args, |it| _visitor.fold_expr(it)),
     }
 }
@@ -1282,7 +1287,7 @@
     ExprCast {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
         expr: Box::new(_visitor.fold_expr(*_i.expr)),
-        as_token: Token ! [ as ](tokens_helper(_visitor, &(_i.as_token).0)),
+        as_token: Token ! [ as ](tokens_helper(_visitor, &_i.as_token.span)),
         ty: Box::new(_visitor.fold_type(*_i.ty)),
     }
 }
@@ -1291,8 +1296,8 @@
 pub fn fold_expr_catch<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprCatch) -> ExprCatch {
     ExprCatch {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
-        do_token: Token ! [ do ](tokens_helper(_visitor, &(_i.do_token).0)),
-        catch_token: Token![catch](tokens_helper(_visitor, &(_i.catch_token).0)),
+        do_token: Token ! [ do ](tokens_helper(_visitor, &_i.do_token.span)),
+        catch_token: Token![catch](tokens_helper(_visitor, &_i.catch_token.span)),
         block: _visitor.fold_block(_i.block),
     }
 }
@@ -1301,11 +1306,11 @@
 pub fn fold_expr_closure<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprClosure) -> ExprClosure {
     ExprClosure {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
-        movability: (_i.movability).map(|it| Token ! [ static ](tokens_helper(_visitor, &(it).0))),
-        capture: (_i.capture).map(|it| Token ! [ move ](tokens_helper(_visitor, &(it).0))),
-        or1_token: Token ! [ | ](tokens_helper(_visitor, &(_i.or1_token).0)),
+        movability: (_i.movability).map(|it| Token ! [ static ](tokens_helper(_visitor, &it.span))),
+        capture: (_i.capture).map(|it| Token ! [ move ](tokens_helper(_visitor, &it.span))),
+        or1_token: Token ! [ | ](tokens_helper(_visitor, &_i.or1_token.spans)),
         inputs: FoldHelper::lift(_i.inputs, |it| _visitor.fold_fn_arg(it)),
-        or2_token: Token ! [ | ](tokens_helper(_visitor, &(_i.or2_token).0)),
+        or2_token: Token ! [ | ](tokens_helper(_visitor, &_i.or2_token.spans)),
         output: _visitor.fold_return_type(_i.output),
         body: Box::new(_visitor.fold_expr(*_i.body)),
     }
@@ -1315,7 +1320,7 @@
 pub fn fold_expr_continue<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprContinue) -> ExprContinue {
     ExprContinue {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
-        continue_token: Token![continue](tokens_helper(_visitor, &(_i.continue_token).0)),
+        continue_token: Token![continue](tokens_helper(_visitor, &_i.continue_token.span)),
         label: (_i.label).map(|it| _visitor.fold_lifetime(it)),
     }
 }
@@ -1324,7 +1329,7 @@
     ExprField {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
         base: Box::new(_visitor.fold_expr(*_i.base)),
-        dot_token: Token ! [ . ](tokens_helper(_visitor, &(_i.dot_token).0)),
+        dot_token: Token ! [ . ](tokens_helper(_visitor, &_i.dot_token.spans)),
         member: _visitor.fold_member(_i.member),
     }
 }
@@ -1334,9 +1339,9 @@
     ExprForLoop {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
         label: (_i.label).map(|it| _visitor.fold_label(it)),
-        for_token: Token ! [ for ](tokens_helper(_visitor, &(_i.for_token).0)),
+        for_token: Token ! [ for ](tokens_helper(_visitor, &_i.for_token.span)),
         pat: Box::new(_visitor.fold_pat(*_i.pat)),
-        in_token: Token ! [ in ](tokens_helper(_visitor, &(_i.in_token).0)),
+        in_token: Token ! [ in ](tokens_helper(_visitor, &_i.in_token.span)),
         expr: Box::new(_visitor.fold_expr(*_i.expr)),
         body: _visitor.fold_block(_i.body),
     }
@@ -1346,7 +1351,7 @@
 pub fn fold_expr_group<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprGroup) -> ExprGroup {
     ExprGroup {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
-        group_token: Group(tokens_helper(_visitor, &(_i.group_token).0)),
+        group_token: Group(tokens_helper(_visitor, &_i.group_token.span)),
         expr: Box::new(_visitor.fold_expr(*_i.expr)),
     }
 }
@@ -1355,12 +1360,12 @@
 pub fn fold_expr_if<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprIf) -> ExprIf {
     ExprIf {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
-        if_token: Token ! [ if ](tokens_helper(_visitor, &(_i.if_token).0)),
+        if_token: Token ! [ if ](tokens_helper(_visitor, &_i.if_token.span)),
         cond: Box::new(_visitor.fold_expr(*_i.cond)),
         then_branch: _visitor.fold_block(_i.then_branch),
         else_branch: (_i.else_branch).map(|it| {
             (
-                Token ! [ else ](tokens_helper(_visitor, &((it).0).0)),
+                Token ! [ else ](tokens_helper(_visitor, &(it).0.span)),
                 Box::new(_visitor.fold_expr(*(it).1)),
             )
         }),
@@ -1371,15 +1376,15 @@
 pub fn fold_expr_if_let<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprIfLet) -> ExprIfLet {
     ExprIfLet {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
-        if_token: Token ! [ if ](tokens_helper(_visitor, &(_i.if_token).0)),
-        let_token: Token ! [ let ](tokens_helper(_visitor, &(_i.let_token).0)),
+        if_token: Token ! [ if ](tokens_helper(_visitor, &_i.if_token.span)),
+        let_token: Token ! [ let ](tokens_helper(_visitor, &_i.let_token.span)),
         pats: FoldHelper::lift(_i.pats, |it| _visitor.fold_pat(it)),
-        eq_token: Token ! [ = ](tokens_helper(_visitor, &(_i.eq_token).0)),
+        eq_token: Token ! [ = ](tokens_helper(_visitor, &_i.eq_token.spans)),
         expr: Box::new(_visitor.fold_expr(*_i.expr)),
         then_branch: _visitor.fold_block(_i.then_branch),
         else_branch: (_i.else_branch).map(|it| {
             (
-                Token ! [ else ](tokens_helper(_visitor, &((it).0).0)),
+                Token ! [ else ](tokens_helper(_visitor, &(it).0.span)),
                 Box::new(_visitor.fold_expr(*(it).1)),
             )
         }),
@@ -1391,7 +1396,7 @@
     ExprInPlace {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
         place: Box::new(_visitor.fold_expr(*_i.place)),
-        arrow_token: Token ! [ <- ](tokens_helper(_visitor, &(_i.arrow_token).0)),
+        arrow_token: Token ! [ <- ](tokens_helper(_visitor, &_i.arrow_token.spans)),
         value: Box::new(_visitor.fold_expr(*_i.value)),
     }
 }
@@ -1400,7 +1405,7 @@
     ExprIndex {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
         expr: Box::new(_visitor.fold_expr(*_i.expr)),
-        bracket_token: Bracket(tokens_helper(_visitor, &(_i.bracket_token).0)),
+        bracket_token: Bracket(tokens_helper(_visitor, &_i.bracket_token.span)),
         index: Box::new(_visitor.fold_expr(*_i.index)),
     }
 }
@@ -1417,7 +1422,7 @@
     ExprLoop {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
         label: (_i.label).map(|it| _visitor.fold_label(it)),
-        loop_token: Token ! [ loop ](tokens_helper(_visitor, &(_i.loop_token).0)),
+        loop_token: Token ! [ loop ](tokens_helper(_visitor, &_i.loop_token.span)),
         body: _visitor.fold_block(_i.body),
     }
 }
@@ -1434,9 +1439,9 @@
 pub fn fold_expr_match<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprMatch) -> ExprMatch {
     ExprMatch {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
-        match_token: Token ! [ match ](tokens_helper(_visitor, &(_i.match_token).0)),
+        match_token: Token ! [ match ](tokens_helper(_visitor, &_i.match_token.span)),
         expr: Box::new(_visitor.fold_expr(*_i.expr)),
-        brace_token: Brace(tokens_helper(_visitor, &(_i.brace_token).0)),
+        brace_token: Brace(tokens_helper(_visitor, &_i.brace_token.span)),
         arms: FoldHelper::lift(_i.arms, |it| _visitor.fold_arm(it)),
     }
 }
@@ -1449,10 +1454,10 @@
     ExprMethodCall {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
         receiver: Box::new(_visitor.fold_expr(*_i.receiver)),
-        dot_token: Token ! [ . ](tokens_helper(_visitor, &(_i.dot_token).0)),
+        dot_token: Token ! [ . ](tokens_helper(_visitor, &_i.dot_token.spans)),
         method: _visitor.fold_ident(_i.method),
         turbofish: (_i.turbofish).map(|it| _visitor.fold_method_turbofish(it)),
-        paren_token: Paren(tokens_helper(_visitor, &(_i.paren_token).0)),
+        paren_token: Paren(tokens_helper(_visitor, &_i.paren_token.span)),
         args: FoldHelper::lift(_i.args, |it| _visitor.fold_expr(it)),
     }
 }
@@ -1460,7 +1465,7 @@
 pub fn fold_expr_paren<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprParen) -> ExprParen {
     ExprParen {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
-        paren_token: Paren(tokens_helper(_visitor, &(_i.paren_token).0)),
+        paren_token: Paren(tokens_helper(_visitor, &_i.paren_token.span)),
         expr: Box::new(_visitor.fold_expr(*_i.expr)),
     }
 }
@@ -1487,8 +1492,8 @@
 pub fn fold_expr_reference<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprReference) -> ExprReference {
     ExprReference {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
-        and_token: Token ! [ & ](tokens_helper(_visitor, &(_i.and_token).0)),
-        mutability: (_i.mutability).map(|it| Token ! [ mut ](tokens_helper(_visitor, &(it).0))),
+        and_token: Token ! [ & ](tokens_helper(_visitor, &_i.and_token.spans)),
+        mutability: (_i.mutability).map(|it| Token ! [ mut ](tokens_helper(_visitor, &it.span))),
         expr: Box::new(_visitor.fold_expr(*_i.expr)),
     }
 }
@@ -1497,9 +1502,9 @@
 pub fn fold_expr_repeat<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprRepeat) -> ExprRepeat {
     ExprRepeat {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
-        bracket_token: Bracket(tokens_helper(_visitor, &(_i.bracket_token).0)),
+        bracket_token: Bracket(tokens_helper(_visitor, &_i.bracket_token.span)),
         expr: Box::new(_visitor.fold_expr(*_i.expr)),
-        semi_token: Token ! [ ; ](tokens_helper(_visitor, &(_i.semi_token).0)),
+        semi_token: Token ! [ ; ](tokens_helper(_visitor, &_i.semi_token.spans)),
         len: Box::new(_visitor.fold_expr(*_i.len)),
     }
 }
@@ -1508,7 +1513,7 @@
 pub fn fold_expr_return<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprReturn) -> ExprReturn {
     ExprReturn {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
-        return_token: Token![return](tokens_helper(_visitor, &(_i.return_token).0)),
+        return_token: Token![return](tokens_helper(_visitor, &_i.return_token.span)),
         expr: (_i.expr).map(|it| Box::new(_visitor.fold_expr(*it))),
     }
 }
@@ -1518,9 +1523,9 @@
     ExprStruct {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
         path: _visitor.fold_path(_i.path),
-        brace_token: Brace(tokens_helper(_visitor, &(_i.brace_token).0)),
+        brace_token: Brace(tokens_helper(_visitor, &_i.brace_token.span)),
         fields: FoldHelper::lift(_i.fields, |it| _visitor.fold_field_value(it)),
-        dot2_token: (_i.dot2_token).map(|it| Token![..](tokens_helper(_visitor, &(it).0))),
+        dot2_token: (_i.dot2_token).map(|it| Token![..](tokens_helper(_visitor, &it.spans))),
         rest: (_i.rest).map(|it| Box::new(_visitor.fold_expr(*it))),
     }
 }
@@ -1530,7 +1535,7 @@
     ExprTry {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
         expr: Box::new(_visitor.fold_expr(*_i.expr)),
-        question_token: Token ! [ ? ](tokens_helper(_visitor, &(_i.question_token).0)),
+        question_token: Token ! [ ? ](tokens_helper(_visitor, &_i.question_token.spans)),
     }
 }
 #[cfg(feature = "full")]
@@ -1538,7 +1543,7 @@
 pub fn fold_expr_tuple<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprTuple) -> ExprTuple {
     ExprTuple {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
-        paren_token: Paren(tokens_helper(_visitor, &(_i.paren_token).0)),
+        paren_token: Paren(tokens_helper(_visitor, &_i.paren_token.span)),
         elems: FoldHelper::lift(_i.elems, |it| _visitor.fold_expr(it)),
     }
 }
@@ -1548,7 +1553,7 @@
     ExprType {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
         expr: Box::new(_visitor.fold_expr(*_i.expr)),
-        colon_token: Token ! [ : ](tokens_helper(_visitor, &(_i.colon_token).0)),
+        colon_token: Token ! [ : ](tokens_helper(_visitor, &_i.colon_token.spans)),
         ty: Box::new(_visitor.fold_type(*_i.ty)),
     }
 }
@@ -1565,7 +1570,7 @@
 pub fn fold_expr_unsafe<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprUnsafe) -> ExprUnsafe {
     ExprUnsafe {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
-        unsafe_token: Token ! [ unsafe ](tokens_helper(_visitor, &(_i.unsafe_token).0)),
+        unsafe_token: Token ! [ unsafe ](tokens_helper(_visitor, &_i.unsafe_token.span)),
         block: _visitor.fold_block(_i.block),
     }
 }
@@ -1579,7 +1584,7 @@
     ExprWhile {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
         label: (_i.label).map(|it| _visitor.fold_label(it)),
-        while_token: Token ! [ while ](tokens_helper(_visitor, &(_i.while_token).0)),
+        while_token: Token ! [ while ](tokens_helper(_visitor, &_i.while_token.span)),
         cond: Box::new(_visitor.fold_expr(*_i.cond)),
         body: _visitor.fold_block(_i.body),
     }
@@ -1590,10 +1595,10 @@
     ExprWhileLet {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
         label: (_i.label).map(|it| _visitor.fold_label(it)),
-        while_token: Token ! [ while ](tokens_helper(_visitor, &(_i.while_token).0)),
-        let_token: Token ! [ let ](tokens_helper(_visitor, &(_i.let_token).0)),
+        while_token: Token ! [ while ](tokens_helper(_visitor, &_i.while_token.span)),
+        let_token: Token ! [ let ](tokens_helper(_visitor, &_i.let_token.span)),
         pats: FoldHelper::lift(_i.pats, |it| _visitor.fold_pat(it)),
-        eq_token: Token ! [ = ](tokens_helper(_visitor, &(_i.eq_token).0)),
+        eq_token: Token ! [ = ](tokens_helper(_visitor, &_i.eq_token.spans)),
         expr: Box::new(_visitor.fold_expr(*_i.expr)),
         body: _visitor.fold_block(_i.body),
     }
@@ -1603,7 +1608,7 @@
 pub fn fold_expr_yield<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprYield) -> ExprYield {
     ExprYield {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
-        yield_token: Token![yield](tokens_helper(_visitor, &(_i.yield_token).0)),
+        yield_token: Token![yield](tokens_helper(_visitor, &_i.yield_token.span)),
         expr: (_i.expr).map(|it| Box::new(_visitor.fold_expr(*it))),
     }
 }
@@ -1613,7 +1618,7 @@
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
         vis: _visitor.fold_visibility(_i.vis),
         ident: (_i.ident).map(|it| _visitor.fold_ident(it)),
-        colon_token: (_i.colon_token).map(|it| Token ! [ : ](tokens_helper(_visitor, &(it).0))),
+        colon_token: (_i.colon_token).map(|it| Token ! [ : ](tokens_helper(_visitor, &it.spans))),
         ty: _visitor.fold_type(_i.ty),
     }
 }
@@ -1623,7 +1628,7 @@
     FieldPat {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
         member: _visitor.fold_member(_i.member),
-        colon_token: (_i.colon_token).map(|it| Token ! [ : ](tokens_helper(_visitor, &(it).0))),
+        colon_token: (_i.colon_token).map(|it| Token ! [ : ](tokens_helper(_visitor, &it.spans))),
         pat: Box::new(_visitor.fold_pat(*_i.pat)),
     }
 }
@@ -1633,7 +1638,7 @@
     FieldValue {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
         member: _visitor.fold_member(_i.member),
-        colon_token: (_i.colon_token).map(|it| Token ! [ : ](tokens_helper(_visitor, &(it).0))),
+        colon_token: (_i.colon_token).map(|it| Token ! [ : ](tokens_helper(_visitor, &it.spans))),
         expr: _visitor.fold_expr(_i.expr),
     }
 }
@@ -1648,14 +1653,14 @@
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn fold_fields_named<V: Fold + ?Sized>(_visitor: &mut V, _i: FieldsNamed) -> FieldsNamed {
     FieldsNamed {
-        brace_token: Brace(tokens_helper(_visitor, &(_i.brace_token).0)),
+        brace_token: Brace(tokens_helper(_visitor, &_i.brace_token.span)),
         named: FoldHelper::lift(_i.named, |it| _visitor.fold_field(it)),
     }
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn fold_fields_unnamed<V: Fold + ?Sized>(_visitor: &mut V, _i: FieldsUnnamed) -> FieldsUnnamed {
     FieldsUnnamed {
-        paren_token: Paren(tokens_helper(_visitor, &(_i.paren_token).0)),
+        paren_token: Paren(tokens_helper(_visitor, &_i.paren_token.span)),
         unnamed: FoldHelper::lift(_i.unnamed, |it| _visitor.fold_field(it)),
     }
 }
@@ -1680,11 +1685,11 @@
 #[cfg(feature = "full")]
 pub fn fold_fn_decl<V: Fold + ?Sized>(_visitor: &mut V, _i: FnDecl) -> FnDecl {
     FnDecl {
-        fn_token: Token ! [ fn ](tokens_helper(_visitor, &(_i.fn_token).0)),
+        fn_token: Token ! [ fn ](tokens_helper(_visitor, &_i.fn_token.span)),
         generics: _visitor.fold_generics(_i.generics),
-        paren_token: Paren(tokens_helper(_visitor, &(_i.paren_token).0)),
+        paren_token: Paren(tokens_helper(_visitor, &_i.paren_token.span)),
         inputs: FoldHelper::lift(_i.inputs, |it| _visitor.fold_fn_arg(it)),
-        variadic: (_i.variadic).map(|it| Token ! [ ... ](tokens_helper(_visitor, &(it).0))),
+        variadic: (_i.variadic).map(|it| Token ! [ ... ](tokens_helper(_visitor, &it.spans))),
         output: _visitor.fold_return_type(_i.output),
     }
 }
@@ -1713,7 +1718,7 @@
         vis: _visitor.fold_visibility(_i.vis),
         ident: _visitor.fold_ident(_i.ident),
         decl: Box::new(_visitor.fold_fn_decl(*_i.decl)),
-        semi_token: Token ! [ ; ](tokens_helper(_visitor, &(_i.semi_token).0)),
+        semi_token: Token ! [ ; ](tokens_helper(_visitor, &_i.semi_token.spans)),
     }
 }
 #[cfg(feature = "full")]
@@ -1724,12 +1729,12 @@
     ForeignItemStatic {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
         vis: _visitor.fold_visibility(_i.vis),
-        static_token: Token ! [ static ](tokens_helper(_visitor, &(_i.static_token).0)),
-        mutability: (_i.mutability).map(|it| Token ! [ mut ](tokens_helper(_visitor, &(it).0))),
+        static_token: Token ! [ static ](tokens_helper(_visitor, &_i.static_token.span)),
+        mutability: (_i.mutability).map(|it| Token ! [ mut ](tokens_helper(_visitor, &it.span))),
         ident: _visitor.fold_ident(_i.ident),
-        colon_token: Token ! [ : ](tokens_helper(_visitor, &(_i.colon_token).0)),
+        colon_token: Token ! [ : ](tokens_helper(_visitor, &_i.colon_token.spans)),
         ty: Box::new(_visitor.fold_type(*_i.ty)),
-        semi_token: Token ! [ ; ](tokens_helper(_visitor, &(_i.semi_token).0)),
+        semi_token: Token ! [ ; ](tokens_helper(_visitor, &_i.semi_token.spans)),
     }
 }
 #[cfg(feature = "full")]
@@ -1740,9 +1745,9 @@
     ForeignItemType {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
         vis: _visitor.fold_visibility(_i.vis),
-        type_token: Token ! [ type ](tokens_helper(_visitor, &(_i.type_token).0)),
+        type_token: Token ! [ type ](tokens_helper(_visitor, &_i.type_token.span)),
         ident: _visitor.fold_ident(_i.ident),
-        semi_token: Token ! [ ; ](tokens_helper(_visitor, &(_i.semi_token).0)),
+        semi_token: Token ! [ ; ](tokens_helper(_visitor, &_i.semi_token.spans)),
     }
 }
 #[cfg(feature = "full")]
@@ -1800,9 +1805,9 @@
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn fold_generics<V: Fold + ?Sized>(_visitor: &mut V, _i: Generics) -> Generics {
     Generics {
-        lt_token: (_i.lt_token).map(|it| Token ! [ < ](tokens_helper(_visitor, &(it).0))),
+        lt_token: (_i.lt_token).map(|it| Token ! [ < ](tokens_helper(_visitor, &it.spans))),
         params: FoldHelper::lift(_i.params, |it| _visitor.fold_generic_param(it)),
-        gt_token: (_i.gt_token).map(|it| Token ! [ > ](tokens_helper(_visitor, &(it).0))),
+        gt_token: (_i.gt_token).map(|it| Token ! [ > ](tokens_helper(_visitor, &it.spans))),
         where_clause: (_i.where_clause).map(|it| _visitor.fold_where_clause(it)),
     }
 }
@@ -1834,14 +1839,14 @@
     ImplItemConst {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
         vis: _visitor.fold_visibility(_i.vis),
-        defaultness: (_i.defaultness).map(|it| Token![default](tokens_helper(_visitor, &(it).0))),
-        const_token: Token ! [ const ](tokens_helper(_visitor, &(_i.const_token).0)),
+        defaultness: (_i.defaultness).map(|it| Token![default](tokens_helper(_visitor, &it.span))),
+        const_token: Token ! [ const ](tokens_helper(_visitor, &_i.const_token.span)),
         ident: _visitor.fold_ident(_i.ident),
-        colon_token: Token ! [ : ](tokens_helper(_visitor, &(_i.colon_token).0)),
+        colon_token: Token ! [ : ](tokens_helper(_visitor, &_i.colon_token.spans)),
         ty: _visitor.fold_type(_i.ty),
-        eq_token: Token ! [ = ](tokens_helper(_visitor, &(_i.eq_token).0)),
+        eq_token: Token ! [ = ](tokens_helper(_visitor, &_i.eq_token.spans)),
         expr: _visitor.fold_expr(_i.expr),
-        semi_token: Token ! [ ; ](tokens_helper(_visitor, &(_i.semi_token).0)),
+        semi_token: Token ! [ ; ](tokens_helper(_visitor, &_i.semi_token.spans)),
     }
 }
 #[cfg(feature = "full")]
@@ -1852,7 +1857,7 @@
     ImplItemMacro {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
         mac: _visitor.fold_macro(_i.mac),
-        semi_token: (_i.semi_token).map(|it| Token ! [ ; ](tokens_helper(_visitor, &(it).0))),
+        semi_token: (_i.semi_token).map(|it| Token ! [ ; ](tokens_helper(_visitor, &it.spans))),
     }
 }
 #[cfg(feature = "full")]
@@ -1863,7 +1868,7 @@
     ImplItemMethod {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
         vis: _visitor.fold_visibility(_i.vis),
-        defaultness: (_i.defaultness).map(|it| Token![default](tokens_helper(_visitor, &(it).0))),
+        defaultness: (_i.defaultness).map(|it| Token![default](tokens_helper(_visitor, &it.span))),
         sig: _visitor.fold_method_sig(_i.sig),
         block: _visitor.fold_block(_i.block),
     }
@@ -1873,13 +1878,13 @@
     ImplItemType {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
         vis: _visitor.fold_visibility(_i.vis),
-        defaultness: (_i.defaultness).map(|it| Token![default](tokens_helper(_visitor, &(it).0))),
-        type_token: Token ! [ type ](tokens_helper(_visitor, &(_i.type_token).0)),
+        defaultness: (_i.defaultness).map(|it| Token![default](tokens_helper(_visitor, &it.span))),
+        type_token: Token ! [ type ](tokens_helper(_visitor, &_i.type_token.span)),
         ident: _visitor.fold_ident(_i.ident),
         generics: _visitor.fold_generics(_i.generics),
-        eq_token: Token ! [ = ](tokens_helper(_visitor, &(_i.eq_token).0)),
+        eq_token: Token ! [ = ](tokens_helper(_visitor, &_i.eq_token.spans)),
         ty: _visitor.fold_type(_i.ty),
-        semi_token: Token ! [ ; ](tokens_helper(_visitor, &(_i.semi_token).0)),
+        semi_token: Token ! [ ; ](tokens_helper(_visitor, &_i.semi_token.spans)),
     }
 }
 #[cfg(feature = "full")]
@@ -1926,13 +1931,13 @@
     ItemConst {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
         vis: _visitor.fold_visibility(_i.vis),
-        const_token: Token ! [ const ](tokens_helper(_visitor, &(_i.const_token).0)),
+        const_token: Token ! [ const ](tokens_helper(_visitor, &_i.const_token.span)),
         ident: _visitor.fold_ident(_i.ident),
-        colon_token: Token ! [ : ](tokens_helper(_visitor, &(_i.colon_token).0)),
+        colon_token: Token ! [ : ](tokens_helper(_visitor, &_i.colon_token.spans)),
         ty: Box::new(_visitor.fold_type(*_i.ty)),
-        eq_token: Token ! [ = ](tokens_helper(_visitor, &(_i.eq_token).0)),
+        eq_token: Token ! [ = ](tokens_helper(_visitor, &_i.eq_token.spans)),
         expr: Box::new(_visitor.fold_expr(*_i.expr)),
-        semi_token: Token ! [ ; ](tokens_helper(_visitor, &(_i.semi_token).0)),
+        semi_token: Token ! [ ; ](tokens_helper(_visitor, &_i.semi_token.spans)),
     }
 }
 #[cfg(feature = "full")]
@@ -1940,10 +1945,10 @@
     ItemEnum {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
         vis: _visitor.fold_visibility(_i.vis),
-        enum_token: Token ! [ enum ](tokens_helper(_visitor, &(_i.enum_token).0)),
+        enum_token: Token ! [ enum ](tokens_helper(_visitor, &_i.enum_token.span)),
         ident: _visitor.fold_ident(_i.ident),
         generics: _visitor.fold_generics(_i.generics),
-        brace_token: Brace(tokens_helper(_visitor, &(_i.brace_token).0)),
+        brace_token: Brace(tokens_helper(_visitor, &_i.brace_token.span)),
         variants: FoldHelper::lift(_i.variants, |it| _visitor.fold_variant(it)),
     }
 }
@@ -1955,16 +1960,16 @@
     ItemExternCrate {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
         vis: _visitor.fold_visibility(_i.vis),
-        extern_token: Token![extern](tokens_helper(_visitor, &(_i.extern_token).0)),
-        crate_token: Token![crate](tokens_helper(_visitor, &(_i.crate_token).0)),
+        extern_token: Token![extern](tokens_helper(_visitor, &_i.extern_token.span)),
+        crate_token: Token![crate](tokens_helper(_visitor, &_i.crate_token.span)),
         ident: _visitor.fold_ident(_i.ident),
         rename: (_i.rename).map(|it| {
             (
-                Token ! [ as ](tokens_helper(_visitor, &((it).0).0)),
+                Token ! [ as ](tokens_helper(_visitor, &(it).0.span)),
                 _visitor.fold_ident((it).1),
             )
         }),
-        semi_token: Token ! [ ; ](tokens_helper(_visitor, &(_i.semi_token).0)),
+        semi_token: Token ! [ ; ](tokens_helper(_visitor, &_i.semi_token.spans)),
     }
 }
 #[cfg(feature = "full")]
@@ -1972,8 +1977,8 @@
     ItemFn {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
         vis: _visitor.fold_visibility(_i.vis),
-        constness: (_i.constness).map(|it| Token ! [ const ](tokens_helper(_visitor, &(it).0))),
-        unsafety: (_i.unsafety).map(|it| Token ! [ unsafe ](tokens_helper(_visitor, &(it).0))),
+        constness: (_i.constness).map(|it| Token ! [ const ](tokens_helper(_visitor, &it.span))),
+        unsafety: (_i.unsafety).map(|it| Token ! [ unsafe ](tokens_helper(_visitor, &it.span))),
         abi: (_i.abi).map(|it| _visitor.fold_abi(it)),
         ident: _visitor.fold_ident(_i.ident),
         decl: Box::new(_visitor.fold_fn_decl(*_i.decl)),
@@ -1988,7 +1993,7 @@
     ItemForeignMod {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
         abi: _visitor.fold_abi(_i.abi),
-        brace_token: Brace(tokens_helper(_visitor, &(_i.brace_token).0)),
+        brace_token: Brace(tokens_helper(_visitor, &_i.brace_token.span)),
         items: FoldHelper::lift(_i.items, |it| _visitor.fold_foreign_item(it)),
     }
 }
@@ -1996,19 +2001,19 @@
 pub fn fold_item_impl<V: Fold + ?Sized>(_visitor: &mut V, _i: ItemImpl) -> ItemImpl {
     ItemImpl {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
-        defaultness: (_i.defaultness).map(|it| Token![default](tokens_helper(_visitor, &(it).0))),
-        unsafety: (_i.unsafety).map(|it| Token ! [ unsafe ](tokens_helper(_visitor, &(it).0))),
-        impl_token: Token![impl ](tokens_helper(_visitor, &(_i.impl_token).0)),
+        defaultness: (_i.defaultness).map(|it| Token![default](tokens_helper(_visitor, &it.span))),
+        unsafety: (_i.unsafety).map(|it| Token ! [ unsafe ](tokens_helper(_visitor, &it.span))),
+        impl_token: Token![impl ](tokens_helper(_visitor, &_i.impl_token.span)),
         generics: _visitor.fold_generics(_i.generics),
         trait_: (_i.trait_).map(|it| {
             (
-                ((it).0).map(|it| Token![!](tokens_helper(_visitor, &(it).0))),
+                ((it).0).map(|it| Token![!](tokens_helper(_visitor, &it.spans))),
                 _visitor.fold_path((it).1),
-                Token ! [ for ](tokens_helper(_visitor, &((it).2).0)),
+                Token ! [ for ](tokens_helper(_visitor, &(it).2.span)),
             )
         }),
         self_ty: Box::new(_visitor.fold_type(*_i.self_ty)),
-        brace_token: Brace(tokens_helper(_visitor, &(_i.brace_token).0)),
+        brace_token: Brace(tokens_helper(_visitor, &_i.brace_token.span)),
         items: FoldHelper::lift(_i.items, |it| _visitor.fold_impl_item(it)),
     }
 }
@@ -2018,7 +2023,7 @@
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
         ident: (_i.ident).map(|it| _visitor.fold_ident(it)),
         mac: _visitor.fold_macro(_i.mac),
-        semi_token: (_i.semi_token).map(|it| Token ! [ ; ](tokens_helper(_visitor, &(it).0))),
+        semi_token: (_i.semi_token).map(|it| Token ! [ ; ](tokens_helper(_visitor, &it.spans))),
     }
 }
 #[cfg(feature = "full")]
@@ -2026,11 +2031,11 @@
     ItemMacro2 {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
         vis: _visitor.fold_visibility(_i.vis),
-        macro_token: Token ! [ macro ](tokens_helper(_visitor, &(_i.macro_token).0)),
+        macro_token: Token ! [ macro ](tokens_helper(_visitor, &_i.macro_token.span)),
         ident: _visitor.fold_ident(_i.ident),
-        paren_token: Paren(tokens_helper(_visitor, &(_i.paren_token).0)),
+        paren_token: Paren(tokens_helper(_visitor, &_i.paren_token.span)),
         args: _i.args,
-        brace_token: Brace(tokens_helper(_visitor, &(_i.brace_token).0)),
+        brace_token: Brace(tokens_helper(_visitor, &_i.brace_token.span)),
         body: _i.body,
     }
 }
@@ -2039,15 +2044,15 @@
     ItemMod {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
         vis: _visitor.fold_visibility(_i.vis),
-        mod_token: Token ! [ mod ](tokens_helper(_visitor, &(_i.mod_token).0)),
+        mod_token: Token ! [ mod ](tokens_helper(_visitor, &_i.mod_token.span)),
         ident: _visitor.fold_ident(_i.ident),
         content: (_i.content).map(|it| {
             (
-                Brace(tokens_helper(_visitor, &((it).0).0)),
+                Brace(tokens_helper(_visitor, &(it).0.span)),
                 FoldHelper::lift((it).1, |it| _visitor.fold_item(it)),
             )
         }),
-        semi: (_i.semi).map(|it| Token ! [ ; ](tokens_helper(_visitor, &(it).0))),
+        semi: (_i.semi).map(|it| Token ! [ ; ](tokens_helper(_visitor, &it.spans))),
     }
 }
 #[cfg(feature = "full")]
@@ -2055,14 +2060,14 @@
     ItemStatic {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
         vis: _visitor.fold_visibility(_i.vis),
-        static_token: Token ! [ static ](tokens_helper(_visitor, &(_i.static_token).0)),
-        mutability: (_i.mutability).map(|it| Token ! [ mut ](tokens_helper(_visitor, &(it).0))),
+        static_token: Token ! [ static ](tokens_helper(_visitor, &_i.static_token.span)),
+        mutability: (_i.mutability).map(|it| Token ! [ mut ](tokens_helper(_visitor, &it.span))),
         ident: _visitor.fold_ident(_i.ident),
-        colon_token: Token ! [ : ](tokens_helper(_visitor, &(_i.colon_token).0)),
+        colon_token: Token ! [ : ](tokens_helper(_visitor, &_i.colon_token.spans)),
         ty: Box::new(_visitor.fold_type(*_i.ty)),
-        eq_token: Token ! [ = ](tokens_helper(_visitor, &(_i.eq_token).0)),
+        eq_token: Token ! [ = ](tokens_helper(_visitor, &_i.eq_token.spans)),
         expr: Box::new(_visitor.fold_expr(*_i.expr)),
-        semi_token: Token ! [ ; ](tokens_helper(_visitor, &(_i.semi_token).0)),
+        semi_token: Token ! [ ; ](tokens_helper(_visitor, &_i.semi_token.spans)),
     }
 }
 #[cfg(feature = "full")]
@@ -2070,11 +2075,11 @@
     ItemStruct {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
         vis: _visitor.fold_visibility(_i.vis),
-        struct_token: Token ! [ struct ](tokens_helper(_visitor, &(_i.struct_token).0)),
+        struct_token: Token ! [ struct ](tokens_helper(_visitor, &_i.struct_token.span)),
         ident: _visitor.fold_ident(_i.ident),
         generics: _visitor.fold_generics(_i.generics),
         fields: _visitor.fold_fields(_i.fields),
-        semi_token: (_i.semi_token).map(|it| Token ! [ ; ](tokens_helper(_visitor, &(it).0))),
+        semi_token: (_i.semi_token).map(|it| Token ! [ ; ](tokens_helper(_visitor, &it.spans))),
     }
 }
 #[cfg(feature = "full")]
@@ -2082,14 +2087,14 @@
     ItemTrait {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
         vis: _visitor.fold_visibility(_i.vis),
-        unsafety: (_i.unsafety).map(|it| Token ! [ unsafe ](tokens_helper(_visitor, &(it).0))),
-        auto_token: (_i.auto_token).map(|it| Token![auto](tokens_helper(_visitor, &(it).0))),
-        trait_token: Token ! [ trait ](tokens_helper(_visitor, &(_i.trait_token).0)),
+        unsafety: (_i.unsafety).map(|it| Token ! [ unsafe ](tokens_helper(_visitor, &it.span))),
+        auto_token: (_i.auto_token).map(|it| Token![auto](tokens_helper(_visitor, &it.span))),
+        trait_token: Token ! [ trait ](tokens_helper(_visitor, &_i.trait_token.span)),
         ident: _visitor.fold_ident(_i.ident),
         generics: _visitor.fold_generics(_i.generics),
-        colon_token: (_i.colon_token).map(|it| Token ! [ : ](tokens_helper(_visitor, &(it).0))),
+        colon_token: (_i.colon_token).map(|it| Token ! [ : ](tokens_helper(_visitor, &it.spans))),
         supertraits: FoldHelper::lift(_i.supertraits, |it| _visitor.fold_type_param_bound(it)),
-        brace_token: Brace(tokens_helper(_visitor, &(_i.brace_token).0)),
+        brace_token: Brace(tokens_helper(_visitor, &_i.brace_token.span)),
         items: FoldHelper::lift(_i.items, |it| _visitor.fold_trait_item(it)),
     }
 }
@@ -2098,12 +2103,12 @@
     ItemType {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
         vis: _visitor.fold_visibility(_i.vis),
-        type_token: Token ! [ type ](tokens_helper(_visitor, &(_i.type_token).0)),
+        type_token: Token ! [ type ](tokens_helper(_visitor, &_i.type_token.span)),
         ident: _visitor.fold_ident(_i.ident),
         generics: _visitor.fold_generics(_i.generics),
-        eq_token: Token ! [ = ](tokens_helper(_visitor, &(_i.eq_token).0)),
+        eq_token: Token ! [ = ](tokens_helper(_visitor, &_i.eq_token.spans)),
         ty: Box::new(_visitor.fold_type(*_i.ty)),
-        semi_token: Token ! [ ; ](tokens_helper(_visitor, &(_i.semi_token).0)),
+        semi_token: Token ! [ ; ](tokens_helper(_visitor, &_i.semi_token.spans)),
     }
 }
 #[cfg(feature = "full")]
@@ -2111,7 +2116,7 @@
     ItemUnion {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
         vis: _visitor.fold_visibility(_i.vis),
-        union_token: Token![union](tokens_helper(_visitor, &(_i.union_token).0)),
+        union_token: Token![union](tokens_helper(_visitor, &_i.union_token.span)),
         ident: _visitor.fold_ident(_i.ident),
         generics: _visitor.fold_generics(_i.generics),
         fields: _visitor.fold_fields_named(_i.fields),
@@ -2122,11 +2127,11 @@
     ItemUse {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
         vis: _visitor.fold_visibility(_i.vis),
-        use_token: Token ! [ use ](tokens_helper(_visitor, &(_i.use_token).0)),
+        use_token: Token ! [ use ](tokens_helper(_visitor, &_i.use_token.span)),
         leading_colon: (_i.leading_colon)
-            .map(|it| Token ! [ :: ](tokens_helper(_visitor, &(it).0))),
+            .map(|it| Token ! [ :: ](tokens_helper(_visitor, &it.spans))),
         tree: _visitor.fold_use_tree(_i.tree),
-        semi_token: Token ! [ ; ](tokens_helper(_visitor, &(_i.semi_token).0)),
+        semi_token: Token ! [ ; ](tokens_helper(_visitor, &_i.semi_token.spans)),
     }
 }
 #[cfg(feature = "full")]
@@ -2138,7 +2143,7 @@
 pub fn fold_label<V: Fold + ?Sized>(_visitor: &mut V, _i: Label) -> Label {
     Label {
         name: _visitor.fold_lifetime(_i.name),
-        colon_token: Token ! [ : ](tokens_helper(_visitor, &(_i.colon_token).0)),
+        colon_token: Token ! [ : ](tokens_helper(_visitor, &_i.colon_token.spans)),
     }
 }
 #[cfg(any(feature = "full", feature = "derive"))]
@@ -2153,7 +2158,7 @@
     LifetimeDef {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
         lifetime: _visitor.fold_lifetime(_i.lifetime),
-        colon_token: (_i.colon_token).map(|it| Token ! [ : ](tokens_helper(_visitor, &(it).0))),
+        colon_token: (_i.colon_token).map(|it| Token ! [ : ](tokens_helper(_visitor, &it.spans))),
         bounds: FoldHelper::lift(_i.bounds, |it| _visitor.fold_lifetime(it)),
     }
 }
@@ -2186,28 +2191,28 @@
 pub fn fold_local<V: Fold + ?Sized>(_visitor: &mut V, _i: Local) -> Local {
     Local {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
-        let_token: Token ! [ let ](tokens_helper(_visitor, &(_i.let_token).0)),
+        let_token: Token ! [ let ](tokens_helper(_visitor, &_i.let_token.span)),
         pats: FoldHelper::lift(_i.pats, |it| _visitor.fold_pat(it)),
         ty: (_i.ty).map(|it| {
             (
-                Token ! [ : ](tokens_helper(_visitor, &((it).0).0)),
+                Token ! [ : ](tokens_helper(_visitor, &(it).0.spans)),
                 Box::new(_visitor.fold_type(*(it).1)),
             )
         }),
         init: (_i.init).map(|it| {
             (
-                Token ! [ = ](tokens_helper(_visitor, &((it).0).0)),
+                Token ! [ = ](tokens_helper(_visitor, &(it).0.spans)),
                 Box::new(_visitor.fold_expr(*(it).1)),
             )
         }),
-        semi_token: Token ! [ ; ](tokens_helper(_visitor, &(_i.semi_token).0)),
+        semi_token: Token ! [ ; ](tokens_helper(_visitor, &_i.semi_token.spans)),
     }
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn fold_macro<V: Fold + ?Sized>(_visitor: &mut V, _i: Macro) -> Macro {
     Macro {
         path: _visitor.fold_path(_i.path),
-        bang_token: Token![!](tokens_helper(_visitor, &(_i.bang_token).0)),
+        bang_token: Token![!](tokens_helper(_visitor, &_i.bang_token.spans)),
         delimiter: _visitor.fold_macro_delimiter(_i.delimiter),
         tts: _i.tts,
     }
@@ -2219,13 +2224,13 @@
 ) -> MacroDelimiter {
     match _i {
         MacroDelimiter::Paren(_binding_0) => {
-            MacroDelimiter::Paren(Paren(tokens_helper(_visitor, &(_binding_0).0)))
+            MacroDelimiter::Paren(Paren(tokens_helper(_visitor, &_binding_0.span)))
         }
         MacroDelimiter::Brace(_binding_0) => {
-            MacroDelimiter::Brace(Brace(tokens_helper(_visitor, &(_binding_0).0)))
+            MacroDelimiter::Brace(Brace(tokens_helper(_visitor, &_binding_0.span)))
         }
         MacroDelimiter::Bracket(_binding_0) => {
-            MacroDelimiter::Bracket(Bracket(tokens_helper(_visitor, &(_binding_0).0)))
+            MacroDelimiter::Bracket(Bracket(tokens_helper(_visitor, &_binding_0.span)))
         }
     }
 }
@@ -2248,7 +2253,7 @@
 pub fn fold_meta_list<V: Fold + ?Sized>(_visitor: &mut V, _i: MetaList) -> MetaList {
     MetaList {
         ident: _visitor.fold_ident(_i.ident),
-        paren_token: Paren(tokens_helper(_visitor, &(_i.paren_token).0)),
+        paren_token: Paren(tokens_helper(_visitor, &_i.paren_token.span)),
         nested: FoldHelper::lift(_i.nested, |it| _visitor.fold_nested_meta(it)),
     }
 }
@@ -2259,15 +2264,15 @@
 ) -> MetaNameValue {
     MetaNameValue {
         ident: _visitor.fold_ident(_i.ident),
-        eq_token: Token ! [ = ](tokens_helper(_visitor, &(_i.eq_token).0)),
+        eq_token: Token ! [ = ](tokens_helper(_visitor, &_i.eq_token.spans)),
         lit: _visitor.fold_lit(_i.lit),
     }
 }
 #[cfg(feature = "full")]
 pub fn fold_method_sig<V: Fold + ?Sized>(_visitor: &mut V, _i: MethodSig) -> MethodSig {
     MethodSig {
-        constness: (_i.constness).map(|it| Token ! [ const ](tokens_helper(_visitor, &(it).0))),
-        unsafety: (_i.unsafety).map(|it| Token ! [ unsafe ](tokens_helper(_visitor, &(it).0))),
+        constness: (_i.constness).map(|it| Token ! [ const ](tokens_helper(_visitor, &it.span))),
+        unsafety: (_i.unsafety).map(|it| Token ! [ unsafe ](tokens_helper(_visitor, &it.span))),
         abi: (_i.abi).map(|it| _visitor.fold_abi(it)),
         ident: _visitor.fold_ident(_i.ident),
         decl: _visitor.fold_fn_decl(_i.decl),
@@ -2280,10 +2285,10 @@
     _i: MethodTurbofish,
 ) -> MethodTurbofish {
     MethodTurbofish {
-        colon2_token: Token ! [ :: ](tokens_helper(_visitor, &(_i.colon2_token).0)),
-        lt_token: Token ! [ < ](tokens_helper(_visitor, &(_i.lt_token).0)),
+        colon2_token: Token ! [ :: ](tokens_helper(_visitor, &_i.colon2_token.spans)),
+        lt_token: Token ! [ < ](tokens_helper(_visitor, &_i.lt_token.spans)),
         args: FoldHelper::lift(_i.args, |it| _visitor.fold_generic_method_argument(it)),
-        gt_token: Token ! [ > ](tokens_helper(_visitor, &(_i.gt_token).0)),
+        gt_token: Token ! [ > ](tokens_helper(_visitor, &_i.gt_token.spans)),
     }
 }
 #[cfg(any(feature = "full", feature = "derive"))]
@@ -2299,7 +2304,7 @@
     _i: ParenthesizedGenericArguments,
 ) -> ParenthesizedGenericArguments {
     ParenthesizedGenericArguments {
-        paren_token: Paren(tokens_helper(_visitor, &(_i.paren_token).0)),
+        paren_token: Paren(tokens_helper(_visitor, &_i.paren_token.span)),
         inputs: FoldHelper::lift(_i.inputs, |it| _visitor.fold_type(it)),
         output: _visitor.fold_return_type(_i.output),
     }
@@ -2329,7 +2334,7 @@
 #[cfg(feature = "full")]
 pub fn fold_pat_box<V: Fold + ?Sized>(_visitor: &mut V, _i: PatBox) -> PatBox {
     PatBox {
-        box_token: Token ! [ box ](tokens_helper(_visitor, &(_i.box_token).0)),
+        box_token: Token ! [ box ](tokens_helper(_visitor, &_i.box_token.span)),
         pat: Box::new(_visitor.fold_pat(*_i.pat)),
     }
 }
@@ -2337,12 +2342,12 @@
 #[cfg(feature = "full")]
 pub fn fold_pat_ident<V: Fold + ?Sized>(_visitor: &mut V, _i: PatIdent) -> PatIdent {
     PatIdent {
-        by_ref: (_i.by_ref).map(|it| Token ! [ ref ](tokens_helper(_visitor, &(it).0))),
-        mutability: (_i.mutability).map(|it| Token ! [ mut ](tokens_helper(_visitor, &(it).0))),
+        by_ref: (_i.by_ref).map(|it| Token ! [ ref ](tokens_helper(_visitor, &it.span))),
+        mutability: (_i.mutability).map(|it| Token ! [ mut ](tokens_helper(_visitor, &it.span))),
         ident: _visitor.fold_ident(_i.ident),
         subpat: (_i.subpat).map(|it| {
             (
-                Token ! [ @ ](tokens_helper(_visitor, &((it).0).0)),
+                Token ! [ @ ](tokens_helper(_visitor, &(it).0.spans)),
                 Box::new(_visitor.fold_pat(*(it).1)),
             )
         }),
@@ -2383,8 +2388,8 @@
 #[cfg(feature = "full")]
 pub fn fold_pat_ref<V: Fold + ?Sized>(_visitor: &mut V, _i: PatRef) -> PatRef {
     PatRef {
-        and_token: Token ! [ & ](tokens_helper(_visitor, &(_i.and_token).0)),
-        mutability: (_i.mutability).map(|it| Token ! [ mut ](tokens_helper(_visitor, &(it).0))),
+        and_token: Token ! [ & ](tokens_helper(_visitor, &_i.and_token.spans)),
+        mutability: (_i.mutability).map(|it| Token ! [ mut ](tokens_helper(_visitor, &it.span))),
         pat: Box::new(_visitor.fold_pat(*_i.pat)),
     }
 }
@@ -2392,11 +2397,11 @@
 #[cfg(feature = "full")]
 pub fn fold_pat_slice<V: Fold + ?Sized>(_visitor: &mut V, _i: PatSlice) -> PatSlice {
     PatSlice {
-        bracket_token: Bracket(tokens_helper(_visitor, &(_i.bracket_token).0)),
+        bracket_token: Bracket(tokens_helper(_visitor, &_i.bracket_token.span)),
         front: FoldHelper::lift(_i.front, |it| _visitor.fold_pat(it)),
         middle: (_i.middle).map(|it| Box::new(_visitor.fold_pat(*it))),
-        dot2_token: (_i.dot2_token).map(|it| Token![..](tokens_helper(_visitor, &(it).0))),
-        comma_token: (_i.comma_token).map(|it| Token ! [ , ](tokens_helper(_visitor, &(it).0))),
+        dot2_token: (_i.dot2_token).map(|it| Token![..](tokens_helper(_visitor, &it.spans))),
+        comma_token: (_i.comma_token).map(|it| Token ! [ , ](tokens_helper(_visitor, &it.spans))),
         back: FoldHelper::lift(_i.back, |it| _visitor.fold_pat(it)),
     }
 }
@@ -2405,19 +2410,19 @@
 pub fn fold_pat_struct<V: Fold + ?Sized>(_visitor: &mut V, _i: PatStruct) -> PatStruct {
     PatStruct {
         path: _visitor.fold_path(_i.path),
-        brace_token: Brace(tokens_helper(_visitor, &(_i.brace_token).0)),
+        brace_token: Brace(tokens_helper(_visitor, &_i.brace_token.span)),
         fields: FoldHelper::lift(_i.fields, |it| _visitor.fold_field_pat(it)),
-        dot2_token: (_i.dot2_token).map(|it| Token![..](tokens_helper(_visitor, &(it).0))),
+        dot2_token: (_i.dot2_token).map(|it| Token![..](tokens_helper(_visitor, &it.spans))),
     }
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn fold_pat_tuple<V: Fold + ?Sized>(_visitor: &mut V, _i: PatTuple) -> PatTuple {
     PatTuple {
-        paren_token: Paren(tokens_helper(_visitor, &(_i.paren_token).0)),
+        paren_token: Paren(tokens_helper(_visitor, &_i.paren_token.span)),
         front: FoldHelper::lift(_i.front, |it| _visitor.fold_pat(it)),
-        dot2_token: (_i.dot2_token).map(|it| Token![..](tokens_helper(_visitor, &(it).0))),
-        comma_token: (_i.comma_token).map(|it| Token ! [ , ](tokens_helper(_visitor, &(it).0))),
+        dot2_token: (_i.dot2_token).map(|it| Token![..](tokens_helper(_visitor, &it.spans))),
+        comma_token: (_i.comma_token).map(|it| Token ! [ , ](tokens_helper(_visitor, &it.spans))),
         back: FoldHelper::lift(_i.back, |it| _visitor.fold_pat(it)),
     }
 }
@@ -2441,14 +2446,14 @@
 #[cfg(feature = "full")]
 pub fn fold_pat_wild<V: Fold + ?Sized>(_visitor: &mut V, _i: PatWild) -> PatWild {
     PatWild {
-        underscore_token: Token![_](tokens_helper(_visitor, &(_i.underscore_token).0)),
+        underscore_token: Token![_](tokens_helper(_visitor, &_i.underscore_token.spans)),
     }
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn fold_path<V: Fold + ?Sized>(_visitor: &mut V, _i: Path) -> Path {
     Path {
         leading_colon: (_i.leading_colon)
-            .map(|it| Token ! [ :: ](tokens_helper(_visitor, &(it).0))),
+            .map(|it| Token ! [ :: ](tokens_helper(_visitor, &it.spans))),
         segments: FoldHelper::lift(_i.segments, |it| _visitor.fold_path_segment(it)),
     }
 }
@@ -2475,7 +2480,7 @@
 pub fn fold_predicate_eq<V: Fold + ?Sized>(_visitor: &mut V, _i: PredicateEq) -> PredicateEq {
     PredicateEq {
         lhs_ty: _visitor.fold_type(_i.lhs_ty),
-        eq_token: Token ! [ = ](tokens_helper(_visitor, &(_i.eq_token).0)),
+        eq_token: Token ! [ = ](tokens_helper(_visitor, &_i.eq_token.spans)),
         rhs_ty: _visitor.fold_type(_i.rhs_ty),
     }
 }
@@ -2486,7 +2491,7 @@
 ) -> PredicateLifetime {
     PredicateLifetime {
         lifetime: _visitor.fold_lifetime(_i.lifetime),
-        colon_token: (_i.colon_token).map(|it| Token ! [ : ](tokens_helper(_visitor, &(it).0))),
+        colon_token: (_i.colon_token).map(|it| Token ! [ : ](tokens_helper(_visitor, &it.spans))),
         bounds: FoldHelper::lift(_i.bounds, |it| _visitor.fold_lifetime(it)),
     }
 }
@@ -2495,18 +2500,18 @@
     PredicateType {
         lifetimes: (_i.lifetimes).map(|it| _visitor.fold_bound_lifetimes(it)),
         bounded_ty: _visitor.fold_type(_i.bounded_ty),
-        colon_token: Token ! [ : ](tokens_helper(_visitor, &(_i.colon_token).0)),
+        colon_token: Token ! [ : ](tokens_helper(_visitor, &_i.colon_token.spans)),
         bounds: FoldHelper::lift(_i.bounds, |it| _visitor.fold_type_param_bound(it)),
     }
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn fold_qself<V: Fold + ?Sized>(_visitor: &mut V, _i: QSelf) -> QSelf {
     QSelf {
-        lt_token: Token ! [ < ](tokens_helper(_visitor, &(_i.lt_token).0)),
+        lt_token: Token ! [ < ](tokens_helper(_visitor, &_i.lt_token.spans)),
         ty: Box::new(_visitor.fold_type(*_i.ty)),
         position: _i.position,
-        as_token: (_i.as_token).map(|it| Token ! [ as ](tokens_helper(_visitor, &(it).0))),
-        gt_token: Token ! [ > ](tokens_helper(_visitor, &(_i.gt_token).0)),
+        as_token: (_i.as_token).map(|it| Token ! [ as ](tokens_helper(_visitor, &it.span))),
+        gt_token: Token ! [ > ](tokens_helper(_visitor, &_i.gt_token.spans)),
     }
 }
 #[cfg(any(feature = "full", feature = "derive"))]
@@ -2514,10 +2519,10 @@
 pub fn fold_range_limits<V: Fold + ?Sized>(_visitor: &mut V, _i: RangeLimits) -> RangeLimits {
     match _i {
         RangeLimits::HalfOpen(_binding_0) => {
-            RangeLimits::HalfOpen(Token![..](tokens_helper(_visitor, &(_binding_0).0)))
+            RangeLimits::HalfOpen(Token![..](tokens_helper(_visitor, &_binding_0.spans)))
         }
         RangeLimits::Closed(_binding_0) => {
-            RangeLimits::Closed(Token ! [ ..= ](tokens_helper(_visitor, &(_binding_0).0)))
+            RangeLimits::Closed(Token ! [ ..= ](tokens_helper(_visitor, &_binding_0.spans)))
         }
     }
 }
@@ -2526,7 +2531,7 @@
     match _i {
         ReturnType::Default => ReturnType::Default,
         ReturnType::Type(_binding_0, _binding_1) => ReturnType::Type(
-            Token ! [ -> ](tokens_helper(_visitor, &(_binding_0).0)),
+            Token ! [ -> ](tokens_helper(_visitor, &_binding_0.spans)),
             Box::new(_visitor.fold_type(*_binding_1)),
         ),
     }
@@ -2543,14 +2548,14 @@
         Stmt::Expr(_binding_0) => Stmt::Expr(_visitor.fold_expr(_binding_0)),
         Stmt::Semi(_binding_0, _binding_1) => Stmt::Semi(
             _visitor.fold_expr(_binding_0),
-            Token ! [ ; ](tokens_helper(_visitor, &(_binding_1).0)),
+            Token ! [ ; ](tokens_helper(_visitor, &_binding_1.spans)),
         ),
     }
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn fold_trait_bound<V: Fold + ?Sized>(_visitor: &mut V, _i: TraitBound) -> TraitBound {
     TraitBound {
-        paren_token: (_i.paren_token).map(|it| Paren(tokens_helper(_visitor, &(it).0))),
+        paren_token: (_i.paren_token).map(|it| Paren(tokens_helper(_visitor, &it.span))),
         modifier: _visitor.fold_trait_bound_modifier(_i.modifier),
         lifetimes: (_i.lifetimes).map(|it| _visitor.fold_bound_lifetimes(it)),
         path: _visitor.fold_path(_i.path),
@@ -2564,7 +2569,7 @@
     match _i {
         TraitBoundModifier::None => TraitBoundModifier::None,
         TraitBoundModifier::Maybe(_binding_0) => {
-            TraitBoundModifier::Maybe(Token ! [ ? ](tokens_helper(_visitor, &(_binding_0).0)))
+            TraitBoundModifier::Maybe(Token ! [ ? ](tokens_helper(_visitor, &_binding_0.spans)))
         }
     }
 }
@@ -2593,17 +2598,17 @@
 ) -> TraitItemConst {
     TraitItemConst {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
-        const_token: Token ! [ const ](tokens_helper(_visitor, &(_i.const_token).0)),
+        const_token: Token ! [ const ](tokens_helper(_visitor, &_i.const_token.span)),
         ident: _visitor.fold_ident(_i.ident),
-        colon_token: Token ! [ : ](tokens_helper(_visitor, &(_i.colon_token).0)),
+        colon_token: Token ! [ : ](tokens_helper(_visitor, &_i.colon_token.spans)),
         ty: _visitor.fold_type(_i.ty),
         default: (_i.default).map(|it| {
             (
-                Token ! [ = ](tokens_helper(_visitor, &((it).0).0)),
+                Token ! [ = ](tokens_helper(_visitor, &(it).0.spans)),
                 _visitor.fold_expr((it).1),
             )
         }),
-        semi_token: Token ! [ ; ](tokens_helper(_visitor, &(_i.semi_token).0)),
+        semi_token: Token ! [ ; ](tokens_helper(_visitor, &_i.semi_token.spans)),
     }
 }
 #[cfg(feature = "full")]
@@ -2614,7 +2619,7 @@
     TraitItemMacro {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
         mac: _visitor.fold_macro(_i.mac),
-        semi_token: (_i.semi_token).map(|it| Token ! [ ; ](tokens_helper(_visitor, &(it).0))),
+        semi_token: (_i.semi_token).map(|it| Token ! [ ; ](tokens_helper(_visitor, &it.spans))),
     }
 }
 #[cfg(feature = "full")]
@@ -2626,7 +2631,7 @@
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
         sig: _visitor.fold_method_sig(_i.sig),
         default: (_i.default).map(|it| _visitor.fold_block(it)),
-        semi_token: (_i.semi_token).map(|it| Token ! [ ; ](tokens_helper(_visitor, &(it).0))),
+        semi_token: (_i.semi_token).map(|it| Token ! [ ; ](tokens_helper(_visitor, &it.spans))),
     }
 }
 #[cfg(feature = "full")]
@@ -2636,18 +2641,18 @@
 ) -> TraitItemType {
     TraitItemType {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
-        type_token: Token ! [ type ](tokens_helper(_visitor, &(_i.type_token).0)),
+        type_token: Token ! [ type ](tokens_helper(_visitor, &_i.type_token.span)),
         ident: _visitor.fold_ident(_i.ident),
         generics: _visitor.fold_generics(_i.generics),
-        colon_token: (_i.colon_token).map(|it| Token ! [ : ](tokens_helper(_visitor, &(it).0))),
+        colon_token: (_i.colon_token).map(|it| Token ! [ : ](tokens_helper(_visitor, &it.spans))),
         bounds: FoldHelper::lift(_i.bounds, |it| _visitor.fold_type_param_bound(it)),
         default: (_i.default).map(|it| {
             (
-                Token ! [ = ](tokens_helper(_visitor, &((it).0).0)),
+                Token ! [ = ](tokens_helper(_visitor, &(it).0.spans)),
                 _visitor.fold_type((it).1),
             )
         }),
-        semi_token: Token ! [ ; ](tokens_helper(_visitor, &(_i.semi_token).0)),
+        semi_token: Token ! [ ; ](tokens_helper(_visitor, &_i.semi_token.spans)),
     }
 }
 #[cfg(feature = "full")]
@@ -2682,29 +2687,29 @@
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn fold_type_array<V: Fold + ?Sized>(_visitor: &mut V, _i: TypeArray) -> TypeArray {
     TypeArray {
-        bracket_token: Bracket(tokens_helper(_visitor, &(_i.bracket_token).0)),
+        bracket_token: Bracket(tokens_helper(_visitor, &_i.bracket_token.span)),
         elem: Box::new(_visitor.fold_type(*_i.elem)),
-        semi_token: Token ! [ ; ](tokens_helper(_visitor, &(_i.semi_token).0)),
+        semi_token: Token ! [ ; ](tokens_helper(_visitor, &_i.semi_token.spans)),
         len: _visitor.fold_expr(_i.len),
     }
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn fold_type_bare_fn<V: Fold + ?Sized>(_visitor: &mut V, _i: TypeBareFn) -> TypeBareFn {
     TypeBareFn {
-        unsafety: (_i.unsafety).map(|it| Token ! [ unsafe ](tokens_helper(_visitor, &(it).0))),
+        unsafety: (_i.unsafety).map(|it| Token ! [ unsafe ](tokens_helper(_visitor, &it.span))),
         abi: (_i.abi).map(|it| _visitor.fold_abi(it)),
-        fn_token: Token ! [ fn ](tokens_helper(_visitor, &(_i.fn_token).0)),
+        fn_token: Token ! [ fn ](tokens_helper(_visitor, &_i.fn_token.span)),
         lifetimes: (_i.lifetimes).map(|it| _visitor.fold_bound_lifetimes(it)),
-        paren_token: Paren(tokens_helper(_visitor, &(_i.paren_token).0)),
+        paren_token: Paren(tokens_helper(_visitor, &_i.paren_token.span)),
         inputs: FoldHelper::lift(_i.inputs, |it| _visitor.fold_bare_fn_arg(it)),
-        variadic: (_i.variadic).map(|it| Token ! [ ... ](tokens_helper(_visitor, &(it).0))),
+        variadic: (_i.variadic).map(|it| Token ! [ ... ](tokens_helper(_visitor, &it.spans))),
         output: _visitor.fold_return_type(_i.output),
     }
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn fold_type_group<V: Fold + ?Sized>(_visitor: &mut V, _i: TypeGroup) -> TypeGroup {
     TypeGroup {
-        group_token: Group(tokens_helper(_visitor, &(_i.group_token).0)),
+        group_token: Group(tokens_helper(_visitor, &_i.group_token.span)),
         elem: Box::new(_visitor.fold_type(*_i.elem)),
     }
 }
@@ -2714,14 +2719,14 @@
     _i: TypeImplTrait,
 ) -> TypeImplTrait {
     TypeImplTrait {
-        impl_token: Token![impl ](tokens_helper(_visitor, &(_i.impl_token).0)),
+        impl_token: Token![impl ](tokens_helper(_visitor, &_i.impl_token.span)),
         bounds: FoldHelper::lift(_i.bounds, |it| _visitor.fold_type_param_bound(it)),
     }
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn fold_type_infer<V: Fold + ?Sized>(_visitor: &mut V, _i: TypeInfer) -> TypeInfer {
     TypeInfer {
-        underscore_token: Token![_](tokens_helper(_visitor, &(_i.underscore_token).0)),
+        underscore_token: Token![_](tokens_helper(_visitor, &_i.underscore_token.spans)),
     }
 }
 #[cfg(any(feature = "full", feature = "derive"))]
@@ -2733,7 +2738,7 @@
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn fold_type_never<V: Fold + ?Sized>(_visitor: &mut V, _i: TypeNever) -> TypeNever {
     TypeNever {
-        bang_token: Token![!](tokens_helper(_visitor, &(_i.bang_token).0)),
+        bang_token: Token![!](tokens_helper(_visitor, &_i.bang_token.spans)),
     }
 }
 #[cfg(any(feature = "full", feature = "derive"))]
@@ -2741,9 +2746,9 @@
     TypeParam {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
         ident: _visitor.fold_ident(_i.ident),
-        colon_token: (_i.colon_token).map(|it| Token ! [ : ](tokens_helper(_visitor, &(it).0))),
+        colon_token: (_i.colon_token).map(|it| Token ! [ : ](tokens_helper(_visitor, &it.spans))),
         bounds: FoldHelper::lift(_i.bounds, |it| _visitor.fold_type_param_bound(it)),
-        eq_token: (_i.eq_token).map(|it| Token ! [ = ](tokens_helper(_visitor, &(it).0))),
+        eq_token: (_i.eq_token).map(|it| Token ! [ = ](tokens_helper(_visitor, &it.spans))),
         default: (_i.default).map(|it| _visitor.fold_type(it)),
     }
 }
@@ -2764,7 +2769,7 @@
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn fold_type_paren<V: Fold + ?Sized>(_visitor: &mut V, _i: TypeParen) -> TypeParen {
     TypeParen {
-        paren_token: Paren(tokens_helper(_visitor, &(_i.paren_token).0)),
+        paren_token: Paren(tokens_helper(_visitor, &_i.paren_token.span)),
         elem: Box::new(_visitor.fold_type(*_i.elem)),
     }
 }
@@ -2778,25 +2783,26 @@
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn fold_type_ptr<V: Fold + ?Sized>(_visitor: &mut V, _i: TypePtr) -> TypePtr {
     TypePtr {
-        star_token: Token ! [ * ](tokens_helper(_visitor, &(_i.star_token).0)),
-        const_token: (_i.const_token).map(|it| Token ! [ const ](tokens_helper(_visitor, &(it).0))),
-        mutability: (_i.mutability).map(|it| Token ! [ mut ](tokens_helper(_visitor, &(it).0))),
+        star_token: Token ! [ * ](tokens_helper(_visitor, &_i.star_token.spans)),
+        const_token: (_i.const_token)
+            .map(|it| Token ! [ const ](tokens_helper(_visitor, &it.span))),
+        mutability: (_i.mutability).map(|it| Token ! [ mut ](tokens_helper(_visitor, &it.span))),
         elem: Box::new(_visitor.fold_type(*_i.elem)),
     }
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn fold_type_reference<V: Fold + ?Sized>(_visitor: &mut V, _i: TypeReference) -> TypeReference {
     TypeReference {
-        and_token: Token ! [ & ](tokens_helper(_visitor, &(_i.and_token).0)),
+        and_token: Token ! [ & ](tokens_helper(_visitor, &_i.and_token.spans)),
         lifetime: (_i.lifetime).map(|it| _visitor.fold_lifetime(it)),
-        mutability: (_i.mutability).map(|it| Token ! [ mut ](tokens_helper(_visitor, &(it).0))),
+        mutability: (_i.mutability).map(|it| Token ! [ mut ](tokens_helper(_visitor, &it.span))),
         elem: Box::new(_visitor.fold_type(*_i.elem)),
     }
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn fold_type_slice<V: Fold + ?Sized>(_visitor: &mut V, _i: TypeSlice) -> TypeSlice {
     TypeSlice {
-        bracket_token: Bracket(tokens_helper(_visitor, &(_i.bracket_token).0)),
+        bracket_token: Bracket(tokens_helper(_visitor, &_i.bracket_token.span)),
         elem: Box::new(_visitor.fold_type(*_i.elem)),
     }
 }
@@ -2806,14 +2812,14 @@
     _i: TypeTraitObject,
 ) -> TypeTraitObject {
     TypeTraitObject {
-        dyn_token: (_i.dyn_token).map(|it| Token![dyn](tokens_helper(_visitor, &(it).0))),
+        dyn_token: (_i.dyn_token).map(|it| Token![dyn](tokens_helper(_visitor, &it.span))),
         bounds: FoldHelper::lift(_i.bounds, |it| _visitor.fold_type_param_bound(it)),
     }
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn fold_type_tuple<V: Fold + ?Sized>(_visitor: &mut V, _i: TypeTuple) -> TypeTuple {
     TypeTuple {
-        paren_token: Paren(tokens_helper(_visitor, &(_i.paren_token).0)),
+        paren_token: Paren(tokens_helper(_visitor, &_i.paren_token.span)),
         elems: FoldHelper::lift(_i.elems, |it| _visitor.fold_type(it)),
     }
 }
@@ -2825,22 +2831,24 @@
 pub fn fold_un_op<V: Fold + ?Sized>(_visitor: &mut V, _i: UnOp) -> UnOp {
     match _i {
         UnOp::Deref(_binding_0) => {
-            UnOp::Deref(Token ! [ * ](tokens_helper(_visitor, &(_binding_0).0)))
+            UnOp::Deref(Token ! [ * ](tokens_helper(_visitor, &_binding_0.spans)))
         }
-        UnOp::Not(_binding_0) => UnOp::Not(Token![!](tokens_helper(_visitor, &(_binding_0).0))),
-        UnOp::Neg(_binding_0) => UnOp::Neg(Token ! [ - ](tokens_helper(_visitor, &(_binding_0).0))),
+        UnOp::Not(_binding_0) => UnOp::Not(Token![!](tokens_helper(_visitor, &_binding_0.spans))),
+        UnOp::Neg(_binding_0) => {
+            UnOp::Neg(Token ! [ - ](tokens_helper(_visitor, &_binding_0.spans)))
+        }
     }
 }
 #[cfg(feature = "full")]
 pub fn fold_use_glob<V: Fold + ?Sized>(_visitor: &mut V, _i: UseGlob) -> UseGlob {
     UseGlob {
-        star_token: Token ! [ * ](tokens_helper(_visitor, &(_i.star_token).0)),
+        star_token: Token ! [ * ](tokens_helper(_visitor, &_i.star_token.spans)),
     }
 }
 #[cfg(feature = "full")]
 pub fn fold_use_group<V: Fold + ?Sized>(_visitor: &mut V, _i: UseGroup) -> UseGroup {
     UseGroup {
-        brace_token: Brace(tokens_helper(_visitor, &(_i.brace_token).0)),
+        brace_token: Brace(tokens_helper(_visitor, &_i.brace_token.span)),
         items: FoldHelper::lift(_i.items, |it| _visitor.fold_use_tree(it)),
     }
 }
@@ -2854,7 +2862,7 @@
 pub fn fold_use_path<V: Fold + ?Sized>(_visitor: &mut V, _i: UsePath) -> UsePath {
     UsePath {
         ident: _visitor.fold_ident(_i.ident),
-        colon2_token: Token ! [ :: ](tokens_helper(_visitor, &(_i.colon2_token).0)),
+        colon2_token: Token ! [ :: ](tokens_helper(_visitor, &_i.colon2_token.spans)),
         tree: Box::new(_visitor.fold_use_tree(*_i.tree)),
     }
 }
@@ -2862,7 +2870,7 @@
 pub fn fold_use_rename<V: Fold + ?Sized>(_visitor: &mut V, _i: UseRename) -> UseRename {
     UseRename {
         ident: _visitor.fold_ident(_i.ident),
-        as_token: Token ! [ as ](tokens_helper(_visitor, &(_i.as_token).0)),
+        as_token: Token ! [ as ](tokens_helper(_visitor, &_i.as_token.span)),
         rename: _visitor.fold_ident(_i.rename),
     }
 }
@@ -2884,7 +2892,7 @@
         fields: _visitor.fold_fields(_i.fields),
         discriminant: (_i.discriminant).map(|it| {
             (
-                Token ! [ = ](tokens_helper(_visitor, &((it).0).0)),
+                Token ! [ = ](tokens_helper(_visitor, &(it).0.spans)),
                 _visitor.fold_expr((it).1),
             )
         }),
@@ -2893,21 +2901,21 @@
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn fold_vis_crate<V: Fold + ?Sized>(_visitor: &mut V, _i: VisCrate) -> VisCrate {
     VisCrate {
-        crate_token: Token![crate](tokens_helper(_visitor, &(_i.crate_token).0)),
+        crate_token: Token![crate](tokens_helper(_visitor, &_i.crate_token.span)),
     }
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn fold_vis_public<V: Fold + ?Sized>(_visitor: &mut V, _i: VisPublic) -> VisPublic {
     VisPublic {
-        pub_token: Token ! [ pub ](tokens_helper(_visitor, &(_i.pub_token).0)),
+        pub_token: Token ! [ pub ](tokens_helper(_visitor, &_i.pub_token.span)),
     }
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn fold_vis_restricted<V: Fold + ?Sized>(_visitor: &mut V, _i: VisRestricted) -> VisRestricted {
     VisRestricted {
-        pub_token: Token ! [ pub ](tokens_helper(_visitor, &(_i.pub_token).0)),
-        paren_token: Paren(tokens_helper(_visitor, &(_i.paren_token).0)),
-        in_token: (_i.in_token).map(|it| Token ! [ in ](tokens_helper(_visitor, &(it).0))),
+        pub_token: Token ! [ pub ](tokens_helper(_visitor, &_i.pub_token.span)),
+        paren_token: Paren(tokens_helper(_visitor, &_i.paren_token.span)),
+        in_token: (_i.in_token).map(|it| Token ! [ in ](tokens_helper(_visitor, &it.span))),
         path: Box::new(_visitor.fold_path(*_i.path)),
     }
 }
@@ -2925,7 +2933,7 @@
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn fold_where_clause<V: Fold + ?Sized>(_visitor: &mut V, _i: WhereClause) -> WhereClause {
     WhereClause {
-        where_token: Token ! [ where ](tokens_helper(_visitor, &(_i.where_token).0)),
+        where_token: Token ! [ where ](tokens_helper(_visitor, &_i.where_token.span)),
         predicates: FoldHelper::lift(_i.predicates, |it| _visitor.fold_where_predicate(it)),
     }
 }
diff --git a/src/gen/visit.rs b/src/gen/visit.rs
index d501ac6..91563c9 100644
--- a/src/gen/visit.rs
+++ b/src/gen/visit.rs
@@ -854,7 +854,7 @@
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_abi<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Abi) {
-    tokens_helper(_visitor, &(_i.extern_token).0);
+    tokens_helper(_visitor, &_i.extern_token.span);
     if let Some(ref it) = _i.name {
         _visitor.visit_lit_str(it)
     };
@@ -865,38 +865,38 @@
     _i: &'ast AngleBracketedGenericArguments,
 ) {
     if let Some(ref it) = _i.colon2_token {
-        tokens_helper(_visitor, &(it).0)
+        tokens_helper(_visitor, &it.spans)
     };
-    tokens_helper(_visitor, &(_i.lt_token).0);
+    tokens_helper(_visitor, &_i.lt_token.spans);
     for el in Punctuated::pairs(&_i.args) {
         let it = el.value();
         _visitor.visit_generic_argument(it)
     }
-    tokens_helper(_visitor, &(_i.gt_token).0);
+    tokens_helper(_visitor, &_i.gt_token.spans);
 }
 #[cfg(feature = "full")]
 pub fn visit_arg_captured<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ArgCaptured) {
     _visitor.visit_pat(&_i.pat);
-    tokens_helper(_visitor, &(_i.colon_token).0);
+    tokens_helper(_visitor, &_i.colon_token.spans);
     _visitor.visit_type(&_i.ty);
 }
 #[cfg(feature = "full")]
 pub fn visit_arg_self<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ArgSelf) {
     if let Some(ref it) = _i.mutability {
-        tokens_helper(_visitor, &(it).0)
+        tokens_helper(_visitor, &it.span)
     };
-    tokens_helper(_visitor, &(_i.self_token).0);
+    tokens_helper(_visitor, &_i.self_token.span);
 }
 #[cfg(feature = "full")]
 pub fn visit_arg_self_ref<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ArgSelfRef) {
-    tokens_helper(_visitor, &(_i.and_token).0);
+    tokens_helper(_visitor, &_i.and_token.spans);
     if let Some(ref it) = _i.lifetime {
         _visitor.visit_lifetime(it)
     };
     if let Some(ref it) = _i.mutability {
-        tokens_helper(_visitor, &(it).0)
+        tokens_helper(_visitor, &it.span)
     };
-    tokens_helper(_visitor, &(_i.self_token).0);
+    tokens_helper(_visitor, &_i.self_token.span);
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
@@ -905,20 +905,20 @@
         _visitor.visit_attribute(it)
     }
     if let Some(ref it) = _i.leading_vert {
-        tokens_helper(_visitor, &(it).0)
+        tokens_helper(_visitor, &it.spans)
     };
     for el in Punctuated::pairs(&_i.pats) {
         let it = el.value();
         _visitor.visit_pat(it)
     }
     if let Some(ref it) = _i.guard {
-        tokens_helper(_visitor, &((it).0).0);
+        tokens_helper(_visitor, &(it).0.span);
         _visitor.visit_expr(&*(it).1);
     };
-    tokens_helper(_visitor, &(_i.fat_arrow_token).0);
+    tokens_helper(_visitor, &_i.fat_arrow_token.spans);
     _visitor.visit_expr(&*_i.body);
     if let Some(ref it) = _i.comma {
-        tokens_helper(_visitor, &(it).0)
+        tokens_helper(_visitor, &it.spans)
     };
 }
 #[cfg(any(feature = "full", feature = "derive"))]
@@ -926,15 +926,15 @@
     match *_i {
         AttrStyle::Outer => {}
         AttrStyle::Inner(ref _binding_0) => {
-            tokens_helper(_visitor, &(_binding_0).0);
+            tokens_helper(_visitor, &_binding_0.spans);
         }
     }
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_attribute<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Attribute) {
-    tokens_helper(_visitor, &(_i.pound_token).0);
+    tokens_helper(_visitor, &_i.pound_token.spans);
     _visitor.visit_attr_style(&_i.style);
-    tokens_helper(_visitor, &(_i.bracket_token).0);
+    tokens_helper(_visitor, &_i.bracket_token.span);
     _visitor.visit_path(&_i.path);
     skip!(_i.tts);
     skip!(_i.is_sugared_doc);
@@ -943,7 +943,7 @@
 pub fn visit_bare_fn_arg<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast BareFnArg) {
     if let Some(ref it) = _i.name {
         _visitor.visit_bare_fn_arg_name(&(it).0);
-        tokens_helper(_visitor, &((it).1).0);
+        tokens_helper(_visitor, &(it).1.spans);
     };
     _visitor.visit_type(&_i.ty);
 }
@@ -957,7 +957,7 @@
             _visitor.visit_ident(_binding_0);
         }
         BareFnArgName::Wild(ref _binding_0) => {
-            tokens_helper(_visitor, &(_binding_0).0);
+            tokens_helper(_visitor, &_binding_0.spans);
         }
     }
 }
@@ -965,101 +965,101 @@
 pub fn visit_bin_op<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast BinOp) {
     match *_i {
         BinOp::Add(ref _binding_0) => {
-            tokens_helper(_visitor, &(_binding_0).0);
+            tokens_helper(_visitor, &_binding_0.spans);
         }
         BinOp::Sub(ref _binding_0) => {
-            tokens_helper(_visitor, &(_binding_0).0);
+            tokens_helper(_visitor, &_binding_0.spans);
         }
         BinOp::Mul(ref _binding_0) => {
-            tokens_helper(_visitor, &(_binding_0).0);
+            tokens_helper(_visitor, &_binding_0.spans);
         }
         BinOp::Div(ref _binding_0) => {
-            tokens_helper(_visitor, &(_binding_0).0);
+            tokens_helper(_visitor, &_binding_0.spans);
         }
         BinOp::Rem(ref _binding_0) => {
-            tokens_helper(_visitor, &(_binding_0).0);
+            tokens_helper(_visitor, &_binding_0.spans);
         }
         BinOp::And(ref _binding_0) => {
-            tokens_helper(_visitor, &(_binding_0).0);
+            tokens_helper(_visitor, &_binding_0.spans);
         }
         BinOp::Or(ref _binding_0) => {
-            tokens_helper(_visitor, &(_binding_0).0);
+            tokens_helper(_visitor, &_binding_0.spans);
         }
         BinOp::BitXor(ref _binding_0) => {
-            tokens_helper(_visitor, &(_binding_0).0);
+            tokens_helper(_visitor, &_binding_0.spans);
         }
         BinOp::BitAnd(ref _binding_0) => {
-            tokens_helper(_visitor, &(_binding_0).0);
+            tokens_helper(_visitor, &_binding_0.spans);
         }
         BinOp::BitOr(ref _binding_0) => {
-            tokens_helper(_visitor, &(_binding_0).0);
+            tokens_helper(_visitor, &_binding_0.spans);
         }
         BinOp::Shl(ref _binding_0) => {
-            tokens_helper(_visitor, &(_binding_0).0);
+            tokens_helper(_visitor, &_binding_0.spans);
         }
         BinOp::Shr(ref _binding_0) => {
-            tokens_helper(_visitor, &(_binding_0).0);
+            tokens_helper(_visitor, &_binding_0.spans);
         }
         BinOp::Eq(ref _binding_0) => {
-            tokens_helper(_visitor, &(_binding_0).0);
+            tokens_helper(_visitor, &_binding_0.spans);
         }
         BinOp::Lt(ref _binding_0) => {
-            tokens_helper(_visitor, &(_binding_0).0);
+            tokens_helper(_visitor, &_binding_0.spans);
         }
         BinOp::Le(ref _binding_0) => {
-            tokens_helper(_visitor, &(_binding_0).0);
+            tokens_helper(_visitor, &_binding_0.spans);
         }
         BinOp::Ne(ref _binding_0) => {
-            tokens_helper(_visitor, &(_binding_0).0);
+            tokens_helper(_visitor, &_binding_0.spans);
         }
         BinOp::Ge(ref _binding_0) => {
-            tokens_helper(_visitor, &(_binding_0).0);
+            tokens_helper(_visitor, &_binding_0.spans);
         }
         BinOp::Gt(ref _binding_0) => {
-            tokens_helper(_visitor, &(_binding_0).0);
+            tokens_helper(_visitor, &_binding_0.spans);
         }
         BinOp::AddEq(ref _binding_0) => {
-            tokens_helper(_visitor, &(_binding_0).0);
+            tokens_helper(_visitor, &_binding_0.spans);
         }
         BinOp::SubEq(ref _binding_0) => {
-            tokens_helper(_visitor, &(_binding_0).0);
+            tokens_helper(_visitor, &_binding_0.spans);
         }
         BinOp::MulEq(ref _binding_0) => {
-            tokens_helper(_visitor, &(_binding_0).0);
+            tokens_helper(_visitor, &_binding_0.spans);
         }
         BinOp::DivEq(ref _binding_0) => {
-            tokens_helper(_visitor, &(_binding_0).0);
+            tokens_helper(_visitor, &_binding_0.spans);
         }
         BinOp::RemEq(ref _binding_0) => {
-            tokens_helper(_visitor, &(_binding_0).0);
+            tokens_helper(_visitor, &_binding_0.spans);
         }
         BinOp::BitXorEq(ref _binding_0) => {
-            tokens_helper(_visitor, &(_binding_0).0);
+            tokens_helper(_visitor, &_binding_0.spans);
         }
         BinOp::BitAndEq(ref _binding_0) => {
-            tokens_helper(_visitor, &(_binding_0).0);
+            tokens_helper(_visitor, &_binding_0.spans);
         }
         BinOp::BitOrEq(ref _binding_0) => {
-            tokens_helper(_visitor, &(_binding_0).0);
+            tokens_helper(_visitor, &_binding_0.spans);
         }
         BinOp::ShlEq(ref _binding_0) => {
-            tokens_helper(_visitor, &(_binding_0).0);
+            tokens_helper(_visitor, &_binding_0.spans);
         }
         BinOp::ShrEq(ref _binding_0) => {
-            tokens_helper(_visitor, &(_binding_0).0);
+            tokens_helper(_visitor, &_binding_0.spans);
         }
     }
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_binding<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Binding) {
     _visitor.visit_ident(&_i.ident);
-    tokens_helper(_visitor, &(_i.eq_token).0);
+    tokens_helper(_visitor, &_i.eq_token.spans);
     _visitor.visit_type(&_i.ty);
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn visit_block<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Block) {
-    tokens_helper(_visitor, &(_i.brace_token).0);
+    tokens_helper(_visitor, &_i.brace_token.span);
     for it in &_i.stmts {
         _visitor.visit_stmt(it)
     }
@@ -1069,25 +1069,25 @@
     _visitor: &mut V,
     _i: &'ast BoundLifetimes,
 ) {
-    tokens_helper(_visitor, &(_i.for_token).0);
-    tokens_helper(_visitor, &(_i.lt_token).0);
+    tokens_helper(_visitor, &_i.for_token.span);
+    tokens_helper(_visitor, &_i.lt_token.spans);
     for el in Punctuated::pairs(&_i.lifetimes) {
         let it = el.value();
         _visitor.visit_lifetime_def(it)
     }
-    tokens_helper(_visitor, &(_i.gt_token).0);
+    tokens_helper(_visitor, &_i.gt_token.spans);
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_const_param<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ConstParam) {
     for it in &_i.attrs {
         _visitor.visit_attribute(it)
     }
-    tokens_helper(_visitor, &(_i.const_token).0);
+    tokens_helper(_visitor, &_i.const_token.span);
     _visitor.visit_ident(&_i.ident);
-    tokens_helper(_visitor, &(_i.colon_token).0);
+    tokens_helper(_visitor, &_i.colon_token.spans);
     _visitor.visit_type(&_i.ty);
     if let Some(ref it) = _i.eq_token {
-        tokens_helper(_visitor, &(it).0)
+        tokens_helper(_visitor, &it.spans)
     };
     if let Some(ref it) = _i.default {
         _visitor.visit_expr(it)
@@ -1109,8 +1109,8 @@
 }
 #[cfg(feature = "derive")]
 pub fn visit_data_enum<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast DataEnum) {
-    tokens_helper(_visitor, &(_i.enum_token).0);
-    tokens_helper(_visitor, &(_i.brace_token).0);
+    tokens_helper(_visitor, &_i.enum_token.span);
+    tokens_helper(_visitor, &_i.brace_token.span);
     for el in Punctuated::pairs(&_i.variants) {
         let it = el.value();
         _visitor.visit_variant(it)
@@ -1118,15 +1118,15 @@
 }
 #[cfg(feature = "derive")]
 pub fn visit_data_struct<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast DataStruct) {
-    tokens_helper(_visitor, &(_i.struct_token).0);
+    tokens_helper(_visitor, &_i.struct_token.span);
     _visitor.visit_fields(&_i.fields);
     if let Some(ref it) = _i.semi_token {
-        tokens_helper(_visitor, &(it).0)
+        tokens_helper(_visitor, &it.spans)
     };
 }
 #[cfg(feature = "derive")]
 pub fn visit_data_union<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast DataUnion) {
-    tokens_helper(_visitor, &(_i.union_token).0);
+    tokens_helper(_visitor, &_i.union_token.span);
     _visitor.visit_fields_named(&_i.fields);
 }
 #[cfg(feature = "derive")]
@@ -1270,7 +1270,7 @@
     for it in &_i.attrs {
         _visitor.visit_attribute(it)
     }
-    tokens_helper(_visitor, &(_i.bracket_token).0);
+    tokens_helper(_visitor, &_i.bracket_token.span);
     for el in Punctuated::pairs(&_i.elems) {
         let it = el.value();
         _visitor.visit_expr(it)
@@ -1283,7 +1283,7 @@
         _visitor.visit_attribute(it)
     }
     _visitor.visit_expr(&*_i.left);
-    tokens_helper(_visitor, &(_i.eq_token).0);
+    tokens_helper(_visitor, &_i.eq_token.spans);
     _visitor.visit_expr(&*_i.right);
 }
 #[cfg(feature = "full")]
@@ -1322,7 +1322,7 @@
     for it in &_i.attrs {
         _visitor.visit_attribute(it)
     }
-    tokens_helper(_visitor, &(_i.box_token).0);
+    tokens_helper(_visitor, &_i.box_token.span);
     _visitor.visit_expr(&*_i.expr);
 }
 #[cfg(feature = "full")]
@@ -1331,7 +1331,7 @@
     for it in &_i.attrs {
         _visitor.visit_attribute(it)
     }
-    tokens_helper(_visitor, &(_i.break_token).0);
+    tokens_helper(_visitor, &_i.break_token.span);
     if let Some(ref it) = _i.label {
         _visitor.visit_lifetime(it)
     };
@@ -1345,7 +1345,7 @@
         _visitor.visit_attribute(it)
     }
     _visitor.visit_expr(&*_i.func);
-    tokens_helper(_visitor, &(_i.paren_token).0);
+    tokens_helper(_visitor, &_i.paren_token.span);
     for el in Punctuated::pairs(&_i.args) {
         let it = el.value();
         _visitor.visit_expr(it)
@@ -1357,7 +1357,7 @@
         _visitor.visit_attribute(it)
     }
     _visitor.visit_expr(&*_i.expr);
-    tokens_helper(_visitor, &(_i.as_token).0);
+    tokens_helper(_visitor, &_i.as_token.span);
     _visitor.visit_type(&*_i.ty);
 }
 #[cfg(feature = "full")]
@@ -1366,8 +1366,8 @@
     for it in &_i.attrs {
         _visitor.visit_attribute(it)
     }
-    tokens_helper(_visitor, &(_i.do_token).0);
-    tokens_helper(_visitor, &(_i.catch_token).0);
+    tokens_helper(_visitor, &_i.do_token.span);
+    tokens_helper(_visitor, &_i.catch_token.span);
     _visitor.visit_block(&_i.block);
 }
 #[cfg(feature = "full")]
@@ -1377,17 +1377,17 @@
         _visitor.visit_attribute(it)
     }
     if let Some(ref it) = _i.movability {
-        tokens_helper(_visitor, &(it).0)
+        tokens_helper(_visitor, &it.span)
     };
     if let Some(ref it) = _i.capture {
-        tokens_helper(_visitor, &(it).0)
+        tokens_helper(_visitor, &it.span)
     };
-    tokens_helper(_visitor, &(_i.or1_token).0);
+    tokens_helper(_visitor, &_i.or1_token.spans);
     for el in Punctuated::pairs(&_i.inputs) {
         let it = el.value();
         _visitor.visit_fn_arg(it)
     }
-    tokens_helper(_visitor, &(_i.or2_token).0);
+    tokens_helper(_visitor, &_i.or2_token.spans);
     _visitor.visit_return_type(&_i.output);
     _visitor.visit_expr(&*_i.body);
 }
@@ -1400,7 +1400,7 @@
     for it in &_i.attrs {
         _visitor.visit_attribute(it)
     }
-    tokens_helper(_visitor, &(_i.continue_token).0);
+    tokens_helper(_visitor, &_i.continue_token.span);
     if let Some(ref it) = _i.label {
         _visitor.visit_lifetime(it)
     };
@@ -1411,7 +1411,7 @@
         _visitor.visit_attribute(it)
     }
     _visitor.visit_expr(&*_i.base);
-    tokens_helper(_visitor, &(_i.dot_token).0);
+    tokens_helper(_visitor, &_i.dot_token.spans);
     _visitor.visit_member(&_i.member);
 }
 #[cfg(feature = "full")]
@@ -1423,9 +1423,9 @@
     if let Some(ref it) = _i.label {
         _visitor.visit_label(it)
     };
-    tokens_helper(_visitor, &(_i.for_token).0);
+    tokens_helper(_visitor, &_i.for_token.span);
     _visitor.visit_pat(&*_i.pat);
-    tokens_helper(_visitor, &(_i.in_token).0);
+    tokens_helper(_visitor, &_i.in_token.span);
     _visitor.visit_expr(&*_i.expr);
     _visitor.visit_block(&_i.body);
 }
@@ -1435,7 +1435,7 @@
     for it in &_i.attrs {
         _visitor.visit_attribute(it)
     }
-    tokens_helper(_visitor, &(_i.group_token).0);
+    tokens_helper(_visitor, &_i.group_token.span);
     _visitor.visit_expr(&*_i.expr);
 }
 #[cfg(feature = "full")]
@@ -1444,11 +1444,11 @@
     for it in &_i.attrs {
         _visitor.visit_attribute(it)
     }
-    tokens_helper(_visitor, &(_i.if_token).0);
+    tokens_helper(_visitor, &_i.if_token.span);
     _visitor.visit_expr(&*_i.cond);
     _visitor.visit_block(&_i.then_branch);
     if let Some(ref it) = _i.else_branch {
-        tokens_helper(_visitor, &((it).0).0);
+        tokens_helper(_visitor, &(it).0.span);
         _visitor.visit_expr(&*(it).1);
     };
 }
@@ -1458,17 +1458,17 @@
     for it in &_i.attrs {
         _visitor.visit_attribute(it)
     }
-    tokens_helper(_visitor, &(_i.if_token).0);
-    tokens_helper(_visitor, &(_i.let_token).0);
+    tokens_helper(_visitor, &_i.if_token.span);
+    tokens_helper(_visitor, &_i.let_token.span);
     for el in Punctuated::pairs(&_i.pats) {
         let it = el.value();
         _visitor.visit_pat(it)
     }
-    tokens_helper(_visitor, &(_i.eq_token).0);
+    tokens_helper(_visitor, &_i.eq_token.spans);
     _visitor.visit_expr(&*_i.expr);
     _visitor.visit_block(&_i.then_branch);
     if let Some(ref it) = _i.else_branch {
-        tokens_helper(_visitor, &((it).0).0);
+        tokens_helper(_visitor, &(it).0.span);
         _visitor.visit_expr(&*(it).1);
     };
 }
@@ -1479,7 +1479,7 @@
         _visitor.visit_attribute(it)
     }
     _visitor.visit_expr(&*_i.place);
-    tokens_helper(_visitor, &(_i.arrow_token).0);
+    tokens_helper(_visitor, &_i.arrow_token.spans);
     _visitor.visit_expr(&*_i.value);
 }
 #[cfg(any(feature = "full", feature = "derive"))]
@@ -1488,7 +1488,7 @@
         _visitor.visit_attribute(it)
     }
     _visitor.visit_expr(&*_i.expr);
-    tokens_helper(_visitor, &(_i.bracket_token).0);
+    tokens_helper(_visitor, &_i.bracket_token.span);
     _visitor.visit_expr(&*_i.index);
 }
 #[cfg(any(feature = "full", feature = "derive"))]
@@ -1507,7 +1507,7 @@
     if let Some(ref it) = _i.label {
         _visitor.visit_label(it)
     };
-    tokens_helper(_visitor, &(_i.loop_token).0);
+    tokens_helper(_visitor, &_i.loop_token.span);
     _visitor.visit_block(&_i.body);
 }
 #[cfg(feature = "full")]
@@ -1524,9 +1524,9 @@
     for it in &_i.attrs {
         _visitor.visit_attribute(it)
     }
-    tokens_helper(_visitor, &(_i.match_token).0);
+    tokens_helper(_visitor, &_i.match_token.span);
     _visitor.visit_expr(&*_i.expr);
-    tokens_helper(_visitor, &(_i.brace_token).0);
+    tokens_helper(_visitor, &_i.brace_token.span);
     for it in &_i.arms {
         _visitor.visit_arm(it)
     }
@@ -1541,12 +1541,12 @@
         _visitor.visit_attribute(it)
     }
     _visitor.visit_expr(&*_i.receiver);
-    tokens_helper(_visitor, &(_i.dot_token).0);
+    tokens_helper(_visitor, &_i.dot_token.spans);
     _visitor.visit_ident(&_i.method);
     if let Some(ref it) = _i.turbofish {
         _visitor.visit_method_turbofish(it)
     };
-    tokens_helper(_visitor, &(_i.paren_token).0);
+    tokens_helper(_visitor, &_i.paren_token.span);
     for el in Punctuated::pairs(&_i.args) {
         let it = el.value();
         _visitor.visit_expr(it)
@@ -1557,7 +1557,7 @@
     for it in &_i.attrs {
         _visitor.visit_attribute(it)
     }
-    tokens_helper(_visitor, &(_i.paren_token).0);
+    tokens_helper(_visitor, &_i.paren_token.span);
     _visitor.visit_expr(&*_i.expr);
 }
 #[cfg(any(feature = "full", feature = "derive"))]
@@ -1593,9 +1593,9 @@
     for it in &_i.attrs {
         _visitor.visit_attribute(it)
     }
-    tokens_helper(_visitor, &(_i.and_token).0);
+    tokens_helper(_visitor, &_i.and_token.spans);
     if let Some(ref it) = _i.mutability {
-        tokens_helper(_visitor, &(it).0)
+        tokens_helper(_visitor, &it.span)
     };
     _visitor.visit_expr(&*_i.expr);
 }
@@ -1605,9 +1605,9 @@
     for it in &_i.attrs {
         _visitor.visit_attribute(it)
     }
-    tokens_helper(_visitor, &(_i.bracket_token).0);
+    tokens_helper(_visitor, &_i.bracket_token.span);
     _visitor.visit_expr(&*_i.expr);
-    tokens_helper(_visitor, &(_i.semi_token).0);
+    tokens_helper(_visitor, &_i.semi_token.spans);
     _visitor.visit_expr(&*_i.len);
 }
 #[cfg(feature = "full")]
@@ -1616,7 +1616,7 @@
     for it in &_i.attrs {
         _visitor.visit_attribute(it)
     }
-    tokens_helper(_visitor, &(_i.return_token).0);
+    tokens_helper(_visitor, &_i.return_token.span);
     if let Some(ref it) = _i.expr {
         _visitor.visit_expr(&**it)
     };
@@ -1628,13 +1628,13 @@
         _visitor.visit_attribute(it)
     }
     _visitor.visit_path(&_i.path);
-    tokens_helper(_visitor, &(_i.brace_token).0);
+    tokens_helper(_visitor, &_i.brace_token.span);
     for el in Punctuated::pairs(&_i.fields) {
         let it = el.value();
         _visitor.visit_field_value(it)
     }
     if let Some(ref it) = _i.dot2_token {
-        tokens_helper(_visitor, &(it).0)
+        tokens_helper(_visitor, &it.spans)
     };
     if let Some(ref it) = _i.rest {
         _visitor.visit_expr(&**it)
@@ -1647,7 +1647,7 @@
         _visitor.visit_attribute(it)
     }
     _visitor.visit_expr(&*_i.expr);
-    tokens_helper(_visitor, &(_i.question_token).0);
+    tokens_helper(_visitor, &_i.question_token.spans);
 }
 #[cfg(feature = "full")]
 #[cfg(any(feature = "full", feature = "derive"))]
@@ -1655,7 +1655,7 @@
     for it in &_i.attrs {
         _visitor.visit_attribute(it)
     }
-    tokens_helper(_visitor, &(_i.paren_token).0);
+    tokens_helper(_visitor, &_i.paren_token.span);
     for el in Punctuated::pairs(&_i.elems) {
         let it = el.value();
         _visitor.visit_expr(it)
@@ -1668,7 +1668,7 @@
         _visitor.visit_attribute(it)
     }
     _visitor.visit_expr(&*_i.expr);
-    tokens_helper(_visitor, &(_i.colon_token).0);
+    tokens_helper(_visitor, &_i.colon_token.spans);
     _visitor.visit_type(&*_i.ty);
 }
 #[cfg(any(feature = "full", feature = "derive"))]
@@ -1685,7 +1685,7 @@
     for it in &_i.attrs {
         _visitor.visit_attribute(it)
     }
-    tokens_helper(_visitor, &(_i.unsafe_token).0);
+    tokens_helper(_visitor, &_i.unsafe_token.span);
     _visitor.visit_block(&_i.block);
 }
 #[cfg(any(feature = "full", feature = "derive"))]
@@ -1704,7 +1704,7 @@
     if let Some(ref it) = _i.label {
         _visitor.visit_label(it)
     };
-    tokens_helper(_visitor, &(_i.while_token).0);
+    tokens_helper(_visitor, &_i.while_token.span);
     _visitor.visit_expr(&*_i.cond);
     _visitor.visit_block(&_i.body);
 }
@@ -1720,13 +1720,13 @@
     if let Some(ref it) = _i.label {
         _visitor.visit_label(it)
     };
-    tokens_helper(_visitor, &(_i.while_token).0);
-    tokens_helper(_visitor, &(_i.let_token).0);
+    tokens_helper(_visitor, &_i.while_token.span);
+    tokens_helper(_visitor, &_i.let_token.span);
     for el in Punctuated::pairs(&_i.pats) {
         let it = el.value();
         _visitor.visit_pat(it)
     }
-    tokens_helper(_visitor, &(_i.eq_token).0);
+    tokens_helper(_visitor, &_i.eq_token.spans);
     _visitor.visit_expr(&*_i.expr);
     _visitor.visit_block(&_i.body);
 }
@@ -1736,7 +1736,7 @@
     for it in &_i.attrs {
         _visitor.visit_attribute(it)
     }
-    tokens_helper(_visitor, &(_i.yield_token).0);
+    tokens_helper(_visitor, &_i.yield_token.span);
     if let Some(ref it) = _i.expr {
         _visitor.visit_expr(&**it)
     };
@@ -1751,7 +1751,7 @@
         _visitor.visit_ident(it)
     };
     if let Some(ref it) = _i.colon_token {
-        tokens_helper(_visitor, &(it).0)
+        tokens_helper(_visitor, &it.spans)
     };
     _visitor.visit_type(&_i.ty);
 }
@@ -1763,7 +1763,7 @@
     }
     _visitor.visit_member(&_i.member);
     if let Some(ref it) = _i.colon_token {
-        tokens_helper(_visitor, &(it).0)
+        tokens_helper(_visitor, &it.spans)
     };
     _visitor.visit_pat(&*_i.pat);
 }
@@ -1775,7 +1775,7 @@
     }
     _visitor.visit_member(&_i.member);
     if let Some(ref it) = _i.colon_token {
-        tokens_helper(_visitor, &(it).0)
+        tokens_helper(_visitor, &it.spans)
     };
     _visitor.visit_expr(&_i.expr);
 }
@@ -1793,7 +1793,7 @@
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_fields_named<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast FieldsNamed) {
-    tokens_helper(_visitor, &(_i.brace_token).0);
+    tokens_helper(_visitor, &_i.brace_token.span);
     for el in Punctuated::pairs(&_i.named) {
         let it = el.value();
         _visitor.visit_field(it)
@@ -1804,7 +1804,7 @@
     _visitor: &mut V,
     _i: &'ast FieldsUnnamed,
 ) {
-    tokens_helper(_visitor, &(_i.paren_token).0);
+    tokens_helper(_visitor, &_i.paren_token.span);
     for el in Punctuated::pairs(&_i.unnamed) {
         let it = el.value();
         _visitor.visit_field(it)
@@ -1842,15 +1842,15 @@
 }
 #[cfg(feature = "full")]
 pub fn visit_fn_decl<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast FnDecl) {
-    tokens_helper(_visitor, &(_i.fn_token).0);
+    tokens_helper(_visitor, &_i.fn_token.span);
     _visitor.visit_generics(&_i.generics);
-    tokens_helper(_visitor, &(_i.paren_token).0);
+    tokens_helper(_visitor, &_i.paren_token.span);
     for el in Punctuated::pairs(&_i.inputs) {
         let it = el.value();
         _visitor.visit_fn_arg(it)
     }
     if let Some(ref it) = _i.variadic {
-        tokens_helper(_visitor, &(it).0)
+        tokens_helper(_visitor, &it.spans)
     };
     _visitor.visit_return_type(&_i.output);
 }
@@ -1882,7 +1882,7 @@
     _visitor.visit_visibility(&_i.vis);
     _visitor.visit_ident(&_i.ident);
     _visitor.visit_fn_decl(&*_i.decl);
-    tokens_helper(_visitor, &(_i.semi_token).0);
+    tokens_helper(_visitor, &_i.semi_token.spans);
 }
 #[cfg(feature = "full")]
 pub fn visit_foreign_item_static<'ast, V: Visit<'ast> + ?Sized>(
@@ -1893,14 +1893,14 @@
         _visitor.visit_attribute(it)
     }
     _visitor.visit_visibility(&_i.vis);
-    tokens_helper(_visitor, &(_i.static_token).0);
+    tokens_helper(_visitor, &_i.static_token.span);
     if let Some(ref it) = _i.mutability {
-        tokens_helper(_visitor, &(it).0)
+        tokens_helper(_visitor, &it.span)
     };
     _visitor.visit_ident(&_i.ident);
-    tokens_helper(_visitor, &(_i.colon_token).0);
+    tokens_helper(_visitor, &_i.colon_token.spans);
     _visitor.visit_type(&*_i.ty);
-    tokens_helper(_visitor, &(_i.semi_token).0);
+    tokens_helper(_visitor, &_i.semi_token.spans);
 }
 #[cfg(feature = "full")]
 pub fn visit_foreign_item_type<'ast, V: Visit<'ast> + ?Sized>(
@@ -1911,9 +1911,9 @@
         _visitor.visit_attribute(it)
     }
     _visitor.visit_visibility(&_i.vis);
-    tokens_helper(_visitor, &(_i.type_token).0);
+    tokens_helper(_visitor, &_i.type_token.span);
     _visitor.visit_ident(&_i.ident);
-    tokens_helper(_visitor, &(_i.semi_token).0);
+    tokens_helper(_visitor, &_i.semi_token.spans);
 }
 #[cfg(feature = "full")]
 pub fn visit_foreign_item_verbatim<'ast, V: Visit<'ast> + ?Sized>(
@@ -1977,14 +1977,14 @@
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_generics<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Generics) {
     if let Some(ref it) = _i.lt_token {
-        tokens_helper(_visitor, &(it).0)
+        tokens_helper(_visitor, &it.spans)
     };
     for el in Punctuated::pairs(&_i.params) {
         let it = el.value();
         _visitor.visit_generic_param(it)
     }
     if let Some(ref it) = _i.gt_token {
-        tokens_helper(_visitor, &(it).0)
+        tokens_helper(_visitor, &it.spans)
     };
     if let Some(ref it) = _i.where_clause {
         _visitor.visit_where_clause(it)
@@ -2021,15 +2021,15 @@
     }
     _visitor.visit_visibility(&_i.vis);
     if let Some(ref it) = _i.defaultness {
-        tokens_helper(_visitor, &(it).0)
+        tokens_helper(_visitor, &it.span)
     };
-    tokens_helper(_visitor, &(_i.const_token).0);
+    tokens_helper(_visitor, &_i.const_token.span);
     _visitor.visit_ident(&_i.ident);
-    tokens_helper(_visitor, &(_i.colon_token).0);
+    tokens_helper(_visitor, &_i.colon_token.spans);
     _visitor.visit_type(&_i.ty);
-    tokens_helper(_visitor, &(_i.eq_token).0);
+    tokens_helper(_visitor, &_i.eq_token.spans);
     _visitor.visit_expr(&_i.expr);
-    tokens_helper(_visitor, &(_i.semi_token).0);
+    tokens_helper(_visitor, &_i.semi_token.spans);
 }
 #[cfg(feature = "full")]
 pub fn visit_impl_item_macro<'ast, V: Visit<'ast> + ?Sized>(
@@ -2041,7 +2041,7 @@
     }
     _visitor.visit_macro(&_i.mac);
     if let Some(ref it) = _i.semi_token {
-        tokens_helper(_visitor, &(it).0)
+        tokens_helper(_visitor, &it.spans)
     };
 }
 #[cfg(feature = "full")]
@@ -2054,7 +2054,7 @@
     }
     _visitor.visit_visibility(&_i.vis);
     if let Some(ref it) = _i.defaultness {
-        tokens_helper(_visitor, &(it).0)
+        tokens_helper(_visitor, &it.span)
     };
     _visitor.visit_method_sig(&_i.sig);
     _visitor.visit_block(&_i.block);
@@ -2069,14 +2069,14 @@
     }
     _visitor.visit_visibility(&_i.vis);
     if let Some(ref it) = _i.defaultness {
-        tokens_helper(_visitor, &(it).0)
+        tokens_helper(_visitor, &it.span)
     };
-    tokens_helper(_visitor, &(_i.type_token).0);
+    tokens_helper(_visitor, &_i.type_token.span);
     _visitor.visit_ident(&_i.ident);
     _visitor.visit_generics(&_i.generics);
-    tokens_helper(_visitor, &(_i.eq_token).0);
+    tokens_helper(_visitor, &_i.eq_token.spans);
     _visitor.visit_type(&_i.ty);
-    tokens_helper(_visitor, &(_i.semi_token).0);
+    tokens_helper(_visitor, &_i.semi_token.spans);
 }
 #[cfg(feature = "full")]
 pub fn visit_impl_item_verbatim<'ast, V: Visit<'ast> + ?Sized>(
@@ -2149,13 +2149,13 @@
         _visitor.visit_attribute(it)
     }
     _visitor.visit_visibility(&_i.vis);
-    tokens_helper(_visitor, &(_i.const_token).0);
+    tokens_helper(_visitor, &_i.const_token.span);
     _visitor.visit_ident(&_i.ident);
-    tokens_helper(_visitor, &(_i.colon_token).0);
+    tokens_helper(_visitor, &_i.colon_token.spans);
     _visitor.visit_type(&*_i.ty);
-    tokens_helper(_visitor, &(_i.eq_token).0);
+    tokens_helper(_visitor, &_i.eq_token.spans);
     _visitor.visit_expr(&*_i.expr);
-    tokens_helper(_visitor, &(_i.semi_token).0);
+    tokens_helper(_visitor, &_i.semi_token.spans);
 }
 #[cfg(feature = "full")]
 pub fn visit_item_enum<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ItemEnum) {
@@ -2163,10 +2163,10 @@
         _visitor.visit_attribute(it)
     }
     _visitor.visit_visibility(&_i.vis);
-    tokens_helper(_visitor, &(_i.enum_token).0);
+    tokens_helper(_visitor, &_i.enum_token.span);
     _visitor.visit_ident(&_i.ident);
     _visitor.visit_generics(&_i.generics);
-    tokens_helper(_visitor, &(_i.brace_token).0);
+    tokens_helper(_visitor, &_i.brace_token.span);
     for el in Punctuated::pairs(&_i.variants) {
         let it = el.value();
         _visitor.visit_variant(it)
@@ -2181,14 +2181,14 @@
         _visitor.visit_attribute(it)
     }
     _visitor.visit_visibility(&_i.vis);
-    tokens_helper(_visitor, &(_i.extern_token).0);
-    tokens_helper(_visitor, &(_i.crate_token).0);
+    tokens_helper(_visitor, &_i.extern_token.span);
+    tokens_helper(_visitor, &_i.crate_token.span);
     _visitor.visit_ident(&_i.ident);
     if let Some(ref it) = _i.rename {
-        tokens_helper(_visitor, &((it).0).0);
+        tokens_helper(_visitor, &(it).0.span);
         _visitor.visit_ident(&(it).1);
     };
-    tokens_helper(_visitor, &(_i.semi_token).0);
+    tokens_helper(_visitor, &_i.semi_token.spans);
 }
 #[cfg(feature = "full")]
 pub fn visit_item_fn<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ItemFn) {
@@ -2197,10 +2197,10 @@
     }
     _visitor.visit_visibility(&_i.vis);
     if let Some(ref it) = _i.constness {
-        tokens_helper(_visitor, &(it).0)
+        tokens_helper(_visitor, &it.span)
     };
     if let Some(ref it) = _i.unsafety {
-        tokens_helper(_visitor, &(it).0)
+        tokens_helper(_visitor, &it.span)
     };
     if let Some(ref it) = _i.abi {
         _visitor.visit_abi(it)
@@ -2218,7 +2218,7 @@
         _visitor.visit_attribute(it)
     }
     _visitor.visit_abi(&_i.abi);
-    tokens_helper(_visitor, &(_i.brace_token).0);
+    tokens_helper(_visitor, &_i.brace_token.span);
     for it in &_i.items {
         _visitor.visit_foreign_item(it)
     }
@@ -2229,22 +2229,22 @@
         _visitor.visit_attribute(it)
     }
     if let Some(ref it) = _i.defaultness {
-        tokens_helper(_visitor, &(it).0)
+        tokens_helper(_visitor, &it.span)
     };
     if let Some(ref it) = _i.unsafety {
-        tokens_helper(_visitor, &(it).0)
+        tokens_helper(_visitor, &it.span)
     };
-    tokens_helper(_visitor, &(_i.impl_token).0);
+    tokens_helper(_visitor, &_i.impl_token.span);
     _visitor.visit_generics(&_i.generics);
     if let Some(ref it) = _i.trait_ {
         if let Some(ref it) = (it).0 {
-            tokens_helper(_visitor, &(it).0)
+            tokens_helper(_visitor, &it.spans)
         };
         _visitor.visit_path(&(it).1);
-        tokens_helper(_visitor, &((it).2).0);
+        tokens_helper(_visitor, &(it).2.span);
     };
     _visitor.visit_type(&*_i.self_ty);
-    tokens_helper(_visitor, &(_i.brace_token).0);
+    tokens_helper(_visitor, &_i.brace_token.span);
     for it in &_i.items {
         _visitor.visit_impl_item(it)
     }
@@ -2259,7 +2259,7 @@
     };
     _visitor.visit_macro(&_i.mac);
     if let Some(ref it) = _i.semi_token {
-        tokens_helper(_visitor, &(it).0)
+        tokens_helper(_visitor, &it.spans)
     };
 }
 #[cfg(feature = "full")]
@@ -2268,11 +2268,11 @@
         _visitor.visit_attribute(it)
     }
     _visitor.visit_visibility(&_i.vis);
-    tokens_helper(_visitor, &(_i.macro_token).0);
+    tokens_helper(_visitor, &_i.macro_token.span);
     _visitor.visit_ident(&_i.ident);
-    tokens_helper(_visitor, &(_i.paren_token).0);
+    tokens_helper(_visitor, &_i.paren_token.span);
     skip!(_i.args);
-    tokens_helper(_visitor, &(_i.brace_token).0);
+    tokens_helper(_visitor, &_i.brace_token.span);
     skip!(_i.body);
 }
 #[cfg(feature = "full")]
@@ -2281,16 +2281,16 @@
         _visitor.visit_attribute(it)
     }
     _visitor.visit_visibility(&_i.vis);
-    tokens_helper(_visitor, &(_i.mod_token).0);
+    tokens_helper(_visitor, &_i.mod_token.span);
     _visitor.visit_ident(&_i.ident);
     if let Some(ref it) = _i.content {
-        tokens_helper(_visitor, &((it).0).0);
+        tokens_helper(_visitor, &(it).0.span);
         for it in &(it).1 {
             _visitor.visit_item(it)
         }
     };
     if let Some(ref it) = _i.semi {
-        tokens_helper(_visitor, &(it).0)
+        tokens_helper(_visitor, &it.spans)
     };
 }
 #[cfg(feature = "full")]
@@ -2299,16 +2299,16 @@
         _visitor.visit_attribute(it)
     }
     _visitor.visit_visibility(&_i.vis);
-    tokens_helper(_visitor, &(_i.static_token).0);
+    tokens_helper(_visitor, &_i.static_token.span);
     if let Some(ref it) = _i.mutability {
-        tokens_helper(_visitor, &(it).0)
+        tokens_helper(_visitor, &it.span)
     };
     _visitor.visit_ident(&_i.ident);
-    tokens_helper(_visitor, &(_i.colon_token).0);
+    tokens_helper(_visitor, &_i.colon_token.spans);
     _visitor.visit_type(&*_i.ty);
-    tokens_helper(_visitor, &(_i.eq_token).0);
+    tokens_helper(_visitor, &_i.eq_token.spans);
     _visitor.visit_expr(&*_i.expr);
-    tokens_helper(_visitor, &(_i.semi_token).0);
+    tokens_helper(_visitor, &_i.semi_token.spans);
 }
 #[cfg(feature = "full")]
 pub fn visit_item_struct<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ItemStruct) {
@@ -2316,12 +2316,12 @@
         _visitor.visit_attribute(it)
     }
     _visitor.visit_visibility(&_i.vis);
-    tokens_helper(_visitor, &(_i.struct_token).0);
+    tokens_helper(_visitor, &_i.struct_token.span);
     _visitor.visit_ident(&_i.ident);
     _visitor.visit_generics(&_i.generics);
     _visitor.visit_fields(&_i.fields);
     if let Some(ref it) = _i.semi_token {
-        tokens_helper(_visitor, &(it).0)
+        tokens_helper(_visitor, &it.spans)
     };
 }
 #[cfg(feature = "full")]
@@ -2331,22 +2331,22 @@
     }
     _visitor.visit_visibility(&_i.vis);
     if let Some(ref it) = _i.unsafety {
-        tokens_helper(_visitor, &(it).0)
+        tokens_helper(_visitor, &it.span)
     };
     if let Some(ref it) = _i.auto_token {
-        tokens_helper(_visitor, &(it).0)
+        tokens_helper(_visitor, &it.span)
     };
-    tokens_helper(_visitor, &(_i.trait_token).0);
+    tokens_helper(_visitor, &_i.trait_token.span);
     _visitor.visit_ident(&_i.ident);
     _visitor.visit_generics(&_i.generics);
     if let Some(ref it) = _i.colon_token {
-        tokens_helper(_visitor, &(it).0)
+        tokens_helper(_visitor, &it.spans)
     };
     for el in Punctuated::pairs(&_i.supertraits) {
         let it = el.value();
         _visitor.visit_type_param_bound(it)
     }
-    tokens_helper(_visitor, &(_i.brace_token).0);
+    tokens_helper(_visitor, &_i.brace_token.span);
     for it in &_i.items {
         _visitor.visit_trait_item(it)
     }
@@ -2357,12 +2357,12 @@
         _visitor.visit_attribute(it)
     }
     _visitor.visit_visibility(&_i.vis);
-    tokens_helper(_visitor, &(_i.type_token).0);
+    tokens_helper(_visitor, &_i.type_token.span);
     _visitor.visit_ident(&_i.ident);
     _visitor.visit_generics(&_i.generics);
-    tokens_helper(_visitor, &(_i.eq_token).0);
+    tokens_helper(_visitor, &_i.eq_token.spans);
     _visitor.visit_type(&*_i.ty);
-    tokens_helper(_visitor, &(_i.semi_token).0);
+    tokens_helper(_visitor, &_i.semi_token.spans);
 }
 #[cfg(feature = "full")]
 pub fn visit_item_union<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ItemUnion) {
@@ -2370,7 +2370,7 @@
         _visitor.visit_attribute(it)
     }
     _visitor.visit_visibility(&_i.vis);
-    tokens_helper(_visitor, &(_i.union_token).0);
+    tokens_helper(_visitor, &_i.union_token.span);
     _visitor.visit_ident(&_i.ident);
     _visitor.visit_generics(&_i.generics);
     _visitor.visit_fields_named(&_i.fields);
@@ -2381,12 +2381,12 @@
         _visitor.visit_attribute(it)
     }
     _visitor.visit_visibility(&_i.vis);
-    tokens_helper(_visitor, &(_i.use_token).0);
+    tokens_helper(_visitor, &_i.use_token.span);
     if let Some(ref it) = _i.leading_colon {
-        tokens_helper(_visitor, &(it).0)
+        tokens_helper(_visitor, &it.spans)
     };
     _visitor.visit_use_tree(&_i.tree);
-    tokens_helper(_visitor, &(_i.semi_token).0);
+    tokens_helper(_visitor, &_i.semi_token.spans);
 }
 #[cfg(feature = "full")]
 pub fn visit_item_verbatim<'ast, V: Visit<'ast> + ?Sized>(
@@ -2399,7 +2399,7 @@
 #[cfg(feature = "full")]
 pub fn visit_label<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Label) {
     _visitor.visit_lifetime(&_i.name);
-    tokens_helper(_visitor, &(_i.colon_token).0);
+    tokens_helper(_visitor, &_i.colon_token.spans);
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_lifetime<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Lifetime) {
@@ -2413,7 +2413,7 @@
     }
     _visitor.visit_lifetime(&_i.lifetime);
     if let Some(ref it) = _i.colon_token {
-        tokens_helper(_visitor, &(it).0)
+        tokens_helper(_visitor, &it.spans)
     };
     for el in Punctuated::pairs(&_i.bounds) {
         let it = el.value();
@@ -2488,25 +2488,25 @@
     for it in &_i.attrs {
         _visitor.visit_attribute(it)
     }
-    tokens_helper(_visitor, &(_i.let_token).0);
+    tokens_helper(_visitor, &_i.let_token.span);
     for el in Punctuated::pairs(&_i.pats) {
         let it = el.value();
         _visitor.visit_pat(it)
     }
     if let Some(ref it) = _i.ty {
-        tokens_helper(_visitor, &((it).0).0);
+        tokens_helper(_visitor, &(it).0.spans);
         _visitor.visit_type(&*(it).1);
     };
     if let Some(ref it) = _i.init {
-        tokens_helper(_visitor, &((it).0).0);
+        tokens_helper(_visitor, &(it).0.spans);
         _visitor.visit_expr(&*(it).1);
     };
-    tokens_helper(_visitor, &(_i.semi_token).0);
+    tokens_helper(_visitor, &_i.semi_token.spans);
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_macro<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Macro) {
     _visitor.visit_path(&_i.path);
-    tokens_helper(_visitor, &(_i.bang_token).0);
+    tokens_helper(_visitor, &_i.bang_token.spans);
     _visitor.visit_macro_delimiter(&_i.delimiter);
     skip!(_i.tts);
 }
@@ -2517,13 +2517,13 @@
 ) {
     match *_i {
         MacroDelimiter::Paren(ref _binding_0) => {
-            tokens_helper(_visitor, &(_binding_0).0);
+            tokens_helper(_visitor, &_binding_0.span);
         }
         MacroDelimiter::Brace(ref _binding_0) => {
-            tokens_helper(_visitor, &(_binding_0).0);
+            tokens_helper(_visitor, &_binding_0.span);
         }
         MacroDelimiter::Bracket(ref _binding_0) => {
-            tokens_helper(_visitor, &(_binding_0).0);
+            tokens_helper(_visitor, &_binding_0.span);
         }
     }
 }
@@ -2555,7 +2555,7 @@
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_meta_list<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast MetaList) {
     _visitor.visit_ident(&_i.ident);
-    tokens_helper(_visitor, &(_i.paren_token).0);
+    tokens_helper(_visitor, &_i.paren_token.span);
     for el in Punctuated::pairs(&_i.nested) {
         let it = el.value();
         _visitor.visit_nested_meta(it)
@@ -2567,16 +2567,16 @@
     _i: &'ast MetaNameValue,
 ) {
     _visitor.visit_ident(&_i.ident);
-    tokens_helper(_visitor, &(_i.eq_token).0);
+    tokens_helper(_visitor, &_i.eq_token.spans);
     _visitor.visit_lit(&_i.lit);
 }
 #[cfg(feature = "full")]
 pub fn visit_method_sig<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast MethodSig) {
     if let Some(ref it) = _i.constness {
-        tokens_helper(_visitor, &(it).0)
+        tokens_helper(_visitor, &it.span)
     };
     if let Some(ref it) = _i.unsafety {
-        tokens_helper(_visitor, &(it).0)
+        tokens_helper(_visitor, &it.span)
     };
     if let Some(ref it) = _i.abi {
         _visitor.visit_abi(it)
@@ -2590,13 +2590,13 @@
     _visitor: &mut V,
     _i: &'ast MethodTurbofish,
 ) {
-    tokens_helper(_visitor, &(_i.colon2_token).0);
-    tokens_helper(_visitor, &(_i.lt_token).0);
+    tokens_helper(_visitor, &_i.colon2_token.spans);
+    tokens_helper(_visitor, &_i.lt_token.spans);
     for el in Punctuated::pairs(&_i.args) {
         let it = el.value();
         _visitor.visit_generic_method_argument(it)
     }
-    tokens_helper(_visitor, &(_i.gt_token).0);
+    tokens_helper(_visitor, &_i.gt_token.spans);
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_nested_meta<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast NestedMeta) {
@@ -2614,7 +2614,7 @@
     _visitor: &mut V,
     _i: &'ast ParenthesizedGenericArguments,
 ) {
-    tokens_helper(_visitor, &(_i.paren_token).0);
+    tokens_helper(_visitor, &_i.paren_token.span);
     for el in Punctuated::pairs(&_i.inputs) {
         let it = el.value();
         _visitor.visit_type(it)
@@ -2669,21 +2669,21 @@
 #[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn visit_pat_box<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PatBox) {
-    tokens_helper(_visitor, &(_i.box_token).0);
+    tokens_helper(_visitor, &_i.box_token.span);
     _visitor.visit_pat(&*_i.pat);
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn visit_pat_ident<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PatIdent) {
     if let Some(ref it) = _i.by_ref {
-        tokens_helper(_visitor, &(it).0)
+        tokens_helper(_visitor, &it.span)
     };
     if let Some(ref it) = _i.mutability {
-        tokens_helper(_visitor, &(it).0)
+        tokens_helper(_visitor, &it.span)
     };
     _visitor.visit_ident(&_i.ident);
     if let Some(ref it) = _i.subpat {
-        tokens_helper(_visitor, &((it).0).0);
+        tokens_helper(_visitor, &(it).0.spans);
         _visitor.visit_pat(&*(it).1);
     };
 }
@@ -2715,16 +2715,16 @@
 #[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn visit_pat_ref<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PatRef) {
-    tokens_helper(_visitor, &(_i.and_token).0);
+    tokens_helper(_visitor, &_i.and_token.spans);
     if let Some(ref it) = _i.mutability {
-        tokens_helper(_visitor, &(it).0)
+        tokens_helper(_visitor, &it.span)
     };
     _visitor.visit_pat(&*_i.pat);
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn visit_pat_slice<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PatSlice) {
-    tokens_helper(_visitor, &(_i.bracket_token).0);
+    tokens_helper(_visitor, &_i.bracket_token.span);
     for el in Punctuated::pairs(&_i.front) {
         let it = el.value();
         _visitor.visit_pat(it)
@@ -2733,10 +2733,10 @@
         _visitor.visit_pat(&**it)
     };
     if let Some(ref it) = _i.dot2_token {
-        tokens_helper(_visitor, &(it).0)
+        tokens_helper(_visitor, &it.spans)
     };
     if let Some(ref it) = _i.comma_token {
-        tokens_helper(_visitor, &(it).0)
+        tokens_helper(_visitor, &it.spans)
     };
     for el in Punctuated::pairs(&_i.back) {
         let it = el.value();
@@ -2747,28 +2747,28 @@
 #[cfg(feature = "full")]
 pub fn visit_pat_struct<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PatStruct) {
     _visitor.visit_path(&_i.path);
-    tokens_helper(_visitor, &(_i.brace_token).0);
+    tokens_helper(_visitor, &_i.brace_token.span);
     for el in Punctuated::pairs(&_i.fields) {
         let it = el.value();
         _visitor.visit_field_pat(it)
     }
     if let Some(ref it) = _i.dot2_token {
-        tokens_helper(_visitor, &(it).0)
+        tokens_helper(_visitor, &it.spans)
     };
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn visit_pat_tuple<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PatTuple) {
-    tokens_helper(_visitor, &(_i.paren_token).0);
+    tokens_helper(_visitor, &_i.paren_token.span);
     for el in Punctuated::pairs(&_i.front) {
         let it = el.value();
         _visitor.visit_pat(it)
     }
     if let Some(ref it) = _i.dot2_token {
-        tokens_helper(_visitor, &(it).0)
+        tokens_helper(_visitor, &it.spans)
     };
     if let Some(ref it) = _i.comma_token {
-        tokens_helper(_visitor, &(it).0)
+        tokens_helper(_visitor, &it.spans)
     };
     for el in Punctuated::pairs(&_i.back) {
         let it = el.value();
@@ -2792,12 +2792,12 @@
 #[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn visit_pat_wild<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PatWild) {
-    tokens_helper(_visitor, &(_i.underscore_token).0);
+    tokens_helper(_visitor, &_i.underscore_token.spans);
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_path<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Path) {
     if let Some(ref it) = _i.leading_colon {
-        tokens_helper(_visitor, &(it).0)
+        tokens_helper(_visitor, &it.spans)
     };
     for el in Punctuated::pairs(&_i.segments) {
         let it = el.value();
@@ -2827,7 +2827,7 @@
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_predicate_eq<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PredicateEq) {
     _visitor.visit_type(&_i.lhs_ty);
-    tokens_helper(_visitor, &(_i.eq_token).0);
+    tokens_helper(_visitor, &_i.eq_token.spans);
     _visitor.visit_type(&_i.rhs_ty);
 }
 #[cfg(any(feature = "full", feature = "derive"))]
@@ -2837,7 +2837,7 @@
 ) {
     _visitor.visit_lifetime(&_i.lifetime);
     if let Some(ref it) = _i.colon_token {
-        tokens_helper(_visitor, &(it).0)
+        tokens_helper(_visitor, &it.spans)
     };
     for el in Punctuated::pairs(&_i.bounds) {
         let it = el.value();
@@ -2853,7 +2853,7 @@
         _visitor.visit_bound_lifetimes(it)
     };
     _visitor.visit_type(&_i.bounded_ty);
-    tokens_helper(_visitor, &(_i.colon_token).0);
+    tokens_helper(_visitor, &_i.colon_token.spans);
     for el in Punctuated::pairs(&_i.bounds) {
         let it = el.value();
         _visitor.visit_type_param_bound(it)
@@ -2861,23 +2861,23 @@
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_qself<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast QSelf) {
-    tokens_helper(_visitor, &(_i.lt_token).0);
+    tokens_helper(_visitor, &_i.lt_token.spans);
     _visitor.visit_type(&*_i.ty);
     skip!(_i.position);
     if let Some(ref it) = _i.as_token {
-        tokens_helper(_visitor, &(it).0)
+        tokens_helper(_visitor, &it.span)
     };
-    tokens_helper(_visitor, &(_i.gt_token).0);
+    tokens_helper(_visitor, &_i.gt_token.spans);
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn visit_range_limits<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast RangeLimits) {
     match *_i {
         RangeLimits::HalfOpen(ref _binding_0) => {
-            tokens_helper(_visitor, &(_binding_0).0);
+            tokens_helper(_visitor, &_binding_0.spans);
         }
         RangeLimits::Closed(ref _binding_0) => {
-            tokens_helper(_visitor, &(_binding_0).0);
+            tokens_helper(_visitor, &_binding_0.spans);
         }
     }
 }
@@ -2886,7 +2886,7 @@
     match *_i {
         ReturnType::Default => {}
         ReturnType::Type(ref _binding_0, ref _binding_1) => {
-            tokens_helper(_visitor, &(_binding_0).0);
+            tokens_helper(_visitor, &_binding_0.spans);
             _visitor.visit_type(&**_binding_1);
         }
     }
@@ -2907,14 +2907,14 @@
         }
         Stmt::Semi(ref _binding_0, ref _binding_1) => {
             _visitor.visit_expr(_binding_0);
-            tokens_helper(_visitor, &(_binding_1).0);
+            tokens_helper(_visitor, &_binding_1.spans);
         }
     }
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_trait_bound<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast TraitBound) {
     if let Some(ref it) = _i.paren_token {
-        tokens_helper(_visitor, &(it).0)
+        tokens_helper(_visitor, &it.span)
     };
     _visitor.visit_trait_bound_modifier(&_i.modifier);
     if let Some(ref it) = _i.lifetimes {
@@ -2930,7 +2930,7 @@
     match *_i {
         TraitBoundModifier::None => {}
         TraitBoundModifier::Maybe(ref _binding_0) => {
-            tokens_helper(_visitor, &(_binding_0).0);
+            tokens_helper(_visitor, &_binding_0.spans);
         }
     }
 }
@@ -2962,15 +2962,15 @@
     for it in &_i.attrs {
         _visitor.visit_attribute(it)
     }
-    tokens_helper(_visitor, &(_i.const_token).0);
+    tokens_helper(_visitor, &_i.const_token.span);
     _visitor.visit_ident(&_i.ident);
-    tokens_helper(_visitor, &(_i.colon_token).0);
+    tokens_helper(_visitor, &_i.colon_token.spans);
     _visitor.visit_type(&_i.ty);
     if let Some(ref it) = _i.default {
-        tokens_helper(_visitor, &((it).0).0);
+        tokens_helper(_visitor, &(it).0.spans);
         _visitor.visit_expr(&(it).1);
     };
-    tokens_helper(_visitor, &(_i.semi_token).0);
+    tokens_helper(_visitor, &_i.semi_token.spans);
 }
 #[cfg(feature = "full")]
 pub fn visit_trait_item_macro<'ast, V: Visit<'ast> + ?Sized>(
@@ -2982,7 +2982,7 @@
     }
     _visitor.visit_macro(&_i.mac);
     if let Some(ref it) = _i.semi_token {
-        tokens_helper(_visitor, &(it).0)
+        tokens_helper(_visitor, &it.spans)
     };
 }
 #[cfg(feature = "full")]
@@ -2998,7 +2998,7 @@
         _visitor.visit_block(it)
     };
     if let Some(ref it) = _i.semi_token {
-        tokens_helper(_visitor, &(it).0)
+        tokens_helper(_visitor, &it.spans)
     };
 }
 #[cfg(feature = "full")]
@@ -3009,21 +3009,21 @@
     for it in &_i.attrs {
         _visitor.visit_attribute(it)
     }
-    tokens_helper(_visitor, &(_i.type_token).0);
+    tokens_helper(_visitor, &_i.type_token.span);
     _visitor.visit_ident(&_i.ident);
     _visitor.visit_generics(&_i.generics);
     if let Some(ref it) = _i.colon_token {
-        tokens_helper(_visitor, &(it).0)
+        tokens_helper(_visitor, &it.spans)
     };
     for el in Punctuated::pairs(&_i.bounds) {
         let it = el.value();
         _visitor.visit_type_param_bound(it)
     }
     if let Some(ref it) = _i.default {
-        tokens_helper(_visitor, &((it).0).0);
+        tokens_helper(_visitor, &(it).0.spans);
         _visitor.visit_type(&(it).1);
     };
-    tokens_helper(_visitor, &(_i.semi_token).0);
+    tokens_helper(_visitor, &_i.semi_token.spans);
 }
 #[cfg(feature = "full")]
 pub fn visit_trait_item_verbatim<'ast, V: Visit<'ast> + ?Sized>(
@@ -3084,36 +3084,36 @@
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_type_array<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast TypeArray) {
-    tokens_helper(_visitor, &(_i.bracket_token).0);
+    tokens_helper(_visitor, &_i.bracket_token.span);
     _visitor.visit_type(&*_i.elem);
-    tokens_helper(_visitor, &(_i.semi_token).0);
+    tokens_helper(_visitor, &_i.semi_token.spans);
     _visitor.visit_expr(&_i.len);
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_type_bare_fn<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast TypeBareFn) {
     if let Some(ref it) = _i.unsafety {
-        tokens_helper(_visitor, &(it).0)
+        tokens_helper(_visitor, &it.span)
     };
     if let Some(ref it) = _i.abi {
         _visitor.visit_abi(it)
     };
-    tokens_helper(_visitor, &(_i.fn_token).0);
+    tokens_helper(_visitor, &_i.fn_token.span);
     if let Some(ref it) = _i.lifetimes {
         _visitor.visit_bound_lifetimes(it)
     };
-    tokens_helper(_visitor, &(_i.paren_token).0);
+    tokens_helper(_visitor, &_i.paren_token.span);
     for el in Punctuated::pairs(&_i.inputs) {
         let it = el.value();
         _visitor.visit_bare_fn_arg(it)
     }
     if let Some(ref it) = _i.variadic {
-        tokens_helper(_visitor, &(it).0)
+        tokens_helper(_visitor, &it.spans)
     };
     _visitor.visit_return_type(&_i.output);
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_type_group<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast TypeGroup) {
-    tokens_helper(_visitor, &(_i.group_token).0);
+    tokens_helper(_visitor, &_i.group_token.span);
     _visitor.visit_type(&*_i.elem);
 }
 #[cfg(any(feature = "full", feature = "derive"))]
@@ -3121,7 +3121,7 @@
     _visitor: &mut V,
     _i: &'ast TypeImplTrait,
 ) {
-    tokens_helper(_visitor, &(_i.impl_token).0);
+    tokens_helper(_visitor, &_i.impl_token.span);
     for el in Punctuated::pairs(&_i.bounds) {
         let it = el.value();
         _visitor.visit_type_param_bound(it)
@@ -3129,7 +3129,7 @@
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_type_infer<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast TypeInfer) {
-    tokens_helper(_visitor, &(_i.underscore_token).0);
+    tokens_helper(_visitor, &_i.underscore_token.spans);
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_type_macro<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast TypeMacro) {
@@ -3137,7 +3137,7 @@
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_type_never<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast TypeNever) {
-    tokens_helper(_visitor, &(_i.bang_token).0);
+    tokens_helper(_visitor, &_i.bang_token.spans);
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_type_param<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast TypeParam) {
@@ -3146,14 +3146,14 @@
     }
     _visitor.visit_ident(&_i.ident);
     if let Some(ref it) = _i.colon_token {
-        tokens_helper(_visitor, &(it).0)
+        tokens_helper(_visitor, &it.spans)
     };
     for el in Punctuated::pairs(&_i.bounds) {
         let it = el.value();
         _visitor.visit_type_param_bound(it)
     }
     if let Some(ref it) = _i.eq_token {
-        tokens_helper(_visitor, &(it).0)
+        tokens_helper(_visitor, &it.spans)
     };
     if let Some(ref it) = _i.default {
         _visitor.visit_type(it)
@@ -3175,7 +3175,7 @@
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_type_paren<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast TypeParen) {
-    tokens_helper(_visitor, &(_i.paren_token).0);
+    tokens_helper(_visitor, &_i.paren_token.span);
     _visitor.visit_type(&*_i.elem);
 }
 #[cfg(any(feature = "full", feature = "derive"))]
@@ -3187,12 +3187,12 @@
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_type_ptr<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast TypePtr) {
-    tokens_helper(_visitor, &(_i.star_token).0);
+    tokens_helper(_visitor, &_i.star_token.spans);
     if let Some(ref it) = _i.const_token {
-        tokens_helper(_visitor, &(it).0)
+        tokens_helper(_visitor, &it.span)
     };
     if let Some(ref it) = _i.mutability {
-        tokens_helper(_visitor, &(it).0)
+        tokens_helper(_visitor, &it.span)
     };
     _visitor.visit_type(&*_i.elem);
 }
@@ -3201,18 +3201,18 @@
     _visitor: &mut V,
     _i: &'ast TypeReference,
 ) {
-    tokens_helper(_visitor, &(_i.and_token).0);
+    tokens_helper(_visitor, &_i.and_token.spans);
     if let Some(ref it) = _i.lifetime {
         _visitor.visit_lifetime(it)
     };
     if let Some(ref it) = _i.mutability {
-        tokens_helper(_visitor, &(it).0)
+        tokens_helper(_visitor, &it.span)
     };
     _visitor.visit_type(&*_i.elem);
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_type_slice<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast TypeSlice) {
-    tokens_helper(_visitor, &(_i.bracket_token).0);
+    tokens_helper(_visitor, &_i.bracket_token.span);
     _visitor.visit_type(&*_i.elem);
 }
 #[cfg(any(feature = "full", feature = "derive"))]
@@ -3221,7 +3221,7 @@
     _i: &'ast TypeTraitObject,
 ) {
     if let Some(ref it) = _i.dyn_token {
-        tokens_helper(_visitor, &(it).0)
+        tokens_helper(_visitor, &it.span)
     };
     for el in Punctuated::pairs(&_i.bounds) {
         let it = el.value();
@@ -3230,7 +3230,7 @@
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_type_tuple<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast TypeTuple) {
-    tokens_helper(_visitor, &(_i.paren_token).0);
+    tokens_helper(_visitor, &_i.paren_token.span);
     for el in Punctuated::pairs(&_i.elems) {
         let it = el.value();
         _visitor.visit_type(it)
@@ -3247,23 +3247,23 @@
 pub fn visit_un_op<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast UnOp) {
     match *_i {
         UnOp::Deref(ref _binding_0) => {
-            tokens_helper(_visitor, &(_binding_0).0);
+            tokens_helper(_visitor, &_binding_0.spans);
         }
         UnOp::Not(ref _binding_0) => {
-            tokens_helper(_visitor, &(_binding_0).0);
+            tokens_helper(_visitor, &_binding_0.spans);
         }
         UnOp::Neg(ref _binding_0) => {
-            tokens_helper(_visitor, &(_binding_0).0);
+            tokens_helper(_visitor, &_binding_0.spans);
         }
     }
 }
 #[cfg(feature = "full")]
 pub fn visit_use_glob<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast UseGlob) {
-    tokens_helper(_visitor, &(_i.star_token).0);
+    tokens_helper(_visitor, &_i.star_token.spans);
 }
 #[cfg(feature = "full")]
 pub fn visit_use_group<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast UseGroup) {
-    tokens_helper(_visitor, &(_i.brace_token).0);
+    tokens_helper(_visitor, &_i.brace_token.span);
     for el in Punctuated::pairs(&_i.items) {
         let it = el.value();
         _visitor.visit_use_tree(it)
@@ -3276,13 +3276,13 @@
 #[cfg(feature = "full")]
 pub fn visit_use_path<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast UsePath) {
     _visitor.visit_ident(&_i.ident);
-    tokens_helper(_visitor, &(_i.colon2_token).0);
+    tokens_helper(_visitor, &_i.colon2_token.spans);
     _visitor.visit_use_tree(&*_i.tree);
 }
 #[cfg(feature = "full")]
 pub fn visit_use_rename<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast UseRename) {
     _visitor.visit_ident(&_i.ident);
-    tokens_helper(_visitor, &(_i.as_token).0);
+    tokens_helper(_visitor, &_i.as_token.span);
     _visitor.visit_ident(&_i.rename);
 }
 #[cfg(feature = "full")]
@@ -3313,27 +3313,27 @@
     _visitor.visit_ident(&_i.ident);
     _visitor.visit_fields(&_i.fields);
     if let Some(ref it) = _i.discriminant {
-        tokens_helper(_visitor, &((it).0).0);
+        tokens_helper(_visitor, &(it).0.spans);
         _visitor.visit_expr(&(it).1);
     };
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_vis_crate<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast VisCrate) {
-    tokens_helper(_visitor, &(_i.crate_token).0);
+    tokens_helper(_visitor, &_i.crate_token.span);
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_vis_public<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast VisPublic) {
-    tokens_helper(_visitor, &(_i.pub_token).0);
+    tokens_helper(_visitor, &_i.pub_token.span);
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_vis_restricted<'ast, V: Visit<'ast> + ?Sized>(
     _visitor: &mut V,
     _i: &'ast VisRestricted,
 ) {
-    tokens_helper(_visitor, &(_i.pub_token).0);
-    tokens_helper(_visitor, &(_i.paren_token).0);
+    tokens_helper(_visitor, &_i.pub_token.span);
+    tokens_helper(_visitor, &_i.paren_token.span);
     if let Some(ref it) = _i.in_token {
-        tokens_helper(_visitor, &(it).0)
+        tokens_helper(_visitor, &it.span)
     };
     _visitor.visit_path(&*_i.path);
 }
@@ -3354,7 +3354,7 @@
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_where_clause<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast WhereClause) {
-    tokens_helper(_visitor, &(_i.where_token).0);
+    tokens_helper(_visitor, &_i.where_token.span);
     for el in Punctuated::pairs(&_i.predicates) {
         let it = el.value();
         _visitor.visit_where_predicate(it)
diff --git a/src/gen/visit_mut.rs b/src/gen/visit_mut.rs
index 14a7970..0f344b8 100644
--- a/src/gen/visit_mut.rs
+++ b/src/gen/visit_mut.rs
@@ -858,7 +858,7 @@
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_abi_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Abi) {
-    tokens_helper(_visitor, &mut (_i.extern_token).0);
+    tokens_helper(_visitor, &mut _i.extern_token.span);
     if let Some(ref mut it) = _i.name {
         _visitor.visit_lit_str_mut(it)
     };
@@ -869,38 +869,38 @@
     _i: &mut AngleBracketedGenericArguments,
 ) {
     if let Some(ref mut it) = _i.colon2_token {
-        tokens_helper(_visitor, &mut (it).0)
+        tokens_helper(_visitor, &mut it.spans)
     };
-    tokens_helper(_visitor, &mut (_i.lt_token).0);
+    tokens_helper(_visitor, &mut _i.lt_token.spans);
     for mut el in Punctuated::pairs_mut(&mut _i.args) {
         let it = el.value_mut();
         _visitor.visit_generic_argument_mut(it)
     }
-    tokens_helper(_visitor, &mut (_i.gt_token).0);
+    tokens_helper(_visitor, &mut _i.gt_token.spans);
 }
 #[cfg(feature = "full")]
 pub fn visit_arg_captured_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ArgCaptured) {
     _visitor.visit_pat_mut(&mut _i.pat);
-    tokens_helper(_visitor, &mut (_i.colon_token).0);
+    tokens_helper(_visitor, &mut _i.colon_token.spans);
     _visitor.visit_type_mut(&mut _i.ty);
 }
 #[cfg(feature = "full")]
 pub fn visit_arg_self_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ArgSelf) {
     if let Some(ref mut it) = _i.mutability {
-        tokens_helper(_visitor, &mut (it).0)
+        tokens_helper(_visitor, &mut it.span)
     };
-    tokens_helper(_visitor, &mut (_i.self_token).0);
+    tokens_helper(_visitor, &mut _i.self_token.span);
 }
 #[cfg(feature = "full")]
 pub fn visit_arg_self_ref_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ArgSelfRef) {
-    tokens_helper(_visitor, &mut (_i.and_token).0);
+    tokens_helper(_visitor, &mut _i.and_token.spans);
     if let Some(ref mut it) = _i.lifetime {
         _visitor.visit_lifetime_mut(it)
     };
     if let Some(ref mut it) = _i.mutability {
-        tokens_helper(_visitor, &mut (it).0)
+        tokens_helper(_visitor, &mut it.span)
     };
-    tokens_helper(_visitor, &mut (_i.self_token).0);
+    tokens_helper(_visitor, &mut _i.self_token.span);
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
@@ -909,20 +909,20 @@
         _visitor.visit_attribute_mut(it)
     }
     if let Some(ref mut it) = _i.leading_vert {
-        tokens_helper(_visitor, &mut (it).0)
+        tokens_helper(_visitor, &mut it.spans)
     };
     for mut el in Punctuated::pairs_mut(&mut _i.pats) {
         let it = el.value_mut();
         _visitor.visit_pat_mut(it)
     }
     if let Some(ref mut it) = _i.guard {
-        tokens_helper(_visitor, &mut ((it).0).0);
+        tokens_helper(_visitor, &mut (it).0.span);
         _visitor.visit_expr_mut(&mut *(it).1);
     };
-    tokens_helper(_visitor, &mut (_i.fat_arrow_token).0);
+    tokens_helper(_visitor, &mut _i.fat_arrow_token.spans);
     _visitor.visit_expr_mut(&mut *_i.body);
     if let Some(ref mut it) = _i.comma {
-        tokens_helper(_visitor, &mut (it).0)
+        tokens_helper(_visitor, &mut it.spans)
     };
 }
 #[cfg(any(feature = "full", feature = "derive"))]
@@ -930,15 +930,15 @@
     match *_i {
         AttrStyle::Outer => {}
         AttrStyle::Inner(ref mut _binding_0) => {
-            tokens_helper(_visitor, &mut (_binding_0).0);
+            tokens_helper(_visitor, &mut _binding_0.spans);
         }
     }
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_attribute_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Attribute) {
-    tokens_helper(_visitor, &mut (_i.pound_token).0);
+    tokens_helper(_visitor, &mut _i.pound_token.spans);
     _visitor.visit_attr_style_mut(&mut _i.style);
-    tokens_helper(_visitor, &mut (_i.bracket_token).0);
+    tokens_helper(_visitor, &mut _i.bracket_token.span);
     _visitor.visit_path_mut(&mut _i.path);
     skip!(_i.tts);
     skip!(_i.is_sugared_doc);
@@ -947,7 +947,7 @@
 pub fn visit_bare_fn_arg_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut BareFnArg) {
     if let Some(ref mut it) = _i.name {
         _visitor.visit_bare_fn_arg_name_mut(&mut (it).0);
-        tokens_helper(_visitor, &mut ((it).1).0);
+        tokens_helper(_visitor, &mut (it).1.spans);
     };
     _visitor.visit_type_mut(&mut _i.ty);
 }
@@ -958,7 +958,7 @@
             _visitor.visit_ident_mut(_binding_0);
         }
         BareFnArgName::Wild(ref mut _binding_0) => {
-            tokens_helper(_visitor, &mut (_binding_0).0);
+            tokens_helper(_visitor, &mut _binding_0.spans);
         }
     }
 }
@@ -966,126 +966,126 @@
 pub fn visit_bin_op_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut BinOp) {
     match *_i {
         BinOp::Add(ref mut _binding_0) => {
-            tokens_helper(_visitor, &mut (_binding_0).0);
+            tokens_helper(_visitor, &mut _binding_0.spans);
         }
         BinOp::Sub(ref mut _binding_0) => {
-            tokens_helper(_visitor, &mut (_binding_0).0);
+            tokens_helper(_visitor, &mut _binding_0.spans);
         }
         BinOp::Mul(ref mut _binding_0) => {
-            tokens_helper(_visitor, &mut (_binding_0).0);
+            tokens_helper(_visitor, &mut _binding_0.spans);
         }
         BinOp::Div(ref mut _binding_0) => {
-            tokens_helper(_visitor, &mut (_binding_0).0);
+            tokens_helper(_visitor, &mut _binding_0.spans);
         }
         BinOp::Rem(ref mut _binding_0) => {
-            tokens_helper(_visitor, &mut (_binding_0).0);
+            tokens_helper(_visitor, &mut _binding_0.spans);
         }
         BinOp::And(ref mut _binding_0) => {
-            tokens_helper(_visitor, &mut (_binding_0).0);
+            tokens_helper(_visitor, &mut _binding_0.spans);
         }
         BinOp::Or(ref mut _binding_0) => {
-            tokens_helper(_visitor, &mut (_binding_0).0);
+            tokens_helper(_visitor, &mut _binding_0.spans);
         }
         BinOp::BitXor(ref mut _binding_0) => {
-            tokens_helper(_visitor, &mut (_binding_0).0);
+            tokens_helper(_visitor, &mut _binding_0.spans);
         }
         BinOp::BitAnd(ref mut _binding_0) => {
-            tokens_helper(_visitor, &mut (_binding_0).0);
+            tokens_helper(_visitor, &mut _binding_0.spans);
         }
         BinOp::BitOr(ref mut _binding_0) => {
-            tokens_helper(_visitor, &mut (_binding_0).0);
+            tokens_helper(_visitor, &mut _binding_0.spans);
         }
         BinOp::Shl(ref mut _binding_0) => {
-            tokens_helper(_visitor, &mut (_binding_0).0);
+            tokens_helper(_visitor, &mut _binding_0.spans);
         }
         BinOp::Shr(ref mut _binding_0) => {
-            tokens_helper(_visitor, &mut (_binding_0).0);
+            tokens_helper(_visitor, &mut _binding_0.spans);
         }
         BinOp::Eq(ref mut _binding_0) => {
-            tokens_helper(_visitor, &mut (_binding_0).0);
+            tokens_helper(_visitor, &mut _binding_0.spans);
         }
         BinOp::Lt(ref mut _binding_0) => {
-            tokens_helper(_visitor, &mut (_binding_0).0);
+            tokens_helper(_visitor, &mut _binding_0.spans);
         }
         BinOp::Le(ref mut _binding_0) => {
-            tokens_helper(_visitor, &mut (_binding_0).0);
+            tokens_helper(_visitor, &mut _binding_0.spans);
         }
         BinOp::Ne(ref mut _binding_0) => {
-            tokens_helper(_visitor, &mut (_binding_0).0);
+            tokens_helper(_visitor, &mut _binding_0.spans);
         }
         BinOp::Ge(ref mut _binding_0) => {
-            tokens_helper(_visitor, &mut (_binding_0).0);
+            tokens_helper(_visitor, &mut _binding_0.spans);
         }
         BinOp::Gt(ref mut _binding_0) => {
-            tokens_helper(_visitor, &mut (_binding_0).0);
+            tokens_helper(_visitor, &mut _binding_0.spans);
         }
         BinOp::AddEq(ref mut _binding_0) => {
-            tokens_helper(_visitor, &mut (_binding_0).0);
+            tokens_helper(_visitor, &mut _binding_0.spans);
         }
         BinOp::SubEq(ref mut _binding_0) => {
-            tokens_helper(_visitor, &mut (_binding_0).0);
+            tokens_helper(_visitor, &mut _binding_0.spans);
         }
         BinOp::MulEq(ref mut _binding_0) => {
-            tokens_helper(_visitor, &mut (_binding_0).0);
+            tokens_helper(_visitor, &mut _binding_0.spans);
         }
         BinOp::DivEq(ref mut _binding_0) => {
-            tokens_helper(_visitor, &mut (_binding_0).0);
+            tokens_helper(_visitor, &mut _binding_0.spans);
         }
         BinOp::RemEq(ref mut _binding_0) => {
-            tokens_helper(_visitor, &mut (_binding_0).0);
+            tokens_helper(_visitor, &mut _binding_0.spans);
         }
         BinOp::BitXorEq(ref mut _binding_0) => {
-            tokens_helper(_visitor, &mut (_binding_0).0);
+            tokens_helper(_visitor, &mut _binding_0.spans);
         }
         BinOp::BitAndEq(ref mut _binding_0) => {
-            tokens_helper(_visitor, &mut (_binding_0).0);
+            tokens_helper(_visitor, &mut _binding_0.spans);
         }
         BinOp::BitOrEq(ref mut _binding_0) => {
-            tokens_helper(_visitor, &mut (_binding_0).0);
+            tokens_helper(_visitor, &mut _binding_0.spans);
         }
         BinOp::ShlEq(ref mut _binding_0) => {
-            tokens_helper(_visitor, &mut (_binding_0).0);
+            tokens_helper(_visitor, &mut _binding_0.spans);
         }
         BinOp::ShrEq(ref mut _binding_0) => {
-            tokens_helper(_visitor, &mut (_binding_0).0);
+            tokens_helper(_visitor, &mut _binding_0.spans);
         }
     }
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_binding_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Binding) {
     _visitor.visit_ident_mut(&mut _i.ident);
-    tokens_helper(_visitor, &mut (_i.eq_token).0);
+    tokens_helper(_visitor, &mut _i.eq_token.spans);
     _visitor.visit_type_mut(&mut _i.ty);
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn visit_block_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Block) {
-    tokens_helper(_visitor, &mut (_i.brace_token).0);
+    tokens_helper(_visitor, &mut _i.brace_token.span);
     for it in &mut _i.stmts {
         _visitor.visit_stmt_mut(it)
     }
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_bound_lifetimes_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut BoundLifetimes) {
-    tokens_helper(_visitor, &mut (_i.for_token).0);
-    tokens_helper(_visitor, &mut (_i.lt_token).0);
+    tokens_helper(_visitor, &mut _i.for_token.span);
+    tokens_helper(_visitor, &mut _i.lt_token.spans);
     for mut el in Punctuated::pairs_mut(&mut _i.lifetimes) {
         let it = el.value_mut();
         _visitor.visit_lifetime_def_mut(it)
     }
-    tokens_helper(_visitor, &mut (_i.gt_token).0);
+    tokens_helper(_visitor, &mut _i.gt_token.spans);
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_const_param_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ConstParam) {
     for it in &mut _i.attrs {
         _visitor.visit_attribute_mut(it)
     }
-    tokens_helper(_visitor, &mut (_i.const_token).0);
+    tokens_helper(_visitor, &mut _i.const_token.span);
     _visitor.visit_ident_mut(&mut _i.ident);
-    tokens_helper(_visitor, &mut (_i.colon_token).0);
+    tokens_helper(_visitor, &mut _i.colon_token.spans);
     _visitor.visit_type_mut(&mut _i.ty);
     if let Some(ref mut it) = _i.eq_token {
-        tokens_helper(_visitor, &mut (it).0)
+        tokens_helper(_visitor, &mut it.spans)
     };
     if let Some(ref mut it) = _i.default {
         _visitor.visit_expr_mut(it)
@@ -1107,8 +1107,8 @@
 }
 #[cfg(feature = "derive")]
 pub fn visit_data_enum_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut DataEnum) {
-    tokens_helper(_visitor, &mut (_i.enum_token).0);
-    tokens_helper(_visitor, &mut (_i.brace_token).0);
+    tokens_helper(_visitor, &mut _i.enum_token.span);
+    tokens_helper(_visitor, &mut _i.brace_token.span);
     for mut el in Punctuated::pairs_mut(&mut _i.variants) {
         let it = el.value_mut();
         _visitor.visit_variant_mut(it)
@@ -1116,15 +1116,15 @@
 }
 #[cfg(feature = "derive")]
 pub fn visit_data_struct_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut DataStruct) {
-    tokens_helper(_visitor, &mut (_i.struct_token).0);
+    tokens_helper(_visitor, &mut _i.struct_token.span);
     _visitor.visit_fields_mut(&mut _i.fields);
     if let Some(ref mut it) = _i.semi_token {
-        tokens_helper(_visitor, &mut (it).0)
+        tokens_helper(_visitor, &mut it.spans)
     };
 }
 #[cfg(feature = "derive")]
 pub fn visit_data_union_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut DataUnion) {
-    tokens_helper(_visitor, &mut (_i.union_token).0);
+    tokens_helper(_visitor, &mut _i.union_token.span);
     _visitor.visit_fields_named_mut(&mut _i.fields);
 }
 #[cfg(feature = "derive")]
@@ -1268,7 +1268,7 @@
     for it in &mut _i.attrs {
         _visitor.visit_attribute_mut(it)
     }
-    tokens_helper(_visitor, &mut (_i.bracket_token).0);
+    tokens_helper(_visitor, &mut _i.bracket_token.span);
     for mut el in Punctuated::pairs_mut(&mut _i.elems) {
         let it = el.value_mut();
         _visitor.visit_expr_mut(it)
@@ -1281,7 +1281,7 @@
         _visitor.visit_attribute_mut(it)
     }
     _visitor.visit_expr_mut(&mut *_i.left);
-    tokens_helper(_visitor, &mut (_i.eq_token).0);
+    tokens_helper(_visitor, &mut _i.eq_token.spans);
     _visitor.visit_expr_mut(&mut *_i.right);
 }
 #[cfg(feature = "full")]
@@ -1317,7 +1317,7 @@
     for it in &mut _i.attrs {
         _visitor.visit_attribute_mut(it)
     }
-    tokens_helper(_visitor, &mut (_i.box_token).0);
+    tokens_helper(_visitor, &mut _i.box_token.span);
     _visitor.visit_expr_mut(&mut *_i.expr);
 }
 #[cfg(feature = "full")]
@@ -1326,7 +1326,7 @@
     for it in &mut _i.attrs {
         _visitor.visit_attribute_mut(it)
     }
-    tokens_helper(_visitor, &mut (_i.break_token).0);
+    tokens_helper(_visitor, &mut _i.break_token.span);
     if let Some(ref mut it) = _i.label {
         _visitor.visit_lifetime_mut(it)
     };
@@ -1340,7 +1340,7 @@
         _visitor.visit_attribute_mut(it)
     }
     _visitor.visit_expr_mut(&mut *_i.func);
-    tokens_helper(_visitor, &mut (_i.paren_token).0);
+    tokens_helper(_visitor, &mut _i.paren_token.span);
     for mut el in Punctuated::pairs_mut(&mut _i.args) {
         let it = el.value_mut();
         _visitor.visit_expr_mut(it)
@@ -1352,7 +1352,7 @@
         _visitor.visit_attribute_mut(it)
     }
     _visitor.visit_expr_mut(&mut *_i.expr);
-    tokens_helper(_visitor, &mut (_i.as_token).0);
+    tokens_helper(_visitor, &mut _i.as_token.span);
     _visitor.visit_type_mut(&mut *_i.ty);
 }
 #[cfg(feature = "full")]
@@ -1361,8 +1361,8 @@
     for it in &mut _i.attrs {
         _visitor.visit_attribute_mut(it)
     }
-    tokens_helper(_visitor, &mut (_i.do_token).0);
-    tokens_helper(_visitor, &mut (_i.catch_token).0);
+    tokens_helper(_visitor, &mut _i.do_token.span);
+    tokens_helper(_visitor, &mut _i.catch_token.span);
     _visitor.visit_block_mut(&mut _i.block);
 }
 #[cfg(feature = "full")]
@@ -1372,17 +1372,17 @@
         _visitor.visit_attribute_mut(it)
     }
     if let Some(ref mut it) = _i.movability {
-        tokens_helper(_visitor, &mut (it).0)
+        tokens_helper(_visitor, &mut it.span)
     };
     if let Some(ref mut it) = _i.capture {
-        tokens_helper(_visitor, &mut (it).0)
+        tokens_helper(_visitor, &mut it.span)
     };
-    tokens_helper(_visitor, &mut (_i.or1_token).0);
+    tokens_helper(_visitor, &mut _i.or1_token.spans);
     for mut el in Punctuated::pairs_mut(&mut _i.inputs) {
         let it = el.value_mut();
         _visitor.visit_fn_arg_mut(it)
     }
-    tokens_helper(_visitor, &mut (_i.or2_token).0);
+    tokens_helper(_visitor, &mut _i.or2_token.spans);
     _visitor.visit_return_type_mut(&mut _i.output);
     _visitor.visit_expr_mut(&mut *_i.body);
 }
@@ -1392,7 +1392,7 @@
     for it in &mut _i.attrs {
         _visitor.visit_attribute_mut(it)
     }
-    tokens_helper(_visitor, &mut (_i.continue_token).0);
+    tokens_helper(_visitor, &mut _i.continue_token.span);
     if let Some(ref mut it) = _i.label {
         _visitor.visit_lifetime_mut(it)
     };
@@ -1403,7 +1403,7 @@
         _visitor.visit_attribute_mut(it)
     }
     _visitor.visit_expr_mut(&mut *_i.base);
-    tokens_helper(_visitor, &mut (_i.dot_token).0);
+    tokens_helper(_visitor, &mut _i.dot_token.spans);
     _visitor.visit_member_mut(&mut _i.member);
 }
 #[cfg(feature = "full")]
@@ -1415,9 +1415,9 @@
     if let Some(ref mut it) = _i.label {
         _visitor.visit_label_mut(it)
     };
-    tokens_helper(_visitor, &mut (_i.for_token).0);
+    tokens_helper(_visitor, &mut _i.for_token.span);
     _visitor.visit_pat_mut(&mut *_i.pat);
-    tokens_helper(_visitor, &mut (_i.in_token).0);
+    tokens_helper(_visitor, &mut _i.in_token.span);
     _visitor.visit_expr_mut(&mut *_i.expr);
     _visitor.visit_block_mut(&mut _i.body);
 }
@@ -1427,7 +1427,7 @@
     for it in &mut _i.attrs {
         _visitor.visit_attribute_mut(it)
     }
-    tokens_helper(_visitor, &mut (_i.group_token).0);
+    tokens_helper(_visitor, &mut _i.group_token.span);
     _visitor.visit_expr_mut(&mut *_i.expr);
 }
 #[cfg(feature = "full")]
@@ -1436,11 +1436,11 @@
     for it in &mut _i.attrs {
         _visitor.visit_attribute_mut(it)
     }
-    tokens_helper(_visitor, &mut (_i.if_token).0);
+    tokens_helper(_visitor, &mut _i.if_token.span);
     _visitor.visit_expr_mut(&mut *_i.cond);
     _visitor.visit_block_mut(&mut _i.then_branch);
     if let Some(ref mut it) = _i.else_branch {
-        tokens_helper(_visitor, &mut ((it).0).0);
+        tokens_helper(_visitor, &mut (it).0.span);
         _visitor.visit_expr_mut(&mut *(it).1);
     };
 }
@@ -1450,17 +1450,17 @@
     for it in &mut _i.attrs {
         _visitor.visit_attribute_mut(it)
     }
-    tokens_helper(_visitor, &mut (_i.if_token).0);
-    tokens_helper(_visitor, &mut (_i.let_token).0);
+    tokens_helper(_visitor, &mut _i.if_token.span);
+    tokens_helper(_visitor, &mut _i.let_token.span);
     for mut el in Punctuated::pairs_mut(&mut _i.pats) {
         let it = el.value_mut();
         _visitor.visit_pat_mut(it)
     }
-    tokens_helper(_visitor, &mut (_i.eq_token).0);
+    tokens_helper(_visitor, &mut _i.eq_token.spans);
     _visitor.visit_expr_mut(&mut *_i.expr);
     _visitor.visit_block_mut(&mut _i.then_branch);
     if let Some(ref mut it) = _i.else_branch {
-        tokens_helper(_visitor, &mut ((it).0).0);
+        tokens_helper(_visitor, &mut (it).0.span);
         _visitor.visit_expr_mut(&mut *(it).1);
     };
 }
@@ -1471,7 +1471,7 @@
         _visitor.visit_attribute_mut(it)
     }
     _visitor.visit_expr_mut(&mut *_i.place);
-    tokens_helper(_visitor, &mut (_i.arrow_token).0);
+    tokens_helper(_visitor, &mut _i.arrow_token.spans);
     _visitor.visit_expr_mut(&mut *_i.value);
 }
 #[cfg(any(feature = "full", feature = "derive"))]
@@ -1480,7 +1480,7 @@
         _visitor.visit_attribute_mut(it)
     }
     _visitor.visit_expr_mut(&mut *_i.expr);
-    tokens_helper(_visitor, &mut (_i.bracket_token).0);
+    tokens_helper(_visitor, &mut _i.bracket_token.span);
     _visitor.visit_expr_mut(&mut *_i.index);
 }
 #[cfg(any(feature = "full", feature = "derive"))]
@@ -1499,7 +1499,7 @@
     if let Some(ref mut it) = _i.label {
         _visitor.visit_label_mut(it)
     };
-    tokens_helper(_visitor, &mut (_i.loop_token).0);
+    tokens_helper(_visitor, &mut _i.loop_token.span);
     _visitor.visit_block_mut(&mut _i.body);
 }
 #[cfg(feature = "full")]
@@ -1516,9 +1516,9 @@
     for it in &mut _i.attrs {
         _visitor.visit_attribute_mut(it)
     }
-    tokens_helper(_visitor, &mut (_i.match_token).0);
+    tokens_helper(_visitor, &mut _i.match_token.span);
     _visitor.visit_expr_mut(&mut *_i.expr);
-    tokens_helper(_visitor, &mut (_i.brace_token).0);
+    tokens_helper(_visitor, &mut _i.brace_token.span);
     for it in &mut _i.arms {
         _visitor.visit_arm_mut(it)
     }
@@ -1530,12 +1530,12 @@
         _visitor.visit_attribute_mut(it)
     }
     _visitor.visit_expr_mut(&mut *_i.receiver);
-    tokens_helper(_visitor, &mut (_i.dot_token).0);
+    tokens_helper(_visitor, &mut _i.dot_token.spans);
     _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 (_i.paren_token).0);
+    tokens_helper(_visitor, &mut _i.paren_token.span);
     for mut el in Punctuated::pairs_mut(&mut _i.args) {
         let it = el.value_mut();
         _visitor.visit_expr_mut(it)
@@ -1546,7 +1546,7 @@
     for it in &mut _i.attrs {
         _visitor.visit_attribute_mut(it)
     }
-    tokens_helper(_visitor, &mut (_i.paren_token).0);
+    tokens_helper(_visitor, &mut _i.paren_token.span);
     _visitor.visit_expr_mut(&mut *_i.expr);
 }
 #[cfg(any(feature = "full", feature = "derive"))]
@@ -1579,9 +1579,9 @@
     for it in &mut _i.attrs {
         _visitor.visit_attribute_mut(it)
     }
-    tokens_helper(_visitor, &mut (_i.and_token).0);
+    tokens_helper(_visitor, &mut _i.and_token.spans);
     if let Some(ref mut it) = _i.mutability {
-        tokens_helper(_visitor, &mut (it).0)
+        tokens_helper(_visitor, &mut it.span)
     };
     _visitor.visit_expr_mut(&mut *_i.expr);
 }
@@ -1591,9 +1591,9 @@
     for it in &mut _i.attrs {
         _visitor.visit_attribute_mut(it)
     }
-    tokens_helper(_visitor, &mut (_i.bracket_token).0);
+    tokens_helper(_visitor, &mut _i.bracket_token.span);
     _visitor.visit_expr_mut(&mut *_i.expr);
-    tokens_helper(_visitor, &mut (_i.semi_token).0);
+    tokens_helper(_visitor, &mut _i.semi_token.spans);
     _visitor.visit_expr_mut(&mut *_i.len);
 }
 #[cfg(feature = "full")]
@@ -1602,7 +1602,7 @@
     for it in &mut _i.attrs {
         _visitor.visit_attribute_mut(it)
     }
-    tokens_helper(_visitor, &mut (_i.return_token).0);
+    tokens_helper(_visitor, &mut _i.return_token.span);
     if let Some(ref mut it) = _i.expr {
         _visitor.visit_expr_mut(&mut **it)
     };
@@ -1614,13 +1614,13 @@
         _visitor.visit_attribute_mut(it)
     }
     _visitor.visit_path_mut(&mut _i.path);
-    tokens_helper(_visitor, &mut (_i.brace_token).0);
+    tokens_helper(_visitor, &mut _i.brace_token.span);
     for mut el in Punctuated::pairs_mut(&mut _i.fields) {
         let it = el.value_mut();
         _visitor.visit_field_value_mut(it)
     }
     if let Some(ref mut it) = _i.dot2_token {
-        tokens_helper(_visitor, &mut (it).0)
+        tokens_helper(_visitor, &mut it.spans)
     };
     if let Some(ref mut it) = _i.rest {
         _visitor.visit_expr_mut(&mut **it)
@@ -1633,7 +1633,7 @@
         _visitor.visit_attribute_mut(it)
     }
     _visitor.visit_expr_mut(&mut *_i.expr);
-    tokens_helper(_visitor, &mut (_i.question_token).0);
+    tokens_helper(_visitor, &mut _i.question_token.spans);
 }
 #[cfg(feature = "full")]
 #[cfg(any(feature = "full", feature = "derive"))]
@@ -1641,7 +1641,7 @@
     for it in &mut _i.attrs {
         _visitor.visit_attribute_mut(it)
     }
-    tokens_helper(_visitor, &mut (_i.paren_token).0);
+    tokens_helper(_visitor, &mut _i.paren_token.span);
     for mut el in Punctuated::pairs_mut(&mut _i.elems) {
         let it = el.value_mut();
         _visitor.visit_expr_mut(it)
@@ -1654,7 +1654,7 @@
         _visitor.visit_attribute_mut(it)
     }
     _visitor.visit_expr_mut(&mut *_i.expr);
-    tokens_helper(_visitor, &mut (_i.colon_token).0);
+    tokens_helper(_visitor, &mut _i.colon_token.spans);
     _visitor.visit_type_mut(&mut *_i.ty);
 }
 #[cfg(any(feature = "full", feature = "derive"))]
@@ -1671,7 +1671,7 @@
     for it in &mut _i.attrs {
         _visitor.visit_attribute_mut(it)
     }
-    tokens_helper(_visitor, &mut (_i.unsafe_token).0);
+    tokens_helper(_visitor, &mut _i.unsafe_token.span);
     _visitor.visit_block_mut(&mut _i.block);
 }
 #[cfg(any(feature = "full", feature = "derive"))]
@@ -1687,7 +1687,7 @@
     if let Some(ref mut it) = _i.label {
         _visitor.visit_label_mut(it)
     };
-    tokens_helper(_visitor, &mut (_i.while_token).0);
+    tokens_helper(_visitor, &mut _i.while_token.span);
     _visitor.visit_expr_mut(&mut *_i.cond);
     _visitor.visit_block_mut(&mut _i.body);
 }
@@ -1700,13 +1700,13 @@
     if let Some(ref mut it) = _i.label {
         _visitor.visit_label_mut(it)
     };
-    tokens_helper(_visitor, &mut (_i.while_token).0);
-    tokens_helper(_visitor, &mut (_i.let_token).0);
+    tokens_helper(_visitor, &mut _i.while_token.span);
+    tokens_helper(_visitor, &mut _i.let_token.span);
     for mut el in Punctuated::pairs_mut(&mut _i.pats) {
         let it = el.value_mut();
         _visitor.visit_pat_mut(it)
     }
-    tokens_helper(_visitor, &mut (_i.eq_token).0);
+    tokens_helper(_visitor, &mut _i.eq_token.spans);
     _visitor.visit_expr_mut(&mut *_i.expr);
     _visitor.visit_block_mut(&mut _i.body);
 }
@@ -1716,7 +1716,7 @@
     for it in &mut _i.attrs {
         _visitor.visit_attribute_mut(it)
     }
-    tokens_helper(_visitor, &mut (_i.yield_token).0);
+    tokens_helper(_visitor, &mut _i.yield_token.span);
     if let Some(ref mut it) = _i.expr {
         _visitor.visit_expr_mut(&mut **it)
     };
@@ -1731,7 +1731,7 @@
         _visitor.visit_ident_mut(it)
     };
     if let Some(ref mut it) = _i.colon_token {
-        tokens_helper(_visitor, &mut (it).0)
+        tokens_helper(_visitor, &mut it.spans)
     };
     _visitor.visit_type_mut(&mut _i.ty);
 }
@@ -1743,7 +1743,7 @@
     }
     _visitor.visit_member_mut(&mut _i.member);
     if let Some(ref mut it) = _i.colon_token {
-        tokens_helper(_visitor, &mut (it).0)
+        tokens_helper(_visitor, &mut it.spans)
     };
     _visitor.visit_pat_mut(&mut *_i.pat);
 }
@@ -1755,7 +1755,7 @@
     }
     _visitor.visit_member_mut(&mut _i.member);
     if let Some(ref mut it) = _i.colon_token {
-        tokens_helper(_visitor, &mut (it).0)
+        tokens_helper(_visitor, &mut it.spans)
     };
     _visitor.visit_expr_mut(&mut _i.expr);
 }
@@ -1773,7 +1773,7 @@
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_fields_named_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut FieldsNamed) {
-    tokens_helper(_visitor, &mut (_i.brace_token).0);
+    tokens_helper(_visitor, &mut _i.brace_token.span);
     for mut el in Punctuated::pairs_mut(&mut _i.named) {
         let it = el.value_mut();
         _visitor.visit_field_mut(it)
@@ -1781,7 +1781,7 @@
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_fields_unnamed_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut FieldsUnnamed) {
-    tokens_helper(_visitor, &mut (_i.paren_token).0);
+    tokens_helper(_visitor, &mut _i.paren_token.span);
     for mut el in Punctuated::pairs_mut(&mut _i.unnamed) {
         let it = el.value_mut();
         _visitor.visit_field_mut(it)
@@ -1819,15 +1819,15 @@
 }
 #[cfg(feature = "full")]
 pub fn visit_fn_decl_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut FnDecl) {
-    tokens_helper(_visitor, &mut (_i.fn_token).0);
+    tokens_helper(_visitor, &mut _i.fn_token.span);
     _visitor.visit_generics_mut(&mut _i.generics);
-    tokens_helper(_visitor, &mut (_i.paren_token).0);
+    tokens_helper(_visitor, &mut _i.paren_token.span);
     for mut el in Punctuated::pairs_mut(&mut _i.inputs) {
         let it = el.value_mut();
         _visitor.visit_fn_arg_mut(it)
     }
     if let Some(ref mut it) = _i.variadic {
-        tokens_helper(_visitor, &mut (it).0)
+        tokens_helper(_visitor, &mut it.spans)
     };
     _visitor.visit_return_type_mut(&mut _i.output);
 }
@@ -1856,7 +1856,7 @@
     _visitor.visit_visibility_mut(&mut _i.vis);
     _visitor.visit_ident_mut(&mut _i.ident);
     _visitor.visit_fn_decl_mut(&mut *_i.decl);
-    tokens_helper(_visitor, &mut (_i.semi_token).0);
+    tokens_helper(_visitor, &mut _i.semi_token.spans);
 }
 #[cfg(feature = "full")]
 pub fn visit_foreign_item_static_mut<V: VisitMut + ?Sized>(
@@ -1867,14 +1867,14 @@
         _visitor.visit_attribute_mut(it)
     }
     _visitor.visit_visibility_mut(&mut _i.vis);
-    tokens_helper(_visitor, &mut (_i.static_token).0);
+    tokens_helper(_visitor, &mut _i.static_token.span);
     if let Some(ref mut it) = _i.mutability {
-        tokens_helper(_visitor, &mut (it).0)
+        tokens_helper(_visitor, &mut it.span)
     };
     _visitor.visit_ident_mut(&mut _i.ident);
-    tokens_helper(_visitor, &mut (_i.colon_token).0);
+    tokens_helper(_visitor, &mut _i.colon_token.spans);
     _visitor.visit_type_mut(&mut *_i.ty);
-    tokens_helper(_visitor, &mut (_i.semi_token).0);
+    tokens_helper(_visitor, &mut _i.semi_token.spans);
 }
 #[cfg(feature = "full")]
 pub fn visit_foreign_item_type_mut<V: VisitMut + ?Sized>(
@@ -1885,9 +1885,9 @@
         _visitor.visit_attribute_mut(it)
     }
     _visitor.visit_visibility_mut(&mut _i.vis);
-    tokens_helper(_visitor, &mut (_i.type_token).0);
+    tokens_helper(_visitor, &mut _i.type_token.span);
     _visitor.visit_ident_mut(&mut _i.ident);
-    tokens_helper(_visitor, &mut (_i.semi_token).0);
+    tokens_helper(_visitor, &mut _i.semi_token.spans);
 }
 #[cfg(feature = "full")]
 pub fn visit_foreign_item_verbatim_mut<V: VisitMut + ?Sized>(
@@ -1948,14 +1948,14 @@
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_generics_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Generics) {
     if let Some(ref mut it) = _i.lt_token {
-        tokens_helper(_visitor, &mut (it).0)
+        tokens_helper(_visitor, &mut it.spans)
     };
     for mut el in Punctuated::pairs_mut(&mut _i.params) {
         let it = el.value_mut();
         _visitor.visit_generic_param_mut(it)
     }
     if let Some(ref mut it) = _i.gt_token {
-        tokens_helper(_visitor, &mut (it).0)
+        tokens_helper(_visitor, &mut it.spans)
     };
     if let Some(ref mut it) = _i.where_clause {
         _visitor.visit_where_clause_mut(it)
@@ -1989,15 +1989,15 @@
     }
     _visitor.visit_visibility_mut(&mut _i.vis);
     if let Some(ref mut it) = _i.defaultness {
-        tokens_helper(_visitor, &mut (it).0)
+        tokens_helper(_visitor, &mut it.span)
     };
-    tokens_helper(_visitor, &mut (_i.const_token).0);
+    tokens_helper(_visitor, &mut _i.const_token.span);
     _visitor.visit_ident_mut(&mut _i.ident);
-    tokens_helper(_visitor, &mut (_i.colon_token).0);
+    tokens_helper(_visitor, &mut _i.colon_token.spans);
     _visitor.visit_type_mut(&mut _i.ty);
-    tokens_helper(_visitor, &mut (_i.eq_token).0);
+    tokens_helper(_visitor, &mut _i.eq_token.spans);
     _visitor.visit_expr_mut(&mut _i.expr);
-    tokens_helper(_visitor, &mut (_i.semi_token).0);
+    tokens_helper(_visitor, &mut _i.semi_token.spans);
 }
 #[cfg(feature = "full")]
 pub fn visit_impl_item_macro_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ImplItemMacro) {
@@ -2006,7 +2006,7 @@
     }
     _visitor.visit_macro_mut(&mut _i.mac);
     if let Some(ref mut it) = _i.semi_token {
-        tokens_helper(_visitor, &mut (it).0)
+        tokens_helper(_visitor, &mut it.spans)
     };
 }
 #[cfg(feature = "full")]
@@ -2016,7 +2016,7 @@
     }
     _visitor.visit_visibility_mut(&mut _i.vis);
     if let Some(ref mut it) = _i.defaultness {
-        tokens_helper(_visitor, &mut (it).0)
+        tokens_helper(_visitor, &mut it.span)
     };
     _visitor.visit_method_sig_mut(&mut _i.sig);
     _visitor.visit_block_mut(&mut _i.block);
@@ -2028,14 +2028,14 @@
     }
     _visitor.visit_visibility_mut(&mut _i.vis);
     if let Some(ref mut it) = _i.defaultness {
-        tokens_helper(_visitor, &mut (it).0)
+        tokens_helper(_visitor, &mut it.span)
     };
-    tokens_helper(_visitor, &mut (_i.type_token).0);
+    tokens_helper(_visitor, &mut _i.type_token.span);
     _visitor.visit_ident_mut(&mut _i.ident);
     _visitor.visit_generics_mut(&mut _i.generics);
-    tokens_helper(_visitor, &mut (_i.eq_token).0);
+    tokens_helper(_visitor, &mut _i.eq_token.spans);
     _visitor.visit_type_mut(&mut _i.ty);
-    tokens_helper(_visitor, &mut (_i.semi_token).0);
+    tokens_helper(_visitor, &mut _i.semi_token.spans);
 }
 #[cfg(feature = "full")]
 pub fn visit_impl_item_verbatim_mut<V: VisitMut + ?Sized>(
@@ -2108,13 +2108,13 @@
         _visitor.visit_attribute_mut(it)
     }
     _visitor.visit_visibility_mut(&mut _i.vis);
-    tokens_helper(_visitor, &mut (_i.const_token).0);
+    tokens_helper(_visitor, &mut _i.const_token.span);
     _visitor.visit_ident_mut(&mut _i.ident);
-    tokens_helper(_visitor, &mut (_i.colon_token).0);
+    tokens_helper(_visitor, &mut _i.colon_token.spans);
     _visitor.visit_type_mut(&mut *_i.ty);
-    tokens_helper(_visitor, &mut (_i.eq_token).0);
+    tokens_helper(_visitor, &mut _i.eq_token.spans);
     _visitor.visit_expr_mut(&mut *_i.expr);
-    tokens_helper(_visitor, &mut (_i.semi_token).0);
+    tokens_helper(_visitor, &mut _i.semi_token.spans);
 }
 #[cfg(feature = "full")]
 pub fn visit_item_enum_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ItemEnum) {
@@ -2122,10 +2122,10 @@
         _visitor.visit_attribute_mut(it)
     }
     _visitor.visit_visibility_mut(&mut _i.vis);
-    tokens_helper(_visitor, &mut (_i.enum_token).0);
+    tokens_helper(_visitor, &mut _i.enum_token.span);
     _visitor.visit_ident_mut(&mut _i.ident);
     _visitor.visit_generics_mut(&mut _i.generics);
-    tokens_helper(_visitor, &mut (_i.brace_token).0);
+    tokens_helper(_visitor, &mut _i.brace_token.span);
     for mut el in Punctuated::pairs_mut(&mut _i.variants) {
         let it = el.value_mut();
         _visitor.visit_variant_mut(it)
@@ -2140,14 +2140,14 @@
         _visitor.visit_attribute_mut(it)
     }
     _visitor.visit_visibility_mut(&mut _i.vis);
-    tokens_helper(_visitor, &mut (_i.extern_token).0);
-    tokens_helper(_visitor, &mut (_i.crate_token).0);
+    tokens_helper(_visitor, &mut _i.extern_token.span);
+    tokens_helper(_visitor, &mut _i.crate_token.span);
     _visitor.visit_ident_mut(&mut _i.ident);
     if let Some(ref mut it) = _i.rename {
-        tokens_helper(_visitor, &mut ((it).0).0);
+        tokens_helper(_visitor, &mut (it).0.span);
         _visitor.visit_ident_mut(&mut (it).1);
     };
-    tokens_helper(_visitor, &mut (_i.semi_token).0);
+    tokens_helper(_visitor, &mut _i.semi_token.spans);
 }
 #[cfg(feature = "full")]
 pub fn visit_item_fn_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ItemFn) {
@@ -2156,10 +2156,10 @@
     }
     _visitor.visit_visibility_mut(&mut _i.vis);
     if let Some(ref mut it) = _i.constness {
-        tokens_helper(_visitor, &mut (it).0)
+        tokens_helper(_visitor, &mut it.span)
     };
     if let Some(ref mut it) = _i.unsafety {
-        tokens_helper(_visitor, &mut (it).0)
+        tokens_helper(_visitor, &mut it.span)
     };
     if let Some(ref mut it) = _i.abi {
         _visitor.visit_abi_mut(it)
@@ -2174,7 +2174,7 @@
         _visitor.visit_attribute_mut(it)
     }
     _visitor.visit_abi_mut(&mut _i.abi);
-    tokens_helper(_visitor, &mut (_i.brace_token).0);
+    tokens_helper(_visitor, &mut _i.brace_token.span);
     for it in &mut _i.items {
         _visitor.visit_foreign_item_mut(it)
     }
@@ -2185,22 +2185,22 @@
         _visitor.visit_attribute_mut(it)
     }
     if let Some(ref mut it) = _i.defaultness {
-        tokens_helper(_visitor, &mut (it).0)
+        tokens_helper(_visitor, &mut it.span)
     };
     if let Some(ref mut it) = _i.unsafety {
-        tokens_helper(_visitor, &mut (it).0)
+        tokens_helper(_visitor, &mut it.span)
     };
-    tokens_helper(_visitor, &mut (_i.impl_token).0);
+    tokens_helper(_visitor, &mut _i.impl_token.span);
     _visitor.visit_generics_mut(&mut _i.generics);
     if let Some(ref mut it) = _i.trait_ {
         if let Some(ref mut it) = (it).0 {
-            tokens_helper(_visitor, &mut (it).0)
+            tokens_helper(_visitor, &mut it.spans)
         };
         _visitor.visit_path_mut(&mut (it).1);
-        tokens_helper(_visitor, &mut ((it).2).0);
+        tokens_helper(_visitor, &mut (it).2.span);
     };
     _visitor.visit_type_mut(&mut *_i.self_ty);
-    tokens_helper(_visitor, &mut (_i.brace_token).0);
+    tokens_helper(_visitor, &mut _i.brace_token.span);
     for it in &mut _i.items {
         _visitor.visit_impl_item_mut(it)
     }
@@ -2215,7 +2215,7 @@
     };
     _visitor.visit_macro_mut(&mut _i.mac);
     if let Some(ref mut it) = _i.semi_token {
-        tokens_helper(_visitor, &mut (it).0)
+        tokens_helper(_visitor, &mut it.spans)
     };
 }
 #[cfg(feature = "full")]
@@ -2224,11 +2224,11 @@
         _visitor.visit_attribute_mut(it)
     }
     _visitor.visit_visibility_mut(&mut _i.vis);
-    tokens_helper(_visitor, &mut (_i.macro_token).0);
+    tokens_helper(_visitor, &mut _i.macro_token.span);
     _visitor.visit_ident_mut(&mut _i.ident);
-    tokens_helper(_visitor, &mut (_i.paren_token).0);
+    tokens_helper(_visitor, &mut _i.paren_token.span);
     skip!(_i.args);
-    tokens_helper(_visitor, &mut (_i.brace_token).0);
+    tokens_helper(_visitor, &mut _i.brace_token.span);
     skip!(_i.body);
 }
 #[cfg(feature = "full")]
@@ -2237,16 +2237,16 @@
         _visitor.visit_attribute_mut(it)
     }
     _visitor.visit_visibility_mut(&mut _i.vis);
-    tokens_helper(_visitor, &mut (_i.mod_token).0);
+    tokens_helper(_visitor, &mut _i.mod_token.span);
     _visitor.visit_ident_mut(&mut _i.ident);
     if let Some(ref mut it) = _i.content {
-        tokens_helper(_visitor, &mut ((it).0).0);
+        tokens_helper(_visitor, &mut (it).0.span);
         for it in &mut (it).1 {
             _visitor.visit_item_mut(it)
         }
     };
     if let Some(ref mut it) = _i.semi {
-        tokens_helper(_visitor, &mut (it).0)
+        tokens_helper(_visitor, &mut it.spans)
     };
 }
 #[cfg(feature = "full")]
@@ -2255,16 +2255,16 @@
         _visitor.visit_attribute_mut(it)
     }
     _visitor.visit_visibility_mut(&mut _i.vis);
-    tokens_helper(_visitor, &mut (_i.static_token).0);
+    tokens_helper(_visitor, &mut _i.static_token.span);
     if let Some(ref mut it) = _i.mutability {
-        tokens_helper(_visitor, &mut (it).0)
+        tokens_helper(_visitor, &mut it.span)
     };
     _visitor.visit_ident_mut(&mut _i.ident);
-    tokens_helper(_visitor, &mut (_i.colon_token).0);
+    tokens_helper(_visitor, &mut _i.colon_token.spans);
     _visitor.visit_type_mut(&mut *_i.ty);
-    tokens_helper(_visitor, &mut (_i.eq_token).0);
+    tokens_helper(_visitor, &mut _i.eq_token.spans);
     _visitor.visit_expr_mut(&mut *_i.expr);
-    tokens_helper(_visitor, &mut (_i.semi_token).0);
+    tokens_helper(_visitor, &mut _i.semi_token.spans);
 }
 #[cfg(feature = "full")]
 pub fn visit_item_struct_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ItemStruct) {
@@ -2272,12 +2272,12 @@
         _visitor.visit_attribute_mut(it)
     }
     _visitor.visit_visibility_mut(&mut _i.vis);
-    tokens_helper(_visitor, &mut (_i.struct_token).0);
+    tokens_helper(_visitor, &mut _i.struct_token.span);
     _visitor.visit_ident_mut(&mut _i.ident);
     _visitor.visit_generics_mut(&mut _i.generics);
     _visitor.visit_fields_mut(&mut _i.fields);
     if let Some(ref mut it) = _i.semi_token {
-        tokens_helper(_visitor, &mut (it).0)
+        tokens_helper(_visitor, &mut it.spans)
     };
 }
 #[cfg(feature = "full")]
@@ -2287,22 +2287,22 @@
     }
     _visitor.visit_visibility_mut(&mut _i.vis);
     if let Some(ref mut it) = _i.unsafety {
-        tokens_helper(_visitor, &mut (it).0)
+        tokens_helper(_visitor, &mut it.span)
     };
     if let Some(ref mut it) = _i.auto_token {
-        tokens_helper(_visitor, &mut (it).0)
+        tokens_helper(_visitor, &mut it.span)
     };
-    tokens_helper(_visitor, &mut (_i.trait_token).0);
+    tokens_helper(_visitor, &mut _i.trait_token.span);
     _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)
+        tokens_helper(_visitor, &mut it.spans)
     };
     for mut el in Punctuated::pairs_mut(&mut _i.supertraits) {
         let it = el.value_mut();
         _visitor.visit_type_param_bound_mut(it)
     }
-    tokens_helper(_visitor, &mut (_i.brace_token).0);
+    tokens_helper(_visitor, &mut _i.brace_token.span);
     for it in &mut _i.items {
         _visitor.visit_trait_item_mut(it)
     }
@@ -2313,12 +2313,12 @@
         _visitor.visit_attribute_mut(it)
     }
     _visitor.visit_visibility_mut(&mut _i.vis);
-    tokens_helper(_visitor, &mut (_i.type_token).0);
+    tokens_helper(_visitor, &mut _i.type_token.span);
     _visitor.visit_ident_mut(&mut _i.ident);
     _visitor.visit_generics_mut(&mut _i.generics);
-    tokens_helper(_visitor, &mut (_i.eq_token).0);
+    tokens_helper(_visitor, &mut _i.eq_token.spans);
     _visitor.visit_type_mut(&mut *_i.ty);
-    tokens_helper(_visitor, &mut (_i.semi_token).0);
+    tokens_helper(_visitor, &mut _i.semi_token.spans);
 }
 #[cfg(feature = "full")]
 pub fn visit_item_union_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ItemUnion) {
@@ -2326,7 +2326,7 @@
         _visitor.visit_attribute_mut(it)
     }
     _visitor.visit_visibility_mut(&mut _i.vis);
-    tokens_helper(_visitor, &mut (_i.union_token).0);
+    tokens_helper(_visitor, &mut _i.union_token.span);
     _visitor.visit_ident_mut(&mut _i.ident);
     _visitor.visit_generics_mut(&mut _i.generics);
     _visitor.visit_fields_named_mut(&mut _i.fields);
@@ -2337,12 +2337,12 @@
         _visitor.visit_attribute_mut(it)
     }
     _visitor.visit_visibility_mut(&mut _i.vis);
-    tokens_helper(_visitor, &mut (_i.use_token).0);
+    tokens_helper(_visitor, &mut _i.use_token.span);
     if let Some(ref mut it) = _i.leading_colon {
-        tokens_helper(_visitor, &mut (it).0)
+        tokens_helper(_visitor, &mut it.spans)
     };
     _visitor.visit_use_tree_mut(&mut _i.tree);
-    tokens_helper(_visitor, &mut (_i.semi_token).0);
+    tokens_helper(_visitor, &mut _i.semi_token.spans);
 }
 #[cfg(feature = "full")]
 pub fn visit_item_verbatim_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ItemVerbatim) {
@@ -2352,7 +2352,7 @@
 #[cfg(feature = "full")]
 pub fn visit_label_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Label) {
     _visitor.visit_lifetime_mut(&mut _i.name);
-    tokens_helper(_visitor, &mut (_i.colon_token).0);
+    tokens_helper(_visitor, &mut _i.colon_token.spans);
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_lifetime_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Lifetime) {
@@ -2366,7 +2366,7 @@
     }
     _visitor.visit_lifetime_mut(&mut _i.lifetime);
     if let Some(ref mut it) = _i.colon_token {
-        tokens_helper(_visitor, &mut (it).0)
+        tokens_helper(_visitor, &mut it.spans)
     };
     for mut el in Punctuated::pairs_mut(&mut _i.bounds) {
         let it = el.value_mut();
@@ -2441,25 +2441,25 @@
     for it in &mut _i.attrs {
         _visitor.visit_attribute_mut(it)
     }
-    tokens_helper(_visitor, &mut (_i.let_token).0);
+    tokens_helper(_visitor, &mut _i.let_token.span);
     for mut el in Punctuated::pairs_mut(&mut _i.pats) {
         let it = el.value_mut();
         _visitor.visit_pat_mut(it)
     }
     if let Some(ref mut it) = _i.ty {
-        tokens_helper(_visitor, &mut ((it).0).0);
+        tokens_helper(_visitor, &mut (it).0.spans);
         _visitor.visit_type_mut(&mut *(it).1);
     };
     if let Some(ref mut it) = _i.init {
-        tokens_helper(_visitor, &mut ((it).0).0);
+        tokens_helper(_visitor, &mut (it).0.spans);
         _visitor.visit_expr_mut(&mut *(it).1);
     };
-    tokens_helper(_visitor, &mut (_i.semi_token).0);
+    tokens_helper(_visitor, &mut _i.semi_token.spans);
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_macro_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Macro) {
     _visitor.visit_path_mut(&mut _i.path);
-    tokens_helper(_visitor, &mut (_i.bang_token).0);
+    tokens_helper(_visitor, &mut _i.bang_token.spans);
     _visitor.visit_macro_delimiter_mut(&mut _i.delimiter);
     skip!(_i.tts);
 }
@@ -2467,13 +2467,13 @@
 pub fn visit_macro_delimiter_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut MacroDelimiter) {
     match *_i {
         MacroDelimiter::Paren(ref mut _binding_0) => {
-            tokens_helper(_visitor, &mut (_binding_0).0);
+            tokens_helper(_visitor, &mut _binding_0.span);
         }
         MacroDelimiter::Brace(ref mut _binding_0) => {
-            tokens_helper(_visitor, &mut (_binding_0).0);
+            tokens_helper(_visitor, &mut _binding_0.span);
         }
         MacroDelimiter::Bracket(ref mut _binding_0) => {
-            tokens_helper(_visitor, &mut (_binding_0).0);
+            tokens_helper(_visitor, &mut _binding_0.span);
         }
     }
 }
@@ -2505,7 +2505,7 @@
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_meta_list_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut MetaList) {
     _visitor.visit_ident_mut(&mut _i.ident);
-    tokens_helper(_visitor, &mut (_i.paren_token).0);
+    tokens_helper(_visitor, &mut _i.paren_token.span);
     for mut el in Punctuated::pairs_mut(&mut _i.nested) {
         let it = el.value_mut();
         _visitor.visit_nested_meta_mut(it)
@@ -2514,16 +2514,16 @@
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_meta_name_value_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut MetaNameValue) {
     _visitor.visit_ident_mut(&mut _i.ident);
-    tokens_helper(_visitor, &mut (_i.eq_token).0);
+    tokens_helper(_visitor, &mut _i.eq_token.spans);
     _visitor.visit_lit_mut(&mut _i.lit);
 }
 #[cfg(feature = "full")]
 pub fn visit_method_sig_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut MethodSig) {
     if let Some(ref mut it) = _i.constness {
-        tokens_helper(_visitor, &mut (it).0)
+        tokens_helper(_visitor, &mut it.span)
     };
     if let Some(ref mut it) = _i.unsafety {
-        tokens_helper(_visitor, &mut (it).0)
+        tokens_helper(_visitor, &mut it.span)
     };
     if let Some(ref mut it) = _i.abi {
         _visitor.visit_abi_mut(it)
@@ -2537,13 +2537,13 @@
     _visitor: &mut V,
     _i: &mut MethodTurbofish,
 ) {
-    tokens_helper(_visitor, &mut (_i.colon2_token).0);
-    tokens_helper(_visitor, &mut (_i.lt_token).0);
+    tokens_helper(_visitor, &mut _i.colon2_token.spans);
+    tokens_helper(_visitor, &mut _i.lt_token.spans);
     for mut el in Punctuated::pairs_mut(&mut _i.args) {
         let it = el.value_mut();
         _visitor.visit_generic_method_argument_mut(it)
     }
-    tokens_helper(_visitor, &mut (_i.gt_token).0);
+    tokens_helper(_visitor, &mut _i.gt_token.spans);
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_nested_meta_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut NestedMeta) {
@@ -2561,7 +2561,7 @@
     _visitor: &mut V,
     _i: &mut ParenthesizedGenericArguments,
 ) {
-    tokens_helper(_visitor, &mut (_i.paren_token).0);
+    tokens_helper(_visitor, &mut _i.paren_token.span);
     for mut el in Punctuated::pairs_mut(&mut _i.inputs) {
         let it = el.value_mut();
         _visitor.visit_type_mut(it)
@@ -2616,21 +2616,21 @@
 #[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn visit_pat_box_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut PatBox) {
-    tokens_helper(_visitor, &mut (_i.box_token).0);
+    tokens_helper(_visitor, &mut _i.box_token.span);
     _visitor.visit_pat_mut(&mut *_i.pat);
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn visit_pat_ident_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut PatIdent) {
     if let Some(ref mut it) = _i.by_ref {
-        tokens_helper(_visitor, &mut (it).0)
+        tokens_helper(_visitor, &mut it.span)
     };
     if let Some(ref mut it) = _i.mutability {
-        tokens_helper(_visitor, &mut (it).0)
+        tokens_helper(_visitor, &mut it.span)
     };
     _visitor.visit_ident_mut(&mut _i.ident);
     if let Some(ref mut it) = _i.subpat {
-        tokens_helper(_visitor, &mut ((it).0).0);
+        tokens_helper(_visitor, &mut (it).0.spans);
         _visitor.visit_pat_mut(&mut *(it).1);
     };
 }
@@ -2662,16 +2662,16 @@
 #[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn visit_pat_ref_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut PatRef) {
-    tokens_helper(_visitor, &mut (_i.and_token).0);
+    tokens_helper(_visitor, &mut _i.and_token.spans);
     if let Some(ref mut it) = _i.mutability {
-        tokens_helper(_visitor, &mut (it).0)
+        tokens_helper(_visitor, &mut it.span)
     };
     _visitor.visit_pat_mut(&mut *_i.pat);
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn visit_pat_slice_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut PatSlice) {
-    tokens_helper(_visitor, &mut (_i.bracket_token).0);
+    tokens_helper(_visitor, &mut _i.bracket_token.span);
     for mut el in Punctuated::pairs_mut(&mut _i.front) {
         let it = el.value_mut();
         _visitor.visit_pat_mut(it)
@@ -2680,10 +2680,10 @@
         _visitor.visit_pat_mut(&mut **it)
     };
     if let Some(ref mut it) = _i.dot2_token {
-        tokens_helper(_visitor, &mut (it).0)
+        tokens_helper(_visitor, &mut it.spans)
     };
     if let Some(ref mut it) = _i.comma_token {
-        tokens_helper(_visitor, &mut (it).0)
+        tokens_helper(_visitor, &mut it.spans)
     };
     for mut el in Punctuated::pairs_mut(&mut _i.back) {
         let it = el.value_mut();
@@ -2694,28 +2694,28 @@
 #[cfg(feature = "full")]
 pub fn visit_pat_struct_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut PatStruct) {
     _visitor.visit_path_mut(&mut _i.path);
-    tokens_helper(_visitor, &mut (_i.brace_token).0);
+    tokens_helper(_visitor, &mut _i.brace_token.span);
     for mut el in Punctuated::pairs_mut(&mut _i.fields) {
         let it = el.value_mut();
         _visitor.visit_field_pat_mut(it)
     }
     if let Some(ref mut it) = _i.dot2_token {
-        tokens_helper(_visitor, &mut (it).0)
+        tokens_helper(_visitor, &mut it.spans)
     };
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn visit_pat_tuple_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut PatTuple) {
-    tokens_helper(_visitor, &mut (_i.paren_token).0);
+    tokens_helper(_visitor, &mut _i.paren_token.span);
     for mut el in Punctuated::pairs_mut(&mut _i.front) {
         let it = el.value_mut();
         _visitor.visit_pat_mut(it)
     }
     if let Some(ref mut it) = _i.dot2_token {
-        tokens_helper(_visitor, &mut (it).0)
+        tokens_helper(_visitor, &mut it.spans)
     };
     if let Some(ref mut it) = _i.comma_token {
-        tokens_helper(_visitor, &mut (it).0)
+        tokens_helper(_visitor, &mut it.spans)
     };
     for mut el in Punctuated::pairs_mut(&mut _i.back) {
         let it = el.value_mut();
@@ -2736,12 +2736,12 @@
 #[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn visit_pat_wild_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut PatWild) {
-    tokens_helper(_visitor, &mut (_i.underscore_token).0);
+    tokens_helper(_visitor, &mut _i.underscore_token.spans);
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_path_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Path) {
     if let Some(ref mut it) = _i.leading_colon {
-        tokens_helper(_visitor, &mut (it).0)
+        tokens_helper(_visitor, &mut it.spans)
     };
     for mut el in Punctuated::pairs_mut(&mut _i.segments) {
         let it = el.value_mut();
@@ -2768,7 +2768,7 @@
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_predicate_eq_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut PredicateEq) {
     _visitor.visit_type_mut(&mut _i.lhs_ty);
-    tokens_helper(_visitor, &mut (_i.eq_token).0);
+    tokens_helper(_visitor, &mut _i.eq_token.spans);
     _visitor.visit_type_mut(&mut _i.rhs_ty);
 }
 #[cfg(any(feature = "full", feature = "derive"))]
@@ -2778,7 +2778,7 @@
 ) {
     _visitor.visit_lifetime_mut(&mut _i.lifetime);
     if let Some(ref mut it) = _i.colon_token {
-        tokens_helper(_visitor, &mut (it).0)
+        tokens_helper(_visitor, &mut it.spans)
     };
     for mut el in Punctuated::pairs_mut(&mut _i.bounds) {
         let it = el.value_mut();
@@ -2791,7 +2791,7 @@
         _visitor.visit_bound_lifetimes_mut(it)
     };
     _visitor.visit_type_mut(&mut _i.bounded_ty);
-    tokens_helper(_visitor, &mut (_i.colon_token).0);
+    tokens_helper(_visitor, &mut _i.colon_token.spans);
     for mut el in Punctuated::pairs_mut(&mut _i.bounds) {
         let it = el.value_mut();
         _visitor.visit_type_param_bound_mut(it)
@@ -2799,23 +2799,23 @@
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_qself_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut QSelf) {
-    tokens_helper(_visitor, &mut (_i.lt_token).0);
+    tokens_helper(_visitor, &mut _i.lt_token.spans);
     _visitor.visit_type_mut(&mut *_i.ty);
     skip!(_i.position);
     if let Some(ref mut it) = _i.as_token {
-        tokens_helper(_visitor, &mut (it).0)
+        tokens_helper(_visitor, &mut it.span)
     };
-    tokens_helper(_visitor, &mut (_i.gt_token).0);
+    tokens_helper(_visitor, &mut _i.gt_token.spans);
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn visit_range_limits_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut RangeLimits) {
     match *_i {
         RangeLimits::HalfOpen(ref mut _binding_0) => {
-            tokens_helper(_visitor, &mut (_binding_0).0);
+            tokens_helper(_visitor, &mut _binding_0.spans);
         }
         RangeLimits::Closed(ref mut _binding_0) => {
-            tokens_helper(_visitor, &mut (_binding_0).0);
+            tokens_helper(_visitor, &mut _binding_0.spans);
         }
     }
 }
@@ -2824,7 +2824,7 @@
     match *_i {
         ReturnType::Default => {}
         ReturnType::Type(ref mut _binding_0, ref mut _binding_1) => {
-            tokens_helper(_visitor, &mut (_binding_0).0);
+            tokens_helper(_visitor, &mut _binding_0.spans);
             _visitor.visit_type_mut(&mut **_binding_1);
         }
     }
@@ -2845,14 +2845,14 @@
         }
         Stmt::Semi(ref mut _binding_0, ref mut _binding_1) => {
             _visitor.visit_expr_mut(_binding_0);
-            tokens_helper(_visitor, &mut (_binding_1).0);
+            tokens_helper(_visitor, &mut _binding_1.spans);
         }
     }
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_trait_bound_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut TraitBound) {
     if let Some(ref mut it) = _i.paren_token {
-        tokens_helper(_visitor, &mut (it).0)
+        tokens_helper(_visitor, &mut it.span)
     };
     _visitor.visit_trait_bound_modifier_mut(&mut _i.modifier);
     if let Some(ref mut it) = _i.lifetimes {
@@ -2868,7 +2868,7 @@
     match *_i {
         TraitBoundModifier::None => {}
         TraitBoundModifier::Maybe(ref mut _binding_0) => {
-            tokens_helper(_visitor, &mut (_binding_0).0);
+            tokens_helper(_visitor, &mut _binding_0.spans);
         }
     }
 }
@@ -2897,15 +2897,15 @@
     for it in &mut _i.attrs {
         _visitor.visit_attribute_mut(it)
     }
-    tokens_helper(_visitor, &mut (_i.const_token).0);
+    tokens_helper(_visitor, &mut _i.const_token.span);
     _visitor.visit_ident_mut(&mut _i.ident);
-    tokens_helper(_visitor, &mut (_i.colon_token).0);
+    tokens_helper(_visitor, &mut _i.colon_token.spans);
     _visitor.visit_type_mut(&mut _i.ty);
     if let Some(ref mut it) = _i.default {
-        tokens_helper(_visitor, &mut ((it).0).0);
+        tokens_helper(_visitor, &mut (it).0.spans);
         _visitor.visit_expr_mut(&mut (it).1);
     };
-    tokens_helper(_visitor, &mut (_i.semi_token).0);
+    tokens_helper(_visitor, &mut _i.semi_token.spans);
 }
 #[cfg(feature = "full")]
 pub fn visit_trait_item_macro_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut TraitItemMacro) {
@@ -2914,7 +2914,7 @@
     }
     _visitor.visit_macro_mut(&mut _i.mac);
     if let Some(ref mut it) = _i.semi_token {
-        tokens_helper(_visitor, &mut (it).0)
+        tokens_helper(_visitor, &mut it.spans)
     };
 }
 #[cfg(feature = "full")]
@@ -2930,7 +2930,7 @@
         _visitor.visit_block_mut(it)
     };
     if let Some(ref mut it) = _i.semi_token {
-        tokens_helper(_visitor, &mut (it).0)
+        tokens_helper(_visitor, &mut it.spans)
     };
 }
 #[cfg(feature = "full")]
@@ -2938,21 +2938,21 @@
     for it in &mut _i.attrs {
         _visitor.visit_attribute_mut(it)
     }
-    tokens_helper(_visitor, &mut (_i.type_token).0);
+    tokens_helper(_visitor, &mut _i.type_token.span);
     _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)
+        tokens_helper(_visitor, &mut it.spans)
     };
     for mut el in Punctuated::pairs_mut(&mut _i.bounds) {
         let it = el.value_mut();
         _visitor.visit_type_param_bound_mut(it)
     }
     if let Some(ref mut it) = _i.default {
-        tokens_helper(_visitor, &mut ((it).0).0);
+        tokens_helper(_visitor, &mut (it).0.spans);
         _visitor.visit_type_mut(&mut (it).1);
     };
-    tokens_helper(_visitor, &mut (_i.semi_token).0);
+    tokens_helper(_visitor, &mut _i.semi_token.spans);
 }
 #[cfg(feature = "full")]
 pub fn visit_trait_item_verbatim_mut<V: VisitMut + ?Sized>(
@@ -3013,41 +3013,41 @@
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_type_array_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut TypeArray) {
-    tokens_helper(_visitor, &mut (_i.bracket_token).0);
+    tokens_helper(_visitor, &mut _i.bracket_token.span);
     _visitor.visit_type_mut(&mut *_i.elem);
-    tokens_helper(_visitor, &mut (_i.semi_token).0);
+    tokens_helper(_visitor, &mut _i.semi_token.spans);
     _visitor.visit_expr_mut(&mut _i.len);
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_type_bare_fn_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut TypeBareFn) {
     if let Some(ref mut it) = _i.unsafety {
-        tokens_helper(_visitor, &mut (it).0)
+        tokens_helper(_visitor, &mut it.span)
     };
     if let Some(ref mut it) = _i.abi {
         _visitor.visit_abi_mut(it)
     };
-    tokens_helper(_visitor, &mut (_i.fn_token).0);
+    tokens_helper(_visitor, &mut _i.fn_token.span);
     if let Some(ref mut it) = _i.lifetimes {
         _visitor.visit_bound_lifetimes_mut(it)
     };
-    tokens_helper(_visitor, &mut (_i.paren_token).0);
+    tokens_helper(_visitor, &mut _i.paren_token.span);
     for mut el in Punctuated::pairs_mut(&mut _i.inputs) {
         let it = el.value_mut();
         _visitor.visit_bare_fn_arg_mut(it)
     }
     if let Some(ref mut it) = _i.variadic {
-        tokens_helper(_visitor, &mut (it).0)
+        tokens_helper(_visitor, &mut it.spans)
     };
     _visitor.visit_return_type_mut(&mut _i.output);
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_type_group_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut TypeGroup) {
-    tokens_helper(_visitor, &mut (_i.group_token).0);
+    tokens_helper(_visitor, &mut _i.group_token.span);
     _visitor.visit_type_mut(&mut *_i.elem);
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_type_impl_trait_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut TypeImplTrait) {
-    tokens_helper(_visitor, &mut (_i.impl_token).0);
+    tokens_helper(_visitor, &mut _i.impl_token.span);
     for mut el in Punctuated::pairs_mut(&mut _i.bounds) {
         let it = el.value_mut();
         _visitor.visit_type_param_bound_mut(it)
@@ -3055,7 +3055,7 @@
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_type_infer_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut TypeInfer) {
-    tokens_helper(_visitor, &mut (_i.underscore_token).0);
+    tokens_helper(_visitor, &mut _i.underscore_token.spans);
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_type_macro_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut TypeMacro) {
@@ -3063,7 +3063,7 @@
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_type_never_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut TypeNever) {
-    tokens_helper(_visitor, &mut (_i.bang_token).0);
+    tokens_helper(_visitor, &mut _i.bang_token.spans);
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_type_param_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut TypeParam) {
@@ -3072,14 +3072,14 @@
     }
     _visitor.visit_ident_mut(&mut _i.ident);
     if let Some(ref mut it) = _i.colon_token {
-        tokens_helper(_visitor, &mut (it).0)
+        tokens_helper(_visitor, &mut it.spans)
     };
     for mut el in Punctuated::pairs_mut(&mut _i.bounds) {
         let it = el.value_mut();
         _visitor.visit_type_param_bound_mut(it)
     }
     if let Some(ref mut it) = _i.eq_token {
-        tokens_helper(_visitor, &mut (it).0)
+        tokens_helper(_visitor, &mut it.spans)
     };
     if let Some(ref mut it) = _i.default {
         _visitor.visit_type_mut(it)
@@ -3098,7 +3098,7 @@
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_type_paren_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut TypeParen) {
-    tokens_helper(_visitor, &mut (_i.paren_token).0);
+    tokens_helper(_visitor, &mut _i.paren_token.span);
     _visitor.visit_type_mut(&mut *_i.elem);
 }
 #[cfg(any(feature = "full", feature = "derive"))]
@@ -3110,29 +3110,29 @@
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_type_ptr_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut TypePtr) {
-    tokens_helper(_visitor, &mut (_i.star_token).0);
+    tokens_helper(_visitor, &mut _i.star_token.spans);
     if let Some(ref mut it) = _i.const_token {
-        tokens_helper(_visitor, &mut (it).0)
+        tokens_helper(_visitor, &mut it.span)
     };
     if let Some(ref mut it) = _i.mutability {
-        tokens_helper(_visitor, &mut (it).0)
+        tokens_helper(_visitor, &mut it.span)
     };
     _visitor.visit_type_mut(&mut *_i.elem);
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_type_reference_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut TypeReference) {
-    tokens_helper(_visitor, &mut (_i.and_token).0);
+    tokens_helper(_visitor, &mut _i.and_token.spans);
     if let Some(ref mut it) = _i.lifetime {
         _visitor.visit_lifetime_mut(it)
     };
     if let Some(ref mut it) = _i.mutability {
-        tokens_helper(_visitor, &mut (it).0)
+        tokens_helper(_visitor, &mut it.span)
     };
     _visitor.visit_type_mut(&mut *_i.elem);
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_type_slice_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut TypeSlice) {
-    tokens_helper(_visitor, &mut (_i.bracket_token).0);
+    tokens_helper(_visitor, &mut _i.bracket_token.span);
     _visitor.visit_type_mut(&mut *_i.elem);
 }
 #[cfg(any(feature = "full", feature = "derive"))]
@@ -3141,7 +3141,7 @@
     _i: &mut TypeTraitObject,
 ) {
     if let Some(ref mut it) = _i.dyn_token {
-        tokens_helper(_visitor, &mut (it).0)
+        tokens_helper(_visitor, &mut it.span)
     };
     for mut el in Punctuated::pairs_mut(&mut _i.bounds) {
         let it = el.value_mut();
@@ -3150,7 +3150,7 @@
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_type_tuple_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut TypeTuple) {
-    tokens_helper(_visitor, &mut (_i.paren_token).0);
+    tokens_helper(_visitor, &mut _i.paren_token.span);
     for mut el in Punctuated::pairs_mut(&mut _i.elems) {
         let it = el.value_mut();
         _visitor.visit_type_mut(it)
@@ -3164,23 +3164,23 @@
 pub fn visit_un_op_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut UnOp) {
     match *_i {
         UnOp::Deref(ref mut _binding_0) => {
-            tokens_helper(_visitor, &mut (_binding_0).0);
+            tokens_helper(_visitor, &mut _binding_0.spans);
         }
         UnOp::Not(ref mut _binding_0) => {
-            tokens_helper(_visitor, &mut (_binding_0).0);
+            tokens_helper(_visitor, &mut _binding_0.spans);
         }
         UnOp::Neg(ref mut _binding_0) => {
-            tokens_helper(_visitor, &mut (_binding_0).0);
+            tokens_helper(_visitor, &mut _binding_0.spans);
         }
     }
 }
 #[cfg(feature = "full")]
 pub fn visit_use_glob_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut UseGlob) {
-    tokens_helper(_visitor, &mut (_i.star_token).0);
+    tokens_helper(_visitor, &mut _i.star_token.spans);
 }
 #[cfg(feature = "full")]
 pub fn visit_use_group_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut UseGroup) {
-    tokens_helper(_visitor, &mut (_i.brace_token).0);
+    tokens_helper(_visitor, &mut _i.brace_token.span);
     for mut el in Punctuated::pairs_mut(&mut _i.items) {
         let it = el.value_mut();
         _visitor.visit_use_tree_mut(it)
@@ -3193,13 +3193,13 @@
 #[cfg(feature = "full")]
 pub fn visit_use_path_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut UsePath) {
     _visitor.visit_ident_mut(&mut _i.ident);
-    tokens_helper(_visitor, &mut (_i.colon2_token).0);
+    tokens_helper(_visitor, &mut _i.colon2_token.spans);
     _visitor.visit_use_tree_mut(&mut *_i.tree);
 }
 #[cfg(feature = "full")]
 pub fn visit_use_rename_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut UseRename) {
     _visitor.visit_ident_mut(&mut _i.ident);
-    tokens_helper(_visitor, &mut (_i.as_token).0);
+    tokens_helper(_visitor, &mut _i.as_token.span);
     _visitor.visit_ident_mut(&mut _i.rename);
 }
 #[cfg(feature = "full")]
@@ -3230,24 +3230,24 @@
     _visitor.visit_ident_mut(&mut _i.ident);
     _visitor.visit_fields_mut(&mut _i.fields);
     if let Some(ref mut it) = _i.discriminant {
-        tokens_helper(_visitor, &mut ((it).0).0);
+        tokens_helper(_visitor, &mut (it).0.spans);
         _visitor.visit_expr_mut(&mut (it).1);
     };
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_vis_crate_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut VisCrate) {
-    tokens_helper(_visitor, &mut (_i.crate_token).0);
+    tokens_helper(_visitor, &mut _i.crate_token.span);
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_vis_public_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut VisPublic) {
-    tokens_helper(_visitor, &mut (_i.pub_token).0);
+    tokens_helper(_visitor, &mut _i.pub_token.span);
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_vis_restricted_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut VisRestricted) {
-    tokens_helper(_visitor, &mut (_i.pub_token).0);
-    tokens_helper(_visitor, &mut (_i.paren_token).0);
+    tokens_helper(_visitor, &mut _i.pub_token.span);
+    tokens_helper(_visitor, &mut _i.paren_token.span);
     if let Some(ref mut it) = _i.in_token {
-        tokens_helper(_visitor, &mut (it).0)
+        tokens_helper(_visitor, &mut it.span)
     };
     _visitor.visit_path_mut(&mut *_i.path);
 }
@@ -3268,7 +3268,7 @@
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_where_clause_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut WhereClause) {
-    tokens_helper(_visitor, &mut (_i.where_token).0);
+    tokens_helper(_visitor, &mut _i.where_token.span);
     for mut el in Punctuated::pairs_mut(&mut _i.predicates) {
         let it = el.value_mut();
         _visitor.visit_where_predicate_mut(it)
diff --git a/src/generics.rs b/src/generics.rs
index d1f4fa2..fb8d672 100644
--- a/src/generics.rs
+++ b/src/generics.rs
@@ -601,7 +601,7 @@
                 ident: id,
                 bounds: bounds.unwrap_or_default(),
                 colon_token: colon,
-                eq_token: default.as_ref().map(|d| Token![=]((d.0).0)),
+                eq_token: default.as_ref().map(|d| Token![=](d.0.spans)),
                 default: default.map(|d| d.1),
             })
         ));
diff --git a/src/token.rs b/src/token.rs
index 0fe8c4d..aa098c7 100644
--- a/src/token.rs
+++ b/src/token.rs
@@ -112,7 +112,7 @@
         }
     ) => (
         $(token_punct_def! { #[$punct_doc] pub struct $punct_name/$len })*
-        $(token_punct_parser! { $punct pub struct $punct_name })*
+        $(token_punct_parser! { $punct pub struct $punct_name/$len })*
         $(token_delimiter! { #[$delimiter_doc] $delimiter pub struct $delimiter_name })*
         $(token_keyword! { #[$keyword_doc] $keyword pub struct $keyword_name })*
     )
@@ -127,12 +127,14 @@
         /// macro instead.
         ///
         /// [`Token!`]: index.html
-        pub struct $name(pub [Span; $len]);
+        pub struct $name {
+            pub spans: [Span; $len],
+        }
 
-        impl $name {
-            pub fn new(span: Span) -> Self {
-                $name([span; $len])
-            }
+        #[doc(hidden)]
+        #[allow(non_snake_case)]
+        pub fn $name<S: IntoSpans<[Span; $len]>>(spans: S) -> $name {
+            $name { spans: spans.into_spans() }
         }
 
         impl ::std::default::Default for $name {
@@ -176,18 +178,18 @@
 }
 
 macro_rules! token_punct_parser {
-    ($s:tt pub struct $name:ident) => {
+    ($s:tt pub struct $name:ident/$len:tt) => {
         #[cfg(feature = "printing")]
         impl ::quote::ToTokens for $name {
             fn to_tokens(&self, tokens: &mut ::proc_macro2::TokenStream) {
-                printing::punct($s, &self.0, tokens);
+                printing::punct($s, &self.spans, tokens);
             }
         }
 
         #[cfg(feature = "parsing")]
         impl ::Synom for $name {
             fn parse(tokens: $crate::buffer::Cursor) -> $crate::synom::PResult<$name> {
-                parsing::punct($s, tokens, $name)
+                parsing::punct($s, tokens, $name::<[Span; $len]>)
             }
 
             fn description() -> Option<&'static str> {
@@ -206,7 +208,15 @@
         /// macro instead.
         ///
         /// [`Token!`]: index.html
-        pub struct $name(pub Span);
+        pub struct $name {
+            pub span: Span,
+        }
+
+        #[doc(hidden)]
+        #[allow(non_snake_case)]
+        pub fn $name<S: IntoSpans<[Span; 1]>>(span: S) -> $name {
+            $name { span: span.into_spans()[0] }
+        }
 
         impl ::std::default::Default for $name {
             fn default() -> Self {
@@ -243,7 +253,7 @@
         #[cfg(feature = "printing")]
         impl ::quote::ToTokens for $name {
             fn to_tokens(&self, tokens: &mut ::proc_macro2::TokenStream) {
-                printing::keyword($s, &self.0, tokens);
+                printing::keyword($s, &self.span, tokens);
             }
         }
 
@@ -270,7 +280,15 @@
     (#[$doc:meta] $s:tt pub struct $name:ident) => {
         #[cfg_attr(feature = "clone-impls", derive(Copy, Clone))]
         #[$doc]
-        pub struct $name(pub Span);
+        pub struct $name {
+            pub span: Span,
+        }
+
+        #[doc(hidden)]
+        #[allow(non_snake_case)]
+        pub fn $name<S: IntoSpans<[Span; 1]>>(span: S) -> $name {
+            $name { span: span.into_spans()[0] }
+        }
 
         impl ::std::default::Default for $name {
             fn default() -> Self {
@@ -310,7 +328,7 @@
             where
                 F: FnOnce(&mut ::proc_macro2::TokenStream),
             {
-                printing::delim($s, &self.0, tokens, f);
+                printing::delim($s, &self.span, tokens, f);
             }
 
             #[cfg(feature = "parsing")]
@@ -342,7 +360,7 @@
 impl ::quote::ToTokens for Underscore {
     fn to_tokens(&self, tokens: &mut ::proc_macro2::TokenStream) {
         use quote::TokenStreamExt;
-        tokens.append(::proc_macro2::Ident::new("_", self.0[0]));
+        tokens.append(::proc_macro2::Ident::new("_", self.spans[0]));
     }
 }
 
@@ -357,7 +375,7 @@
                     ::parse_error()
                 }
             }
-            None => parsing::punct("_", input, Underscore),
+            None => parsing::punct("_", input, Underscore::<[Span; 1]>),
         }
     }
 
@@ -375,7 +393,7 @@
 #[cfg(not(feature = "clone-impls"))]
 impl Clone for Apostrophe {
     fn clone(&self) -> Self {
-        Apostrophe(self.0)
+        Apostrophe(self.spans)
     }
 }
 
@@ -384,7 +402,7 @@
     fn to_tokens(&self, tokens: &mut ::proc_macro2::TokenStream) {
         use quote::TokenStreamExt;
         let mut token = ::proc_macro2::Punct::new('\'', ::proc_macro2::Spacing::Joint);
-        token.set_span(self.0[0]);
+        token.set_span(self.spans[0]);
         tokens.append(token);
     }
 }
@@ -732,7 +750,7 @@
     ($token:ident) => {
         impl From<Token![$token]> for Ident {
             fn from(token: Token![$token]) -> Ident {
-                Ident::new(stringify!($token), token.0)
+                Ident::new(stringify!($token), token.span)
             }
         }
     };
@@ -744,6 +762,48 @@
 ident_from_token!(crate);
 ident_from_token!(extern);
 
+// Not public API.
+#[doc(hidden)]
+pub trait IntoSpans<S> {
+    fn into_spans(self) -> S;
+}
+
+impl IntoSpans<[Span; 1]> for Span {
+    fn into_spans(self) -> [Span; 1] {
+        [self]
+    }
+}
+
+impl IntoSpans<[Span; 2]> for Span {
+    fn into_spans(self) -> [Span; 2] {
+        [self, self]
+    }
+}
+
+impl IntoSpans<[Span; 3]> for Span {
+    fn into_spans(self) -> [Span; 3] {
+        [self, self, self]
+    }
+}
+
+impl IntoSpans<Self> for [Span; 1] {
+    fn into_spans(self) -> Self {
+        self
+    }
+}
+
+impl IntoSpans<Self> for [Span; 2] {
+    fn into_spans(self) -> Self {
+        self
+    }
+}
+
+impl IntoSpans<Self> for [Span; 3] {
+    fn into_spans(self) -> Self {
+        self
+    }
+}
+
 #[cfg(feature = "parsing")]
 mod parsing {
     use proc_macro2::{Delimiter, Spacing, Span};
diff --git a/src/ty.rs b/src/ty.rs
index 1ee46d0..81e4df5 100644
--- a/src/ty.rs
+++ b/src/ty.rs
@@ -700,8 +700,8 @@
                 self.inputs.to_tokens(tokens);
                 if let Some(ref variadic) = self.variadic {
                     if !self.inputs.empty_or_trailing() {
-                        let span = variadic.0[0];
-                        <Token![,]>::new(span).to_tokens(tokens);
+                        let span = variadic.spans[0];
+                        Token![,](span).to_tokens(tokens);
                     }
                     variadic.to_tokens(tokens);
                 }