Upgrade rust/crates/syn to 1.0.73

Test: make
Change-Id: Ibc157381aa2b83e8d6e9a2780ca45f7e86009ddf

19 files changed, 920 insertions, 794 deletions

diff --git a/.cargo_vcs_info.json b/.cargo_vcs_info.json
index a9421b03..48538741 100644
--- a/.cargo_vcs_info.json
+++ b/.cargo_vcs_info.json
@@ -1,5 +1,5 @@
 {
   "git": {
-    "sha1": "c3f9c67ee210f00e8119d7d1485455dad40f2e7b"
+    "sha1": "82ac4e6dc30495e936a9228d7dd6b2528fd48900"
   }
 }
diff --git a/Android.bp b/Android.bp
index 073babc7..72e3191c 100644
--- a/Android.bp
+++ b/Android.bp
@@ -65,6 +65,6 @@ rust_library_host {
 }
 
 // dependent_library ["feature_list"]
-//   proc-macro2-1.0.26 "default,proc-macro"
+//   proc-macro2-1.0.27 "default,proc-macro"
 //   quote-1.0.9 "default,proc-macro"
 //   unicode-xid-0.2.2 "default"
diff --git a/Cargo.toml b/Cargo.toml
index dabb66df..c5c347f7 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -13,7 +13,7 @@
 [package]
 edition = "2018"
 name = "syn"
-version = "1.0.72"
+version = "1.0.73"
 authors = ["David Tolnay <dtolnay@gmail.com>"]
 include = ["/benches/**", "/build.rs", "/Cargo.toml", "/LICENSE-APACHE", "/LICENSE-MIT", "/README.md", "/src/**", "/tests/**"]
 description = "Parser for Rust source code"
diff --git a/Cargo.toml.orig b/Cargo.toml.orig
index d2ba383b..d7d070ef 100644
--- a/Cargo.toml.orig
+++ b/Cargo.toml.orig
@@ -1,6 +1,6 @@
 [package]
 name = "syn"
-version = "1.0.72" # don't forget to update html_root_url and syn.json
+version = "1.0.73" # don't forget to update html_root_url and syn.json
 authors = ["David Tolnay <dtolnay@gmail.com>"]
 license = "MIT OR Apache-2.0"
 description = "Parser for Rust source code"
diff --git a/METADATA b/METADATA
index 73047904..9bc1bf24 100644
--- a/METADATA
+++ b/METADATA
@@ -7,13 +7,13 @@ third_party {
   }
   url {
     type: ARCHIVE
-    value: "https://static.crates.io/crates/syn/syn-1.0.72.crate"
+    value: "https://static.crates.io/crates/syn/syn-1.0.73.crate"
   }
-  version: "1.0.72"
+  version: "1.0.73"
   license_type: NOTICE
   last_upgrade_date {
     year: 2021
-    month: 5
-    day: 19
+    month: 6
+    day: 21
   }
 }
diff --git a/TEST_MAPPING b/TEST_MAPPING
index 32f62ad6..ad0ca480 100644
--- a/TEST_MAPPING
+++ b/TEST_MAPPING
@@ -2,9 +2,6 @@
 {
   "presubmit": [
     {
-      "name": "ZipFuseTest"
-    },
-    {
       "name": "anyhow_device_test_src_lib"
     },
     {
@@ -41,9 +38,6 @@
       "name": "anyhow_device_test_tests_test_source"
     },
     {
-      "name": "authfs_device_test_src_lib"
-    },
-    {
       "name": "doh_unit_test"
     },
     {
@@ -98,6 +92,15 @@
       "name": "serde_test_device_test_src_lib"
     },
     {
+      "name": "slab_device_test_src_lib"
+    },
+    {
+      "name": "slab_device_test_tests_serde"
+    },
+    {
+      "name": "slab_device_test_tests_slab"
+    },
+    {
       "name": "tokio-test_device_test_src_lib"
     },
     {
@@ -110,15 +113,33 @@
       "name": "tokio-test_device_test_tests_macros"
     },
     {
+      "name": "tokio_device_test_tests__require_full"
+    },
+    {
       "name": "tokio_device_test_tests_buffered"
     },
     {
+      "name": "tokio_device_test_tests_io_async_fd"
+    },
+    {
       "name": "tokio_device_test_tests_io_async_read"
     },
     {
+      "name": "tokio_device_test_tests_io_chain"
+    },
+    {
+      "name": "tokio_device_test_tests_io_copy"
+    },
+    {
       "name": "tokio_device_test_tests_io_copy_bidirectional"
     },
     {
+      "name": "tokio_device_test_tests_io_driver"
+    },
+    {
+      "name": "tokio_device_test_tests_io_driver_drop"
+    },
+    {
       "name": "tokio_device_test_tests_io_lines"
     },
     {
@@ -131,9 +152,24 @@
       "name": "tokio_device_test_tests_io_read_buf"
     },
     {
+      "name": "tokio_device_test_tests_io_read_exact"
+    },
+    {
+      "name": "tokio_device_test_tests_io_read_line"
+    },
+    {
       "name": "tokio_device_test_tests_io_read_to_end"
     },
     {
+      "name": "tokio_device_test_tests_io_read_to_string"
+    },
+    {
+      "name": "tokio_device_test_tests_io_read_until"
+    },
+    {
+      "name": "tokio_device_test_tests_io_split"
+    },
+    {
       "name": "tokio_device_test_tests_io_take"
     },
     {
@@ -152,12 +188,36 @@
       "name": "tokio_device_test_tests_macros_join"
     },
     {
+      "name": "tokio_device_test_tests_macros_pin"
+    },
+    {
+      "name": "tokio_device_test_tests_macros_select"
+    },
+    {
+      "name": "tokio_device_test_tests_macros_test"
+    },
+    {
+      "name": "tokio_device_test_tests_macros_try_join"
+    },
+    {
+      "name": "tokio_device_test_tests_net_bind_resource"
+    },
+    {
+      "name": "tokio_device_test_tests_net_lookup_host"
+    },
+    {
       "name": "tokio_device_test_tests_no_rt"
     },
     {
+      "name": "tokio_device_test_tests_process_kill_on_drop"
+    },
+    {
       "name": "tokio_device_test_tests_rt_basic"
     },
     {
+      "name": "tokio_device_test_tests_rt_common"
+    },
+    {
       "name": "tokio_device_test_tests_rt_threaded"
     },
     {
@@ -173,15 +233,36 @@
       "name": "tokio_device_test_tests_sync_mpsc"
     },
     {
+      "name": "tokio_device_test_tests_sync_mutex"
+    },
+    {
       "name": "tokio_device_test_tests_sync_mutex_owned"
     },
     {
+      "name": "tokio_device_test_tests_sync_notify"
+    },
+    {
+      "name": "tokio_device_test_tests_sync_oneshot"
+    },
+    {
       "name": "tokio_device_test_tests_sync_rwlock"
     },
     {
+      "name": "tokio_device_test_tests_sync_semaphore"
+    },
+    {
+      "name": "tokio_device_test_tests_sync_semaphore_owned"
+    },
+    {
       "name": "tokio_device_test_tests_sync_watch"
     },
     {
+      "name": "tokio_device_test_tests_task_abort"
+    },
+    {
+      "name": "tokio_device_test_tests_task_blocking"
+    },
+    {
       "name": "tokio_device_test_tests_task_local"
     },
     {
@@ -191,24 +272,51 @@
       "name": "tokio_device_test_tests_tcp_accept"
     },
     {
+      "name": "tokio_device_test_tests_tcp_connect"
+    },
+    {
       "name": "tokio_device_test_tests_tcp_echo"
     },
     {
+      "name": "tokio_device_test_tests_tcp_into_split"
+    },
+    {
       "name": "tokio_device_test_tests_tcp_into_std"
     },
     {
+      "name": "tokio_device_test_tests_tcp_peek"
+    },
+    {
       "name": "tokio_device_test_tests_tcp_shutdown"
     },
     {
+      "name": "tokio_device_test_tests_tcp_socket"
+    },
+    {
+      "name": "tokio_device_test_tests_tcp_split"
+    },
+    {
       "name": "tokio_device_test_tests_time_rt"
     },
     {
+      "name": "tokio_device_test_tests_udp"
+    },
+    {
+      "name": "tokio_device_test_tests_uds_cred"
+    },
+    {
       "name": "tokio_device_test_tests_uds_split"
     },
     {
       "name": "unicode-bidi_device_test_src_lib"
     },
     {
+      "name": "unicode-xid_device_test_src_lib"
+    },
+    {
+      "name": "unicode-xid_device_test_tests_exhaustive_tests"
+    },
+    {
       "name": "url_device_test_src_lib"
     },
     {
diff --git a/src/attr.rs b/src/attr.rs
index 505ffeb7..5d6877ae 100644
--- a/src/attr.rs
+++ b/src/attr.rs
@@ -649,7 +649,7 @@ mod printing {
             self.path.to_tokens(tokens);
             self.paren_token.surround(tokens, |tokens| {
                 self.nested.to_tokens(tokens);
-            })
+            });
         }
     }
 
diff --git a/src/data.rs b/src/data.rs
index b0258ca0..837224e1 100644
--- a/src/data.rs
+++ b/src/data.rs
@@ -475,7 +475,7 @@ mod printing {
     #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
     impl ToTokens for VisPublic {
         fn to_tokens(&self, tokens: &mut TokenStream) {
-            self.pub_token.to_tokens(tokens)
+            self.pub_token.to_tokens(tokens);
         }
     }
 
diff --git a/src/discouraged.rs b/src/discouraged.rs
index 76c9fce6..a46129b6 100644
--- a/src/discouraged.rs
+++ b/src/discouraged.rs
@@ -189,6 +189,6 @@ impl<'a> Speculative for ParseBuffer<'a> {
 
         // See comment on `cell` in the struct definition.
         self.cell
-            .set(unsafe { mem::transmute::<Cursor, Cursor<'static>>(fork.cursor()) })
+            .set(unsafe { mem::transmute::<Cursor, Cursor<'static>>(fork.cursor()) });
     }
 }
diff --git a/src/error.rs b/src/error.rs
index 780731c8..e2f23821 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -236,7 +236,7 @@ impl Error {
     /// Add another error message to self such that when `to_compile_error()` is
     /// called, both errors will be emitted together.
     pub fn combine(&mut self, another: Error) {
-        self.messages.extend(another.messages)
+        self.messages.extend(another.messages);
     }
 }
 
diff --git a/src/expr.rs b/src/expr.rs
index ef629ecd..24f79117 100644
--- a/src/expr.rs
+++ b/src/expr.rs
@@ -851,6 +851,24 @@ ast_enum! {
     }
 }
 
+impl From<Ident> for Member {
+    fn from(ident: Ident) -> Member {
+        Member::Named(ident)
+    }
+}
+
+impl From<Index> for Member {
+    fn from(index: Index) -> Member {
+        Member::Unnamed(index)
+    }
+}
+
+impl From<usize> for Member {
+    fn from(index: usize) -> Member {
+        Member::Unnamed(Index::from(index))
+    }
+}
+
 impl Eq for Member {}
 
 impl PartialEq for Member {
@@ -2926,7 +2944,7 @@ pub(crate) mod printing {
             self.bracket_token.surround(tokens, |tokens| {
                 inner_attrs_to_tokens(&self.attrs, tokens);
                 self.elems.to_tokens(tokens);
-            })
+            });
         }
     }
 
@@ -2937,7 +2955,7 @@ pub(crate) mod printing {
             self.func.to_tokens(tokens);
             self.paren_token.surround(tokens, |tokens| {
                 self.args.to_tokens(tokens);
-            })
+            });
         }
     }
 
@@ -2991,7 +3009,7 @@ pub(crate) mod printing {
                 if self.elems.len() == 1 && !self.elems.trailing_punct() {
                     <Token![,]>::default().to_tokens(tokens);
                 }
-            })
+            });
         }
     }
 
@@ -3389,7 +3407,7 @@ pub(crate) mod printing {
                     Token![..](Span::call_site()).to_tokens(tokens);
                 }
                 self.rest.to_tokens(tokens);
-            })
+            });
         }
     }
 
@@ -3403,7 +3421,7 @@ pub(crate) mod printing {
                 self.expr.to_tokens(tokens);
                 self.semi_token.to_tokens(tokens);
                 self.len.to_tokens(tokens);
-            })
+            });
         }
     }
 
diff --git a/src/gen/visit.rs b/src/gen/visit.rs
index 24d34b74..6eaee24c 100644
--- a/src/gen/visit.rs
+++ b/src/gen/visit.rs
@@ -33,740 +33,740 @@ macro_rules! skip {
 pub trait Visit<'ast> {
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_abi(&mut self, i: &'ast Abi) {
-        visit_abi(self, i)
+        visit_abi(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_angle_bracketed_generic_arguments(&mut self, i: &'ast AngleBracketedGenericArguments) {
-        visit_angle_bracketed_generic_arguments(self, i)
+        visit_angle_bracketed_generic_arguments(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_arm(&mut self, i: &'ast Arm) {
-        visit_arm(self, i)
+        visit_arm(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_attr_style(&mut self, i: &'ast AttrStyle) {
-        visit_attr_style(self, i)
+        visit_attr_style(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_attribute(&mut self, i: &'ast Attribute) {
-        visit_attribute(self, i)
+        visit_attribute(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_bare_fn_arg(&mut self, i: &'ast BareFnArg) {
-        visit_bare_fn_arg(self, i)
+        visit_bare_fn_arg(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_bin_op(&mut self, i: &'ast BinOp) {
-        visit_bin_op(self, i)
+        visit_bin_op(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_binding(&mut self, i: &'ast Binding) {
-        visit_binding(self, i)
+        visit_binding(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_block(&mut self, i: &'ast Block) {
-        visit_block(self, i)
+        visit_block(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_bound_lifetimes(&mut self, i: &'ast BoundLifetimes) {
-        visit_bound_lifetimes(self, i)
+        visit_bound_lifetimes(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_const_param(&mut self, i: &'ast ConstParam) {
-        visit_const_param(self, i)
+        visit_const_param(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_constraint(&mut self, i: &'ast Constraint) {
-        visit_constraint(self, i)
+        visit_constraint(self, i);
     }
     #[cfg(feature = "derive")]
     fn visit_data(&mut self, i: &'ast Data) {
-        visit_data(self, i)
+        visit_data(self, i);
     }
     #[cfg(feature = "derive")]
     fn visit_data_enum(&mut self, i: &'ast DataEnum) {
-        visit_data_enum(self, i)
+        visit_data_enum(self, i);
     }
     #[cfg(feature = "derive")]
     fn visit_data_struct(&mut self, i: &'ast DataStruct) {
-        visit_data_struct(self, i)
+        visit_data_struct(self, i);
     }
     #[cfg(feature = "derive")]
     fn visit_data_union(&mut self, i: &'ast DataUnion) {
-        visit_data_union(self, i)
+        visit_data_union(self, i);
     }
     #[cfg(feature = "derive")]
     fn visit_derive_input(&mut self, i: &'ast DeriveInput) {
-        visit_derive_input(self, i)
+        visit_derive_input(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_expr(&mut self, i: &'ast Expr) {
-        visit_expr(self, i)
+        visit_expr(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_array(&mut self, i: &'ast ExprArray) {
-        visit_expr_array(self, i)
+        visit_expr_array(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_assign(&mut self, i: &'ast ExprAssign) {
-        visit_expr_assign(self, i)
+        visit_expr_assign(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_assign_op(&mut self, i: &'ast ExprAssignOp) {
-        visit_expr_assign_op(self, i)
+        visit_expr_assign_op(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_async(&mut self, i: &'ast ExprAsync) {
-        visit_expr_async(self, i)
+        visit_expr_async(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_await(&mut self, i: &'ast ExprAwait) {
-        visit_expr_await(self, i)
+        visit_expr_await(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_expr_binary(&mut self, i: &'ast ExprBinary) {
-        visit_expr_binary(self, i)
+        visit_expr_binary(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_block(&mut self, i: &'ast ExprBlock) {
-        visit_expr_block(self, i)
+        visit_expr_block(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_box(&mut self, i: &'ast ExprBox) {
-        visit_expr_box(self, i)
+        visit_expr_box(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_break(&mut self, i: &'ast ExprBreak) {
-        visit_expr_break(self, i)
+        visit_expr_break(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_expr_call(&mut self, i: &'ast ExprCall) {
-        visit_expr_call(self, i)
+        visit_expr_call(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_expr_cast(&mut self, i: &'ast ExprCast) {
-        visit_expr_cast(self, i)
+        visit_expr_cast(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_closure(&mut self, i: &'ast ExprClosure) {
-        visit_expr_closure(self, i)
+        visit_expr_closure(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_continue(&mut self, i: &'ast ExprContinue) {
-        visit_expr_continue(self, i)
+        visit_expr_continue(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_expr_field(&mut self, i: &'ast ExprField) {
-        visit_expr_field(self, i)
+        visit_expr_field(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_for_loop(&mut self, i: &'ast ExprForLoop) {
-        visit_expr_for_loop(self, i)
+        visit_expr_for_loop(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_group(&mut self, i: &'ast ExprGroup) {
-        visit_expr_group(self, i)
+        visit_expr_group(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_if(&mut self, i: &'ast ExprIf) {
-        visit_expr_if(self, i)
+        visit_expr_if(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_expr_index(&mut self, i: &'ast ExprIndex) {
-        visit_expr_index(self, i)
+        visit_expr_index(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_let(&mut self, i: &'ast ExprLet) {
-        visit_expr_let(self, i)
+        visit_expr_let(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_expr_lit(&mut self, i: &'ast ExprLit) {
-        visit_expr_lit(self, i)
+        visit_expr_lit(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_loop(&mut self, i: &'ast ExprLoop) {
-        visit_expr_loop(self, i)
+        visit_expr_loop(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_macro(&mut self, i: &'ast ExprMacro) {
-        visit_expr_macro(self, i)
+        visit_expr_macro(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_match(&mut self, i: &'ast ExprMatch) {
-        visit_expr_match(self, i)
+        visit_expr_match(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_method_call(&mut self, i: &'ast ExprMethodCall) {
-        visit_expr_method_call(self, i)
+        visit_expr_method_call(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_expr_paren(&mut self, i: &'ast ExprParen) {
-        visit_expr_paren(self, i)
+        visit_expr_paren(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_expr_path(&mut self, i: &'ast ExprPath) {
-        visit_expr_path(self, i)
+        visit_expr_path(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_range(&mut self, i: &'ast ExprRange) {
-        visit_expr_range(self, i)
+        visit_expr_range(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_reference(&mut self, i: &'ast ExprReference) {
-        visit_expr_reference(self, i)
+        visit_expr_reference(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_repeat(&mut self, i: &'ast ExprRepeat) {
-        visit_expr_repeat(self, i)
+        visit_expr_repeat(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_return(&mut self, i: &'ast ExprReturn) {
-        visit_expr_return(self, i)
+        visit_expr_return(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_struct(&mut self, i: &'ast ExprStruct) {
-        visit_expr_struct(self, i)
+        visit_expr_struct(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_try(&mut self, i: &'ast ExprTry) {
-        visit_expr_try(self, i)
+        visit_expr_try(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_try_block(&mut self, i: &'ast ExprTryBlock) {
-        visit_expr_try_block(self, i)
+        visit_expr_try_block(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_tuple(&mut self, i: &'ast ExprTuple) {
-        visit_expr_tuple(self, i)
+        visit_expr_tuple(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_type(&mut self, i: &'ast ExprType) {
-        visit_expr_type(self, i)
+        visit_expr_type(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_expr_unary(&mut self, i: &'ast ExprUnary) {
-        visit_expr_unary(self, i)
+        visit_expr_unary(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_unsafe(&mut self, i: &'ast ExprUnsafe) {
-        visit_expr_unsafe(self, i)
+        visit_expr_unsafe(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_while(&mut self, i: &'ast ExprWhile) {
-        visit_expr_while(self, i)
+        visit_expr_while(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_yield(&mut self, i: &'ast ExprYield) {
-        visit_expr_yield(self, i)
+        visit_expr_yield(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_field(&mut self, i: &'ast Field) {
-        visit_field(self, i)
+        visit_field(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_field_pat(&mut self, i: &'ast FieldPat) {
-        visit_field_pat(self, i)
+        visit_field_pat(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_field_value(&mut self, i: &'ast FieldValue) {
-        visit_field_value(self, i)
+        visit_field_value(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_fields(&mut self, i: &'ast Fields) {
-        visit_fields(self, i)
+        visit_fields(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_fields_named(&mut self, i: &'ast FieldsNamed) {
-        visit_fields_named(self, i)
+        visit_fields_named(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_fields_unnamed(&mut self, i: &'ast FieldsUnnamed) {
-        visit_fields_unnamed(self, i)
+        visit_fields_unnamed(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_file(&mut self, i: &'ast File) {
-        visit_file(self, i)
+        visit_file(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_fn_arg(&mut self, i: &'ast FnArg) {
-        visit_fn_arg(self, i)
+        visit_fn_arg(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_foreign_item(&mut self, i: &'ast ForeignItem) {
-        visit_foreign_item(self, i)
+        visit_foreign_item(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_foreign_item_fn(&mut self, i: &'ast ForeignItemFn) {
-        visit_foreign_item_fn(self, i)
+        visit_foreign_item_fn(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_foreign_item_macro(&mut self, i: &'ast ForeignItemMacro) {
-        visit_foreign_item_macro(self, i)
+        visit_foreign_item_macro(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_foreign_item_static(&mut self, i: &'ast ForeignItemStatic) {
-        visit_foreign_item_static(self, i)
+        visit_foreign_item_static(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_foreign_item_type(&mut self, i: &'ast ForeignItemType) {
-        visit_foreign_item_type(self, i)
+        visit_foreign_item_type(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_generic_argument(&mut self, i: &'ast GenericArgument) {
-        visit_generic_argument(self, i)
+        visit_generic_argument(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_generic_method_argument(&mut self, i: &'ast GenericMethodArgument) {
-        visit_generic_method_argument(self, i)
+        visit_generic_method_argument(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_generic_param(&mut self, i: &'ast GenericParam) {
-        visit_generic_param(self, i)
+        visit_generic_param(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_generics(&mut self, i: &'ast Generics) {
-        visit_generics(self, i)
+        visit_generics(self, i);
     }
     fn visit_ident(&mut self, i: &'ast Ident) {
-        visit_ident(self, i)
+        visit_ident(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_impl_item(&mut self, i: &'ast ImplItem) {
-        visit_impl_item(self, i)
+        visit_impl_item(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_impl_item_const(&mut self, i: &'ast ImplItemConst) {
-        visit_impl_item_const(self, i)
+        visit_impl_item_const(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_impl_item_macro(&mut self, i: &'ast ImplItemMacro) {
-        visit_impl_item_macro(self, i)
+        visit_impl_item_macro(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_impl_item_method(&mut self, i: &'ast ImplItemMethod) {
-        visit_impl_item_method(self, i)
+        visit_impl_item_method(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_impl_item_type(&mut self, i: &'ast ImplItemType) {
-        visit_impl_item_type(self, i)
+        visit_impl_item_type(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_index(&mut self, i: &'ast Index) {
-        visit_index(self, i)
+        visit_index(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_item(&mut self, i: &'ast Item) {
-        visit_item(self, i)
+        visit_item(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_item_const(&mut self, i: &'ast ItemConst) {
-        visit_item_const(self, i)
+        visit_item_const(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_item_enum(&mut self, i: &'ast ItemEnum) {
-        visit_item_enum(self, i)
+        visit_item_enum(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_item_extern_crate(&mut self, i: &'ast ItemExternCrate) {
-        visit_item_extern_crate(self, i)
+        visit_item_extern_crate(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_item_fn(&mut self, i: &'ast ItemFn) {
-        visit_item_fn(self, i)
+        visit_item_fn(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_item_foreign_mod(&mut self, i: &'ast ItemForeignMod) {
-        visit_item_foreign_mod(self, i)
+        visit_item_foreign_mod(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_item_impl(&mut self, i: &'ast ItemImpl) {
-        visit_item_impl(self, i)
+        visit_item_impl(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_item_macro(&mut self, i: &'ast ItemMacro) {
-        visit_item_macro(self, i)
+        visit_item_macro(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_item_macro2(&mut self, i: &'ast ItemMacro2) {
-        visit_item_macro2(self, i)
+        visit_item_macro2(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_item_mod(&mut self, i: &'ast ItemMod) {
-        visit_item_mod(self, i)
+        visit_item_mod(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_item_static(&mut self, i: &'ast ItemStatic) {
-        visit_item_static(self, i)
+        visit_item_static(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_item_struct(&mut self, i: &'ast ItemStruct) {
-        visit_item_struct(self, i)
+        visit_item_struct(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_item_trait(&mut self, i: &'ast ItemTrait) {
-        visit_item_trait(self, i)
+        visit_item_trait(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_item_trait_alias(&mut self, i: &'ast ItemTraitAlias) {
-        visit_item_trait_alias(self, i)
+        visit_item_trait_alias(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_item_type(&mut self, i: &'ast ItemType) {
-        visit_item_type(self, i)
+        visit_item_type(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_item_union(&mut self, i: &'ast ItemUnion) {
-        visit_item_union(self, i)
+        visit_item_union(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_item_use(&mut self, i: &'ast ItemUse) {
-        visit_item_use(self, i)
+        visit_item_use(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_label(&mut self, i: &'ast Label) {
-        visit_label(self, i)
+        visit_label(self, i);
     }
     fn visit_lifetime(&mut self, i: &'ast Lifetime) {
-        visit_lifetime(self, i)
+        visit_lifetime(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_lifetime_def(&mut self, i: &'ast LifetimeDef) {
-        visit_lifetime_def(self, i)
+        visit_lifetime_def(self, i);
     }
     fn visit_lit(&mut self, i: &'ast Lit) {
-        visit_lit(self, i)
+        visit_lit(self, i);
     }
     fn visit_lit_bool(&mut self, i: &'ast LitBool) {
-        visit_lit_bool(self, i)
+        visit_lit_bool(self, i);
     }
     fn visit_lit_byte(&mut self, i: &'ast LitByte) {
-        visit_lit_byte(self, i)
+        visit_lit_byte(self, i);
     }
     fn visit_lit_byte_str(&mut self, i: &'ast LitByteStr) {
-        visit_lit_byte_str(self, i)
+        visit_lit_byte_str(self, i);
     }
     fn visit_lit_char(&mut self, i: &'ast LitChar) {
-        visit_lit_char(self, i)
+        visit_lit_char(self, i);
     }
     fn visit_lit_float(&mut self, i: &'ast LitFloat) {
-        visit_lit_float(self, i)
+        visit_lit_float(self, i);
     }
     fn visit_lit_int(&mut self, i: &'ast LitInt) {
-        visit_lit_int(self, i)
+        visit_lit_int(self, i);
     }
     fn visit_lit_str(&mut self, i: &'ast LitStr) {
-        visit_lit_str(self, i)
+        visit_lit_str(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_local(&mut self, i: &'ast Local) {
-        visit_local(self, i)
+        visit_local(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_macro(&mut self, i: &'ast Macro) {
-        visit_macro(self, i)
+        visit_macro(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_macro_delimiter(&mut self, i: &'ast MacroDelimiter) {
-        visit_macro_delimiter(self, i)
+        visit_macro_delimiter(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_member(&mut self, i: &'ast Member) {
-        visit_member(self, i)
+        visit_member(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_meta(&mut self, i: &'ast Meta) {
-        visit_meta(self, i)
+        visit_meta(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_meta_list(&mut self, i: &'ast MetaList) {
-        visit_meta_list(self, i)
+        visit_meta_list(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_meta_name_value(&mut self, i: &'ast MetaNameValue) {
-        visit_meta_name_value(self, i)
+        visit_meta_name_value(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_method_turbofish(&mut self, i: &'ast MethodTurbofish) {
-        visit_method_turbofish(self, i)
+        visit_method_turbofish(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_nested_meta(&mut self, i: &'ast NestedMeta) {
-        visit_nested_meta(self, i)
+        visit_nested_meta(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_parenthesized_generic_arguments(&mut self, i: &'ast ParenthesizedGenericArguments) {
-        visit_parenthesized_generic_arguments(self, i)
+        visit_parenthesized_generic_arguments(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_pat(&mut self, i: &'ast Pat) {
-        visit_pat(self, i)
+        visit_pat(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_pat_box(&mut self, i: &'ast PatBox) {
-        visit_pat_box(self, i)
+        visit_pat_box(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_pat_ident(&mut self, i: &'ast PatIdent) {
-        visit_pat_ident(self, i)
+        visit_pat_ident(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_pat_lit(&mut self, i: &'ast PatLit) {
-        visit_pat_lit(self, i)
+        visit_pat_lit(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_pat_macro(&mut self, i: &'ast PatMacro) {
-        visit_pat_macro(self, i)
+        visit_pat_macro(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_pat_or(&mut self, i: &'ast PatOr) {
-        visit_pat_or(self, i)
+        visit_pat_or(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_pat_path(&mut self, i: &'ast PatPath) {
-        visit_pat_path(self, i)
+        visit_pat_path(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_pat_range(&mut self, i: &'ast PatRange) {
-        visit_pat_range(self, i)
+        visit_pat_range(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_pat_reference(&mut self, i: &'ast PatReference) {
-        visit_pat_reference(self, i)
+        visit_pat_reference(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_pat_rest(&mut self, i: &'ast PatRest) {
-        visit_pat_rest(self, i)
+        visit_pat_rest(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_pat_slice(&mut self, i: &'ast PatSlice) {
-        visit_pat_slice(self, i)
+        visit_pat_slice(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_pat_struct(&mut self, i: &'ast PatStruct) {
-        visit_pat_struct(self, i)
+        visit_pat_struct(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_pat_tuple(&mut self, i: &'ast PatTuple) {
-        visit_pat_tuple(self, i)
+        visit_pat_tuple(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_pat_tuple_struct(&mut self, i: &'ast PatTupleStruct) {
-        visit_pat_tuple_struct(self, i)
+        visit_pat_tuple_struct(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_pat_type(&mut self, i: &'ast PatType) {
-        visit_pat_type(self, i)
+        visit_pat_type(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_pat_wild(&mut self, i: &'ast PatWild) {
-        visit_pat_wild(self, i)
+        visit_pat_wild(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_path(&mut self, i: &'ast Path) {
-        visit_path(self, i)
+        visit_path(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_path_arguments(&mut self, i: &'ast PathArguments) {
-        visit_path_arguments(self, i)
+        visit_path_arguments(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_path_segment(&mut self, i: &'ast PathSegment) {
-        visit_path_segment(self, i)
+        visit_path_segment(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_predicate_eq(&mut self, i: &'ast PredicateEq) {
-        visit_predicate_eq(self, i)
+        visit_predicate_eq(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_predicate_lifetime(&mut self, i: &'ast PredicateLifetime) {
-        visit_predicate_lifetime(self, i)
+        visit_predicate_lifetime(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_predicate_type(&mut self, i: &'ast PredicateType) {
-        visit_predicate_type(self, i)
+        visit_predicate_type(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_qself(&mut self, i: &'ast QSelf) {
-        visit_qself(self, i)
+        visit_qself(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_range_limits(&mut self, i: &'ast RangeLimits) {
-        visit_range_limits(self, i)
+        visit_range_limits(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_receiver(&mut self, i: &'ast Receiver) {
-        visit_receiver(self, i)
+        visit_receiver(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_return_type(&mut self, i: &'ast ReturnType) {
-        visit_return_type(self, i)
+        visit_return_type(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_signature(&mut self, i: &'ast Signature) {
-        visit_signature(self, i)
+        visit_signature(self, i);
     }
     fn visit_span(&mut self, i: &Span) {
-        visit_span(self, i)
+        visit_span(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_stmt(&mut self, i: &'ast Stmt) {
-        visit_stmt(self, i)
+        visit_stmt(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_trait_bound(&mut self, i: &'ast TraitBound) {
-        visit_trait_bound(self, i)
+        visit_trait_bound(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_trait_bound_modifier(&mut self, i: &'ast TraitBoundModifier) {
-        visit_trait_bound_modifier(self, i)
+        visit_trait_bound_modifier(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_trait_item(&mut self, i: &'ast TraitItem) {
-        visit_trait_item(self, i)
+        visit_trait_item(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_trait_item_const(&mut self, i: &'ast TraitItemConst) {
-        visit_trait_item_const(self, i)
+        visit_trait_item_const(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_trait_item_macro(&mut self, i: &'ast TraitItemMacro) {
-        visit_trait_item_macro(self, i)
+        visit_trait_item_macro(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_trait_item_method(&mut self, i: &'ast TraitItemMethod) {
-        visit_trait_item_method(self, i)
+        visit_trait_item_method(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_trait_item_type(&mut self, i: &'ast TraitItemType) {
-        visit_trait_item_type(self, i)
+        visit_trait_item_type(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type(&mut self, i: &'ast Type) {
-        visit_type(self, i)
+        visit_type(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_array(&mut self, i: &'ast TypeArray) {
-        visit_type_array(self, i)
+        visit_type_array(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_bare_fn(&mut self, i: &'ast TypeBareFn) {
-        visit_type_bare_fn(self, i)
+        visit_type_bare_fn(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_group(&mut self, i: &'ast TypeGroup) {
-        visit_type_group(self, i)
+        visit_type_group(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_impl_trait(&mut self, i: &'ast TypeImplTrait) {
-        visit_type_impl_trait(self, i)
+        visit_type_impl_trait(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_infer(&mut self, i: &'ast TypeInfer) {
-        visit_type_infer(self, i)
+        visit_type_infer(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_macro(&mut self, i: &'ast TypeMacro) {
-        visit_type_macro(self, i)
+        visit_type_macro(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_never(&mut self, i: &'ast TypeNever) {
-        visit_type_never(self, i)
+        visit_type_never(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_param(&mut self, i: &'ast TypeParam) {
-        visit_type_param(self, i)
+        visit_type_param(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_param_bound(&mut self, i: &'ast TypeParamBound) {
-        visit_type_param_bound(self, i)
+        visit_type_param_bound(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_paren(&mut self, i: &'ast TypeParen) {
-        visit_type_paren(self, i)
+        visit_type_paren(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_path(&mut self, i: &'ast TypePath) {
-        visit_type_path(self, i)
+        visit_type_path(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_ptr(&mut self, i: &'ast TypePtr) {
-        visit_type_ptr(self, i)
+        visit_type_ptr(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_reference(&mut self, i: &'ast TypeReference) {
-        visit_type_reference(self, i)
+        visit_type_reference(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_slice(&mut self, i: &'ast TypeSlice) {
-        visit_type_slice(self, i)
+        visit_type_slice(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_trait_object(&mut self, i: &'ast TypeTraitObject) {
-        visit_type_trait_object(self, i)
+        visit_type_trait_object(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_tuple(&mut self, i: &'ast TypeTuple) {
-        visit_type_tuple(self, i)
+        visit_type_tuple(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_un_op(&mut self, i: &'ast UnOp) {
-        visit_un_op(self, i)
+        visit_un_op(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_use_glob(&mut self, i: &'ast UseGlob) {
-        visit_use_glob(self, i)
+        visit_use_glob(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_use_group(&mut self, i: &'ast UseGroup) {
-        visit_use_group(self, i)
+        visit_use_group(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_use_name(&mut self, i: &'ast UseName) {
-        visit_use_name(self, i)
+        visit_use_name(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_use_path(&mut self, i: &'ast UsePath) {
-        visit_use_path(self, i)
+        visit_use_path(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_use_rename(&mut self, i: &'ast UseRename) {
-        visit_use_rename(self, i)
+        visit_use_rename(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_use_tree(&mut self, i: &'ast UseTree) {
-        visit_use_tree(self, i)
+        visit_use_tree(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_variadic(&mut self, i: &'ast Variadic) {
-        visit_variadic(self, i)
+        visit_variadic(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_variant(&mut self, i: &'ast Variant) {
-        visit_variant(self, i)
+        visit_variant(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_vis_crate(&mut self, i: &'ast VisCrate) {
-        visit_vis_crate(self, i)
+        visit_vis_crate(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_vis_public(&mut self, i: &'ast VisPublic) {
-        visit_vis_public(self, i)
+        visit_vis_public(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_vis_restricted(&mut self, i: &'ast VisRestricted) {
-        visit_vis_restricted(self, i)
+        visit_vis_restricted(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_visibility(&mut self, i: &'ast Visibility) {
-        visit_visibility(self, i)
+        visit_visibility(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_where_clause(&mut self, i: &'ast WhereClause) {
-        visit_where_clause(self, i)
+        visit_where_clause(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_where_predicate(&mut self, i: &'ast WherePredicate) {
-        visit_where_predicate(self, i)
+        visit_where_predicate(self, i);
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
@@ -776,7 +776,7 @@ where
 {
     tokens_helper(v, &node.extern_token.span);
     if let Some(it) = &node.name {
-        v.visit_lit_str(it)
+        v.visit_lit_str(it);
     };
 }
 #[cfg(any(feature = "derive", feature = "full"))]
@@ -787,7 +787,7 @@ pub fn visit_angle_bracketed_generic_arguments<'ast, V>(
     V: Visit<'ast> + ?Sized,
 {
     if let Some(it) = &node.colon2_token {
-        tokens_helper(v, &it.spans)
+        tokens_helper(v, &it.spans);
     };
     tokens_helper(v, &node.lt_token.spans);
     for el in Punctuated::pairs(&node.args) {
@@ -805,7 +805,7 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_pat(&node.pat);
     if let Some(it) = &node.guard {
@@ -815,7 +815,7 @@ where
     tokens_helper(v, &node.fat_arrow_token.spans);
     v.visit_expr(&*node.body);
     if let Some(it) = &node.comma {
-        tokens_helper(v, &it.spans)
+        tokens_helper(v, &it.spans);
     };
 }
 #[cfg(any(feature = "derive", feature = "full"))]
@@ -847,7 +847,7 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     if let Some(it) = &node.name {
         v.visit_ident(&(it).0);
@@ -963,7 +963,7 @@ where
 {
     tokens_helper(v, &node.brace_token.span);
     for it in &node.stmts {
-        v.visit_stmt(it)
+        v.visit_stmt(it);
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
@@ -988,17 +988,17 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     tokens_helper(v, &node.const_token.span);
     v.visit_ident(&node.ident);
     tokens_helper(v, &node.colon_token.spans);
     v.visit_type(&node.ty);
     if let Some(it) = &node.eq_token {
-        tokens_helper(v, &it.spans)
+        tokens_helper(v, &it.spans);
     };
     if let Some(it) = &node.default {
-        v.visit_expr(it)
+        v.visit_expr(it);
     };
 }
 #[cfg(any(feature = "derive", feature = "full"))]
@@ -1056,7 +1056,7 @@ where
     tokens_helper(v, &node.struct_token.span);
     v.visit_fields(&node.fields);
     if let Some(it) = &node.semi_token {
-        tokens_helper(v, &it.spans)
+        tokens_helper(v, &it.spans);
     };
 }
 #[cfg(feature = "derive")]
@@ -1073,7 +1073,7 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_visibility(&node.vis);
     v.visit_ident(&node.ident);
@@ -1215,7 +1215,7 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     tokens_helper(v, &node.bracket_token.span);
     for el in Punctuated::pairs(&node.elems) {
@@ -1232,7 +1232,7 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_expr(&*node.left);
     tokens_helper(v, &node.eq_token.spans);
@@ -1244,7 +1244,7 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_expr(&*node.left);
     v.visit_bin_op(&node.op);
@@ -1256,11 +1256,11 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     tokens_helper(v, &node.async_token.span);
     if let Some(it) = &node.capture {
-        tokens_helper(v, &it.span)
+        tokens_helper(v, &it.span);
     };
     v.visit_block(&node.block);
 }
@@ -1270,7 +1270,7 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_expr(&*node.base);
     tokens_helper(v, &node.dot_token.spans);
@@ -1282,7 +1282,7 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_expr(&*node.left);
     v.visit_bin_op(&node.op);
@@ -1294,10 +1294,10 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     if let Some(it) = &node.label {
-        v.visit_label(it)
+        v.visit_label(it);
     };
     v.visit_block(&node.block);
 }
@@ -1307,7 +1307,7 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     tokens_helper(v, &node.box_token.span);
     v.visit_expr(&*node.expr);
@@ -1318,14 +1318,14 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     tokens_helper(v, &node.break_token.span);
     if let Some(it) = &node.label {
-        v.visit_lifetime(it)
+        v.visit_lifetime(it);
     };
     if let Some(it) = &node.expr {
-        v.visit_expr(&**it)
+        v.visit_expr(&**it);
     };
 }
 #[cfg(any(feature = "derive", feature = "full"))]
@@ -1334,7 +1334,7 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_expr(&*node.func);
     tokens_helper(v, &node.paren_token.span);
@@ -1352,7 +1352,7 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_expr(&*node.expr);
     tokens_helper(v, &node.as_token.span);
@@ -1364,16 +1364,16 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     if let Some(it) = &node.asyncness {
-        tokens_helper(v, &it.span)
+        tokens_helper(v, &it.span);
     };
     if let Some(it) = &node.movability {
-        tokens_helper(v, &it.span)
+        tokens_helper(v, &it.span);
     };
     if let Some(it) = &node.capture {
-        tokens_helper(v, &it.span)
+        tokens_helper(v, &it.span);
     };
     tokens_helper(v, &node.or1_token.spans);
     for el in Punctuated::pairs(&node.inputs) {
@@ -1393,11 +1393,11 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     tokens_helper(v, &node.continue_token.span);
     if let Some(it) = &node.label {
-        v.visit_lifetime(it)
+        v.visit_lifetime(it);
     };
 }
 #[cfg(any(feature = "derive", feature = "full"))]
@@ -1406,7 +1406,7 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_expr(&*node.base);
     tokens_helper(v, &node.dot_token.spans);
@@ -1418,10 +1418,10 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     if let Some(it) = &node.label {
-        v.visit_label(it)
+        v.visit_label(it);
     };
     tokens_helper(v, &node.for_token.span);
     v.visit_pat(&node.pat);
@@ -1435,7 +1435,7 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     tokens_helper(v, &node.group_token.span);
     v.visit_expr(&*node.expr);
@@ -1446,7 +1446,7 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     tokens_helper(v, &node.if_token.span);
     v.visit_expr(&*node.cond);
@@ -1462,7 +1462,7 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_expr(&*node.expr);
     tokens_helper(v, &node.bracket_token.span);
@@ -1474,7 +1474,7 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     tokens_helper(v, &node.let_token.span);
     v.visit_pat(&node.pat);
@@ -1487,7 +1487,7 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_lit(&node.lit);
 }
@@ -1497,10 +1497,10 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     if let Some(it) = &node.label {
-        v.visit_label(it)
+        v.visit_label(it);
     };
     tokens_helper(v, &node.loop_token.span);
     v.visit_block(&node.body);
@@ -1511,7 +1511,7 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_macro(&node.mac);
 }
@@ -1521,13 +1521,13 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     tokens_helper(v, &node.match_token.span);
     v.visit_expr(&*node.expr);
     tokens_helper(v, &node.brace_token.span);
     for it in &node.arms {
-        v.visit_arm(it)
+        v.visit_arm(it);
     }
 }
 #[cfg(feature = "full")]
@@ -1536,13 +1536,13 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_expr(&*node.receiver);
     tokens_helper(v, &node.dot_token.spans);
     v.visit_ident(&node.method);
     if let Some(it) = &node.turbofish {
-        v.visit_method_turbofish(it)
+        v.visit_method_turbofish(it);
     };
     tokens_helper(v, &node.paren_token.span);
     for el in Punctuated::pairs(&node.args) {
@@ -1559,7 +1559,7 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     tokens_helper(v, &node.paren_token.span);
     v.visit_expr(&*node.expr);
@@ -1570,10 +1570,10 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     if let Some(it) = &node.qself {
-        v.visit_qself(it)
+        v.visit_qself(it);
     };
     v.visit_path(&node.path);
 }
@@ -1583,14 +1583,14 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     if let Some(it) = &node.from {
-        v.visit_expr(&**it)
+        v.visit_expr(&**it);
     };
     v.visit_range_limits(&node.limits);
     if let Some(it) = &node.to {
-        v.visit_expr(&**it)
+        v.visit_expr(&**it);
     };
 }
 #[cfg(feature = "full")]
@@ -1599,11 +1599,11 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     tokens_helper(v, &node.and_token.spans);
     if let Some(it) = &node.mutability {
-        tokens_helper(v, &it.span)
+        tokens_helper(v, &it.span);
     };
     v.visit_expr(&*node.expr);
 }
@@ -1613,7 +1613,7 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     tokens_helper(v, &node.bracket_token.span);
     v.visit_expr(&*node.expr);
@@ -1626,11 +1626,11 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     tokens_helper(v, &node.return_token.span);
     if let Some(it) = &node.expr {
-        v.visit_expr(&**it)
+        v.visit_expr(&**it);
     };
 }
 #[cfg(feature = "full")]
@@ -1639,7 +1639,7 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_path(&node.path);
     tokens_helper(v, &node.brace_token.span);
@@ -1651,10 +1651,10 @@ where
         }
     }
     if let Some(it) = &node.dot2_token {
-        tokens_helper(v, &it.spans)
+        tokens_helper(v, &it.spans);
     };
     if let Some(it) = &node.rest {
-        v.visit_expr(&**it)
+        v.visit_expr(&**it);
     };
 }
 #[cfg(feature = "full")]
@@ -1663,7 +1663,7 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_expr(&*node.expr);
     tokens_helper(v, &node.question_token.spans);
@@ -1674,7 +1674,7 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     tokens_helper(v, &node.try_token.span);
     v.visit_block(&node.block);
@@ -1685,7 +1685,7 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     tokens_helper(v, &node.paren_token.span);
     for el in Punctuated::pairs(&node.elems) {
@@ -1702,7 +1702,7 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_expr(&*node.expr);
     tokens_helper(v, &node.colon_token.spans);
@@ -1714,7 +1714,7 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_un_op(&node.op);
     v.visit_expr(&*node.expr);
@@ -1725,7 +1725,7 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     tokens_helper(v, &node.unsafe_token.span);
     v.visit_block(&node.block);
@@ -1736,10 +1736,10 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     if let Some(it) = &node.label {
-        v.visit_label(it)
+        v.visit_label(it);
     };
     tokens_helper(v, &node.while_token.span);
     v.visit_expr(&*node.cond);
@@ -1751,11 +1751,11 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     tokens_helper(v, &node.yield_token.span);
     if let Some(it) = &node.expr {
-        v.visit_expr(&**it)
+        v.visit_expr(&**it);
     };
 }
 #[cfg(any(feature = "derive", feature = "full"))]
@@ -1764,14 +1764,14 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_visibility(&node.vis);
     if let Some(it) = &node.ident {
-        v.visit_ident(it)
+        v.visit_ident(it);
     };
     if let Some(it) = &node.colon_token {
-        tokens_helper(v, &it.spans)
+        tokens_helper(v, &it.spans);
     };
     v.visit_type(&node.ty);
 }
@@ -1781,11 +1781,11 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_member(&node.member);
     if let Some(it) = &node.colon_token {
-        tokens_helper(v, &it.spans)
+        tokens_helper(v, &it.spans);
     };
     v.visit_pat(&*node.pat);
 }
@@ -1795,11 +1795,11 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_member(&node.member);
     if let Some(it) = &node.colon_token {
-        tokens_helper(v, &it.spans)
+        tokens_helper(v, &it.spans);
     };
     v.visit_expr(&node.expr);
 }
@@ -1853,10 +1853,10 @@ where
 {
     skip!(node.shebang);
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     for it in &node.items {
-        v.visit_item(it)
+        v.visit_item(it);
     }
 }
 #[cfg(feature = "full")]
@@ -1903,7 +1903,7 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_visibility(&node.vis);
     v.visit_signature(&node.sig);
@@ -1915,11 +1915,11 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_macro(&node.mac);
     if let Some(it) = &node.semi_token {
-        tokens_helper(v, &it.spans)
+        tokens_helper(v, &it.spans);
     };
 }
 #[cfg(feature = "full")]
@@ -1928,12 +1928,12 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_visibility(&node.vis);
     tokens_helper(v, &node.static_token.span);
     if let Some(it) = &node.mutability {
-        tokens_helper(v, &it.span)
+        tokens_helper(v, &it.span);
     };
     v.visit_ident(&node.ident);
     tokens_helper(v, &node.colon_token.spans);
@@ -1946,7 +1946,7 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_visibility(&node.vis);
     tokens_helper(v, &node.type_token.span);
@@ -2013,7 +2013,7 @@ where
     V: Visit<'ast> + ?Sized,
 {
     if let Some(it) = &node.lt_token {
-        tokens_helper(v, &it.spans)
+        tokens_helper(v, &it.spans);
     };
     for el in Punctuated::pairs(&node.params) {
         let (it, p) = el.into_tuple();
@@ -2023,10 +2023,10 @@ where
         }
     }
     if let Some(it) = &node.gt_token {
-        tokens_helper(v, &it.spans)
+        tokens_helper(v, &it.spans);
     };
     if let Some(it) = &node.where_clause {
-        v.visit_where_clause(it)
+        v.visit_where_clause(it);
     };
 }
 pub fn visit_ident<'ast, V>(v: &mut V, node: &'ast Ident)
@@ -2065,11 +2065,11 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_visibility(&node.vis);
     if let Some(it) = &node.defaultness {
-        tokens_helper(v, &it.span)
+        tokens_helper(v, &it.span);
     };
     tokens_helper(v, &node.const_token.span);
     v.visit_ident(&node.ident);
@@ -2085,11 +2085,11 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_macro(&node.mac);
     if let Some(it) = &node.semi_token {
-        tokens_helper(v, &it.spans)
+        tokens_helper(v, &it.spans);
     };
 }
 #[cfg(feature = "full")]
@@ -2098,11 +2098,11 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_visibility(&node.vis);
     if let Some(it) = &node.defaultness {
-        tokens_helper(v, &it.span)
+        tokens_helper(v, &it.span);
     };
     v.visit_signature(&node.sig);
     v.visit_block(&node.block);
@@ -2113,11 +2113,11 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_visibility(&node.vis);
     if let Some(it) = &node.defaultness {
-        tokens_helper(v, &it.span)
+        tokens_helper(v, &it.span);
     };
     tokens_helper(v, &node.type_token.span);
     v.visit_ident(&node.ident);
@@ -2200,7 +2200,7 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_visibility(&node.vis);
     tokens_helper(v, &node.const_token.span);
@@ -2217,7 +2217,7 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_visibility(&node.vis);
     tokens_helper(v, &node.enum_token.span);
@@ -2238,7 +2238,7 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_visibility(&node.vis);
     tokens_helper(v, &node.extern_token.span);
@@ -2256,7 +2256,7 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_visibility(&node.vis);
     v.visit_signature(&node.sig);
@@ -2268,12 +2268,12 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_abi(&node.abi);
     tokens_helper(v, &node.brace_token.span);
     for it in &node.items {
-        v.visit_foreign_item(it)
+        v.visit_foreign_item(it);
     }
 }
 #[cfg(feature = "full")]
@@ -2282,19 +2282,19 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     if let Some(it) = &node.defaultness {
-        tokens_helper(v, &it.span)
+        tokens_helper(v, &it.span);
     };
     if let Some(it) = &node.unsafety {
-        tokens_helper(v, &it.span)
+        tokens_helper(v, &it.span);
     };
     tokens_helper(v, &node.impl_token.span);
     v.visit_generics(&node.generics);
     if let Some(it) = &node.trait_ {
         if let Some(it) = &(it).0 {
-            tokens_helper(v, &it.spans)
+            tokens_helper(v, &it.spans);
         };
         v.visit_path(&(it).1);
         tokens_helper(v, &(it).2.span);
@@ -2302,7 +2302,7 @@ where
     v.visit_type(&*node.self_ty);
     tokens_helper(v, &node.brace_token.span);
     for it in &node.items {
-        v.visit_impl_item(it)
+        v.visit_impl_item(it);
     }
 }
 #[cfg(feature = "full")]
@@ -2311,14 +2311,14 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     if let Some(it) = &node.ident {
-        v.visit_ident(it)
+        v.visit_ident(it);
     };
     v.visit_macro(&node.mac);
     if let Some(it) = &node.semi_token {
-        tokens_helper(v, &it.spans)
+        tokens_helper(v, &it.spans);
     };
 }
 #[cfg(feature = "full")]
@@ -2327,7 +2327,7 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_visibility(&node.vis);
     tokens_helper(v, &node.macro_token.span);
@@ -2340,7 +2340,7 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_visibility(&node.vis);
     tokens_helper(v, &node.mod_token.span);
@@ -2348,11 +2348,11 @@ where
     if let Some(it) = &node.content {
         tokens_helper(v, &(it).0.span);
         for it in &(it).1 {
-            v.visit_item(it)
+            v.visit_item(it);
         }
     };
     if let Some(it) = &node.semi {
-        tokens_helper(v, &it.spans)
+        tokens_helper(v, &it.spans);
     };
 }
 #[cfg(feature = "full")]
@@ -2361,12 +2361,12 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_visibility(&node.vis);
     tokens_helper(v, &node.static_token.span);
     if let Some(it) = &node.mutability {
-        tokens_helper(v, &it.span)
+        tokens_helper(v, &it.span);
     };
     v.visit_ident(&node.ident);
     tokens_helper(v, &node.colon_token.spans);
@@ -2381,7 +2381,7 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_visibility(&node.vis);
     tokens_helper(v, &node.struct_token.span);
@@ -2389,7 +2389,7 @@ where
     v.visit_generics(&node.generics);
     v.visit_fields(&node.fields);
     if let Some(it) = &node.semi_token {
-        tokens_helper(v, &it.spans)
+        tokens_helper(v, &it.spans);
     };
 }
 #[cfg(feature = "full")]
@@ -2398,20 +2398,20 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_visibility(&node.vis);
     if let Some(it) = &node.unsafety {
-        tokens_helper(v, &it.span)
+        tokens_helper(v, &it.span);
     };
     if let Some(it) = &node.auto_token {
-        tokens_helper(v, &it.span)
+        tokens_helper(v, &it.span);
     };
     tokens_helper(v, &node.trait_token.span);
     v.visit_ident(&node.ident);
     v.visit_generics(&node.generics);
     if let Some(it) = &node.colon_token {
-        tokens_helper(v, &it.spans)
+        tokens_helper(v, &it.spans);
     };
     for el in Punctuated::pairs(&node.supertraits) {
         let (it, p) = el.into_tuple();
@@ -2422,7 +2422,7 @@ where
     }
     tokens_helper(v, &node.brace_token.span);
     for it in &node.items {
-        v.visit_trait_item(it)
+        v.visit_trait_item(it);
     }
 }
 #[cfg(feature = "full")]
@@ -2431,7 +2431,7 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_visibility(&node.vis);
     tokens_helper(v, &node.trait_token.span);
@@ -2453,7 +2453,7 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_visibility(&node.vis);
     tokens_helper(v, &node.type_token.span);
@@ -2469,7 +2469,7 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_visibility(&node.vis);
     tokens_helper(v, &node.union_token.span);
@@ -2483,12 +2483,12 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_visibility(&node.vis);
     tokens_helper(v, &node.use_token.span);
     if let Some(it) = &node.leading_colon {
-        tokens_helper(v, &it.spans)
+        tokens_helper(v, &it.spans);
     };
     v.visit_use_tree(&node.tree);
     tokens_helper(v, &node.semi_token.spans);
@@ -2514,11 +2514,11 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_lifetime(&node.lifetime);
     if let Some(it) = &node.colon_token {
-        tokens_helper(v, &it.spans)
+        tokens_helper(v, &it.spans);
     };
     for el in Punctuated::pairs(&node.bounds) {
         let (it, p) = el.into_tuple();
@@ -2602,7 +2602,7 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     tokens_helper(v, &node.let_token.span);
     v.visit_pat(&node.pat);
@@ -2804,7 +2804,7 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     tokens_helper(v, &node.box_token.span);
     v.visit_pat(&*node.pat);
@@ -2815,13 +2815,13 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     if let Some(it) = &node.by_ref {
-        tokens_helper(v, &it.span)
+        tokens_helper(v, &it.span);
     };
     if let Some(it) = &node.mutability {
-        tokens_helper(v, &it.span)
+        tokens_helper(v, &it.span);
     };
     v.visit_ident(&node.ident);
     if let Some(it) = &node.subpat {
@@ -2835,7 +2835,7 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_expr(&*node.expr);
 }
@@ -2845,7 +2845,7 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_macro(&node.mac);
 }
@@ -2855,10 +2855,10 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     if let Some(it) = &node.leading_vert {
-        tokens_helper(v, &it.spans)
+        tokens_helper(v, &it.spans);
     };
     for el in Punctuated::pairs(&node.cases) {
         let (it, p) = el.into_tuple();
@@ -2874,10 +2874,10 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     if let Some(it) = &node.qself {
-        v.visit_qself(it)
+        v.visit_qself(it);
     };
     v.visit_path(&node.path);
 }
@@ -2887,7 +2887,7 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_expr(&*node.lo);
     v.visit_range_limits(&node.limits);
@@ -2899,11 +2899,11 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     tokens_helper(v, &node.and_token.spans);
     if let Some(it) = &node.mutability {
-        tokens_helper(v, &it.span)
+        tokens_helper(v, &it.span);
     };
     v.visit_pat(&*node.pat);
 }
@@ -2913,7 +2913,7 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     tokens_helper(v, &node.dot2_token.spans);
 }
@@ -2923,7 +2923,7 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     tokens_helper(v, &node.bracket_token.span);
     for el in Punctuated::pairs(&node.elems) {
@@ -2940,7 +2940,7 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_path(&node.path);
     tokens_helper(v, &node.brace_token.span);
@@ -2952,7 +2952,7 @@ where
         }
     }
     if let Some(it) = &node.dot2_token {
-        tokens_helper(v, &it.spans)
+        tokens_helper(v, &it.spans);
     };
 }
 #[cfg(feature = "full")]
@@ -2961,7 +2961,7 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     tokens_helper(v, &node.paren_token.span);
     for el in Punctuated::pairs(&node.elems) {
@@ -2978,7 +2978,7 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_path(&node.path);
     v.visit_pat_tuple(&node.pat);
@@ -2989,7 +2989,7 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_pat(&*node.pat);
     tokens_helper(v, &node.colon_token.spans);
@@ -3001,7 +3001,7 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     tokens_helper(v, &node.underscore_token.spans);
 }
@@ -3011,7 +3011,7 @@ where
     V: Visit<'ast> + ?Sized,
 {
     if let Some(it) = &node.leading_colon {
-        tokens_helper(v, &it.spans)
+        tokens_helper(v, &it.spans);
     };
     for el in Punctuated::pairs(&node.segments) {
         let (it, p) = el.into_tuple();
@@ -3074,7 +3074,7 @@ where
     V: Visit<'ast> + ?Sized,
 {
     if let Some(it) = &node.lifetimes {
-        v.visit_bound_lifetimes(it)
+        v.visit_bound_lifetimes(it);
     };
     v.visit_type(&node.bounded_ty);
     tokens_helper(v, &node.colon_token.spans);
@@ -3095,7 +3095,7 @@ where
     v.visit_type(&*node.ty);
     skip!(node.position);
     if let Some(it) = &node.as_token {
-        tokens_helper(v, &it.span)
+        tokens_helper(v, &it.span);
     };
     tokens_helper(v, &node.gt_token.spans);
 }
@@ -3119,16 +3119,16 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     if let Some(it) = &node.reference {
         tokens_helper(v, &(it).0.spans);
         if let Some(it) = &(it).1 {
-            v.visit_lifetime(it)
+            v.visit_lifetime(it);
         };
     };
     if let Some(it) = &node.mutability {
-        tokens_helper(v, &it.span)
+        tokens_helper(v, &it.span);
     };
     tokens_helper(v, &node.self_token.span);
 }
@@ -3151,16 +3151,16 @@ where
     V: Visit<'ast> + ?Sized,
 {
     if let Some(it) = &node.constness {
-        tokens_helper(v, &it.span)
+        tokens_helper(v, &it.span);
     };
     if let Some(it) = &node.asyncness {
-        tokens_helper(v, &it.span)
+        tokens_helper(v, &it.span);
     };
     if let Some(it) = &node.unsafety {
-        tokens_helper(v, &it.span)
+        tokens_helper(v, &it.span);
     };
     if let Some(it) = &node.abi {
-        v.visit_abi(it)
+        v.visit_abi(it);
     };
     tokens_helper(v, &node.fn_token.span);
     v.visit_ident(&node.ident);
@@ -3174,7 +3174,7 @@ where
         }
     }
     if let Some(it) = &node.variadic {
-        v.visit_variadic(it)
+        v.visit_variadic(it);
     };
     v.visit_return_type(&node.output);
 }
@@ -3210,11 +3210,11 @@ where
     V: Visit<'ast> + ?Sized,
 {
     if let Some(it) = &node.paren_token {
-        tokens_helper(v, &it.span)
+        tokens_helper(v, &it.span);
     };
     v.visit_trait_bound_modifier(&node.modifier);
     if let Some(it) = &node.lifetimes {
-        v.visit_bound_lifetimes(it)
+        v.visit_bound_lifetimes(it);
     };
     v.visit_path(&node.path);
 }
@@ -3260,7 +3260,7 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     tokens_helper(v, &node.const_token.span);
     v.visit_ident(&node.ident);
@@ -3278,11 +3278,11 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_macro(&node.mac);
     if let Some(it) = &node.semi_token {
-        tokens_helper(v, &it.spans)
+        tokens_helper(v, &it.spans);
     };
 }
 #[cfg(feature = "full")]
@@ -3291,14 +3291,14 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_signature(&node.sig);
     if let Some(it) = &node.default {
-        v.visit_block(it)
+        v.visit_block(it);
     };
     if let Some(it) = &node.semi_token {
-        tokens_helper(v, &it.spans)
+        tokens_helper(v, &it.spans);
     };
 }
 #[cfg(feature = "full")]
@@ -3307,13 +3307,13 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     tokens_helper(v, &node.type_token.span);
     v.visit_ident(&node.ident);
     v.visit_generics(&node.generics);
     if let Some(it) = &node.colon_token {
-        tokens_helper(v, &it.spans)
+        tokens_helper(v, &it.spans);
     };
     for el in Punctuated::pairs(&node.bounds) {
         let (it, p) = el.into_tuple();
@@ -3398,13 +3398,13 @@ where
     V: Visit<'ast> + ?Sized,
 {
     if let Some(it) = &node.lifetimes {
-        v.visit_bound_lifetimes(it)
+        v.visit_bound_lifetimes(it);
     };
     if let Some(it) = &node.unsafety {
-        tokens_helper(v, &it.span)
+        tokens_helper(v, &it.span);
     };
     if let Some(it) = &node.abi {
-        v.visit_abi(it)
+        v.visit_abi(it);
     };
     tokens_helper(v, &node.fn_token.span);
     tokens_helper(v, &node.paren_token.span);
@@ -3416,7 +3416,7 @@ where
         }
     }
     if let Some(it) = &node.variadic {
-        v.visit_variadic(it)
+        v.visit_variadic(it);
     };
     v.visit_return_type(&node.output);
 }
@@ -3469,11 +3469,11 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_ident(&node.ident);
     if let Some(it) = &node.colon_token {
-        tokens_helper(v, &it.spans)
+        tokens_helper(v, &it.spans);
     };
     for el in Punctuated::pairs(&node.bounds) {
         let (it, p) = el.into_tuple();
@@ -3483,10 +3483,10 @@ where
         }
     }
     if let Some(it) = &node.eq_token {
-        tokens_helper(v, &it.spans)
+        tokens_helper(v, &it.spans);
     };
     if let Some(it) = &node.default {
-        v.visit_type(it)
+        v.visit_type(it);
     };
 }
 #[cfg(any(feature = "derive", feature = "full"))]
@@ -3517,7 +3517,7 @@ where
     V: Visit<'ast> + ?Sized,
 {
     if let Some(it) = &node.qself {
-        v.visit_qself(it)
+        v.visit_qself(it);
     };
     v.visit_path(&node.path);
 }
@@ -3528,10 +3528,10 @@ where
 {
     tokens_helper(v, &node.star_token.spans);
     if let Some(it) = &node.const_token {
-        tokens_helper(v, &it.span)
+        tokens_helper(v, &it.span);
     };
     if let Some(it) = &node.mutability {
-        tokens_helper(v, &it.span)
+        tokens_helper(v, &it.span);
     };
     v.visit_type(&*node.elem);
 }
@@ -3542,10 +3542,10 @@ where
 {
     tokens_helper(v, &node.and_token.spans);
     if let Some(it) = &node.lifetime {
-        v.visit_lifetime(it)
+        v.visit_lifetime(it);
     };
     if let Some(it) = &node.mutability {
-        tokens_helper(v, &it.span)
+        tokens_helper(v, &it.span);
     };
     v.visit_type(&*node.elem);
 }
@@ -3563,7 +3563,7 @@ where
     V: Visit<'ast> + ?Sized,
 {
     if let Some(it) = &node.dyn_token {
-        tokens_helper(v, &it.span)
+        tokens_helper(v, &it.span);
     };
     for el in Punctuated::pairs(&node.bounds) {
         let (it, p) = el.into_tuple();
@@ -3679,7 +3679,7 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     tokens_helper(v, &node.dots.spans);
 }
@@ -3689,7 +3689,7 @@ where
     V: Visit<'ast> + ?Sized,
 {
     for it in &node.attrs {
-        v.visit_attribute(it)
+        v.visit_attribute(it);
     }
     v.visit_ident(&node.ident);
     v.visit_fields(&node.fields);
@@ -3720,7 +3720,7 @@ where
     tokens_helper(v, &node.pub_token.span);
     tokens_helper(v, &node.paren_token.span);
     if let Some(it) = &node.in_token {
-        tokens_helper(v, &it.span)
+        tokens_helper(v, &it.span);
     };
     v.visit_path(&*node.path);
 }
diff --git a/src/gen/visit_mut.rs b/src/gen/visit_mut.rs
index 5ce11f0b..1de0c95e 100644
--- a/src/gen/visit_mut.rs
+++ b/src/gen/visit_mut.rs
@@ -34,743 +34,743 @@ macro_rules! skip {
 pub trait VisitMut {
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_abi_mut(&mut self, i: &mut Abi) {
-        visit_abi_mut(self, i)
+        visit_abi_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_angle_bracketed_generic_arguments_mut(
         &mut self,
         i: &mut AngleBracketedGenericArguments,
     ) {
-        visit_angle_bracketed_generic_arguments_mut(self, i)
+        visit_angle_bracketed_generic_arguments_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_arm_mut(&mut self, i: &mut Arm) {
-        visit_arm_mut(self, i)
+        visit_arm_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_attr_style_mut(&mut self, i: &mut AttrStyle) {
-        visit_attr_style_mut(self, i)
+        visit_attr_style_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_attribute_mut(&mut self, i: &mut Attribute) {
-        visit_attribute_mut(self, i)
+        visit_attribute_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_bare_fn_arg_mut(&mut self, i: &mut BareFnArg) {
-        visit_bare_fn_arg_mut(self, i)
+        visit_bare_fn_arg_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_bin_op_mut(&mut self, i: &mut BinOp) {
-        visit_bin_op_mut(self, i)
+        visit_bin_op_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_binding_mut(&mut self, i: &mut Binding) {
-        visit_binding_mut(self, i)
+        visit_binding_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_block_mut(&mut self, i: &mut Block) {
-        visit_block_mut(self, i)
+        visit_block_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_bound_lifetimes_mut(&mut self, i: &mut BoundLifetimes) {
-        visit_bound_lifetimes_mut(self, i)
+        visit_bound_lifetimes_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_const_param_mut(&mut self, i: &mut ConstParam) {
-        visit_const_param_mut(self, i)
+        visit_const_param_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_constraint_mut(&mut self, i: &mut Constraint) {
-        visit_constraint_mut(self, i)
+        visit_constraint_mut(self, i);
     }
     #[cfg(feature = "derive")]
     fn visit_data_mut(&mut self, i: &mut Data) {
-        visit_data_mut(self, i)
+        visit_data_mut(self, i);
     }
     #[cfg(feature = "derive")]
     fn visit_data_enum_mut(&mut self, i: &mut DataEnum) {
-        visit_data_enum_mut(self, i)
+        visit_data_enum_mut(self, i);
     }
     #[cfg(feature = "derive")]
     fn visit_data_struct_mut(&mut self, i: &mut DataStruct) {
-        visit_data_struct_mut(self, i)
+        visit_data_struct_mut(self, i);
     }
     #[cfg(feature = "derive")]
     fn visit_data_union_mut(&mut self, i: &mut DataUnion) {
-        visit_data_union_mut(self, i)
+        visit_data_union_mut(self, i);
     }
     #[cfg(feature = "derive")]
     fn visit_derive_input_mut(&mut self, i: &mut DeriveInput) {
-        visit_derive_input_mut(self, i)
+        visit_derive_input_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_expr_mut(&mut self, i: &mut Expr) {
-        visit_expr_mut(self, i)
+        visit_expr_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_array_mut(&mut self, i: &mut ExprArray) {
-        visit_expr_array_mut(self, i)
+        visit_expr_array_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_assign_mut(&mut self, i: &mut ExprAssign) {
-        visit_expr_assign_mut(self, i)
+        visit_expr_assign_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_assign_op_mut(&mut self, i: &mut ExprAssignOp) {
-        visit_expr_assign_op_mut(self, i)
+        visit_expr_assign_op_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_async_mut(&mut self, i: &mut ExprAsync) {
-        visit_expr_async_mut(self, i)
+        visit_expr_async_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_await_mut(&mut self, i: &mut ExprAwait) {
-        visit_expr_await_mut(self, i)
+        visit_expr_await_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_expr_binary_mut(&mut self, i: &mut ExprBinary) {
-        visit_expr_binary_mut(self, i)
+        visit_expr_binary_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_block_mut(&mut self, i: &mut ExprBlock) {
-        visit_expr_block_mut(self, i)
+        visit_expr_block_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_box_mut(&mut self, i: &mut ExprBox) {
-        visit_expr_box_mut(self, i)
+        visit_expr_box_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_break_mut(&mut self, i: &mut ExprBreak) {
-        visit_expr_break_mut(self, i)
+        visit_expr_break_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_expr_call_mut(&mut self, i: &mut ExprCall) {
-        visit_expr_call_mut(self, i)
+        visit_expr_call_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_expr_cast_mut(&mut self, i: &mut ExprCast) {
-        visit_expr_cast_mut(self, i)
+        visit_expr_cast_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_closure_mut(&mut self, i: &mut ExprClosure) {
-        visit_expr_closure_mut(self, i)
+        visit_expr_closure_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_continue_mut(&mut self, i: &mut ExprContinue) {
-        visit_expr_continue_mut(self, i)
+        visit_expr_continue_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_expr_field_mut(&mut self, i: &mut ExprField) {
-        visit_expr_field_mut(self, i)
+        visit_expr_field_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_for_loop_mut(&mut self, i: &mut ExprForLoop) {
-        visit_expr_for_loop_mut(self, i)
+        visit_expr_for_loop_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_group_mut(&mut self, i: &mut ExprGroup) {
-        visit_expr_group_mut(self, i)
+        visit_expr_group_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_if_mut(&mut self, i: &mut ExprIf) {
-        visit_expr_if_mut(self, i)
+        visit_expr_if_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_expr_index_mut(&mut self, i: &mut ExprIndex) {
-        visit_expr_index_mut(self, i)
+        visit_expr_index_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_let_mut(&mut self, i: &mut ExprLet) {
-        visit_expr_let_mut(self, i)
+        visit_expr_let_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_expr_lit_mut(&mut self, i: &mut ExprLit) {
-        visit_expr_lit_mut(self, i)
+        visit_expr_lit_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_loop_mut(&mut self, i: &mut ExprLoop) {
-        visit_expr_loop_mut(self, i)
+        visit_expr_loop_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_macro_mut(&mut self, i: &mut ExprMacro) {
-        visit_expr_macro_mut(self, i)
+        visit_expr_macro_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_match_mut(&mut self, i: &mut ExprMatch) {
-        visit_expr_match_mut(self, i)
+        visit_expr_match_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_method_call_mut(&mut self, i: &mut ExprMethodCall) {
-        visit_expr_method_call_mut(self, i)
+        visit_expr_method_call_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_expr_paren_mut(&mut self, i: &mut ExprParen) {
-        visit_expr_paren_mut(self, i)
+        visit_expr_paren_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_expr_path_mut(&mut self, i: &mut ExprPath) {
-        visit_expr_path_mut(self, i)
+        visit_expr_path_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_range_mut(&mut self, i: &mut ExprRange) {
-        visit_expr_range_mut(self, i)
+        visit_expr_range_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_reference_mut(&mut self, i: &mut ExprReference) {
-        visit_expr_reference_mut(self, i)
+        visit_expr_reference_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_repeat_mut(&mut self, i: &mut ExprRepeat) {
-        visit_expr_repeat_mut(self, i)
+        visit_expr_repeat_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_return_mut(&mut self, i: &mut ExprReturn) {
-        visit_expr_return_mut(self, i)
+        visit_expr_return_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_struct_mut(&mut self, i: &mut ExprStruct) {
-        visit_expr_struct_mut(self, i)
+        visit_expr_struct_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_try_mut(&mut self, i: &mut ExprTry) {
-        visit_expr_try_mut(self, i)
+        visit_expr_try_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_try_block_mut(&mut self, i: &mut ExprTryBlock) {
-        visit_expr_try_block_mut(self, i)
+        visit_expr_try_block_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_tuple_mut(&mut self, i: &mut ExprTuple) {
-        visit_expr_tuple_mut(self, i)
+        visit_expr_tuple_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_type_mut(&mut self, i: &mut ExprType) {
-        visit_expr_type_mut(self, i)
+        visit_expr_type_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_expr_unary_mut(&mut self, i: &mut ExprUnary) {
-        visit_expr_unary_mut(self, i)
+        visit_expr_unary_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_unsafe_mut(&mut self, i: &mut ExprUnsafe) {
-        visit_expr_unsafe_mut(self, i)
+        visit_expr_unsafe_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_while_mut(&mut self, i: &mut ExprWhile) {
-        visit_expr_while_mut(self, i)
+        visit_expr_while_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_expr_yield_mut(&mut self, i: &mut ExprYield) {
-        visit_expr_yield_mut(self, i)
+        visit_expr_yield_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_field_mut(&mut self, i: &mut Field) {
-        visit_field_mut(self, i)
+        visit_field_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_field_pat_mut(&mut self, i: &mut FieldPat) {
-        visit_field_pat_mut(self, i)
+        visit_field_pat_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_field_value_mut(&mut self, i: &mut FieldValue) {
-        visit_field_value_mut(self, i)
+        visit_field_value_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_fields_mut(&mut self, i: &mut Fields) {
-        visit_fields_mut(self, i)
+        visit_fields_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_fields_named_mut(&mut self, i: &mut FieldsNamed) {
-        visit_fields_named_mut(self, i)
+        visit_fields_named_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_fields_unnamed_mut(&mut self, i: &mut FieldsUnnamed) {
-        visit_fields_unnamed_mut(self, i)
+        visit_fields_unnamed_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_file_mut(&mut self, i: &mut File) {
-        visit_file_mut(self, i)
+        visit_file_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_fn_arg_mut(&mut self, i: &mut FnArg) {
-        visit_fn_arg_mut(self, i)
+        visit_fn_arg_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_foreign_item_mut(&mut self, i: &mut ForeignItem) {
-        visit_foreign_item_mut(self, i)
+        visit_foreign_item_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_foreign_item_fn_mut(&mut self, i: &mut ForeignItemFn) {
-        visit_foreign_item_fn_mut(self, i)
+        visit_foreign_item_fn_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_foreign_item_macro_mut(&mut self, i: &mut ForeignItemMacro) {
-        visit_foreign_item_macro_mut(self, i)
+        visit_foreign_item_macro_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_foreign_item_static_mut(&mut self, i: &mut ForeignItemStatic) {
-        visit_foreign_item_static_mut(self, i)
+        visit_foreign_item_static_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_foreign_item_type_mut(&mut self, i: &mut ForeignItemType) {
-        visit_foreign_item_type_mut(self, i)
+        visit_foreign_item_type_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_generic_argument_mut(&mut self, i: &mut GenericArgument) {
-        visit_generic_argument_mut(self, i)
+        visit_generic_argument_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_generic_method_argument_mut(&mut self, i: &mut GenericMethodArgument) {
-        visit_generic_method_argument_mut(self, i)
+        visit_generic_method_argument_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_generic_param_mut(&mut self, i: &mut GenericParam) {
-        visit_generic_param_mut(self, i)
+        visit_generic_param_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_generics_mut(&mut self, i: &mut Generics) {
-        visit_generics_mut(self, i)
+        visit_generics_mut(self, i);
     }
     fn visit_ident_mut(&mut self, i: &mut Ident) {
-        visit_ident_mut(self, i)
+        visit_ident_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_impl_item_mut(&mut self, i: &mut ImplItem) {
-        visit_impl_item_mut(self, i)
+        visit_impl_item_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_impl_item_const_mut(&mut self, i: &mut ImplItemConst) {
-        visit_impl_item_const_mut(self, i)
+        visit_impl_item_const_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_impl_item_macro_mut(&mut self, i: &mut ImplItemMacro) {
-        visit_impl_item_macro_mut(self, i)
+        visit_impl_item_macro_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_impl_item_method_mut(&mut self, i: &mut ImplItemMethod) {
-        visit_impl_item_method_mut(self, i)
+        visit_impl_item_method_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_impl_item_type_mut(&mut self, i: &mut ImplItemType) {
-        visit_impl_item_type_mut(self, i)
+        visit_impl_item_type_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_index_mut(&mut self, i: &mut Index) {
-        visit_index_mut(self, i)
+        visit_index_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_item_mut(&mut self, i: &mut Item) {
-        visit_item_mut(self, i)
+        visit_item_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_item_const_mut(&mut self, i: &mut ItemConst) {
-        visit_item_const_mut(self, i)
+        visit_item_const_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_item_enum_mut(&mut self, i: &mut ItemEnum) {
-        visit_item_enum_mut(self, i)
+        visit_item_enum_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_item_extern_crate_mut(&mut self, i: &mut ItemExternCrate) {
-        visit_item_extern_crate_mut(self, i)
+        visit_item_extern_crate_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_item_fn_mut(&mut self, i: &mut ItemFn) {
-        visit_item_fn_mut(self, i)
+        visit_item_fn_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_item_foreign_mod_mut(&mut self, i: &mut ItemForeignMod) {
-        visit_item_foreign_mod_mut(self, i)
+        visit_item_foreign_mod_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_item_impl_mut(&mut self, i: &mut ItemImpl) {
-        visit_item_impl_mut(self, i)
+        visit_item_impl_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_item_macro_mut(&mut self, i: &mut ItemMacro) {
-        visit_item_macro_mut(self, i)
+        visit_item_macro_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_item_macro2_mut(&mut self, i: &mut ItemMacro2) {
-        visit_item_macro2_mut(self, i)
+        visit_item_macro2_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_item_mod_mut(&mut self, i: &mut ItemMod) {
-        visit_item_mod_mut(self, i)
+        visit_item_mod_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_item_static_mut(&mut self, i: &mut ItemStatic) {
-        visit_item_static_mut(self, i)
+        visit_item_static_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_item_struct_mut(&mut self, i: &mut ItemStruct) {
-        visit_item_struct_mut(self, i)
+        visit_item_struct_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_item_trait_mut(&mut self, i: &mut ItemTrait) {
-        visit_item_trait_mut(self, i)
+        visit_item_trait_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_item_trait_alias_mut(&mut self, i: &mut ItemTraitAlias) {
-        visit_item_trait_alias_mut(self, i)
+        visit_item_trait_alias_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_item_type_mut(&mut self, i: &mut ItemType) {
-        visit_item_type_mut(self, i)
+        visit_item_type_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_item_union_mut(&mut self, i: &mut ItemUnion) {
-        visit_item_union_mut(self, i)
+        visit_item_union_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_item_use_mut(&mut self, i: &mut ItemUse) {
-        visit_item_use_mut(self, i)
+        visit_item_use_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_label_mut(&mut self, i: &mut Label) {
-        visit_label_mut(self, i)
+        visit_label_mut(self, i);
     }
     fn visit_lifetime_mut(&mut self, i: &mut Lifetime) {
-        visit_lifetime_mut(self, i)
+        visit_lifetime_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_lifetime_def_mut(&mut self, i: &mut LifetimeDef) {
-        visit_lifetime_def_mut(self, i)
+        visit_lifetime_def_mut(self, i);
     }
     fn visit_lit_mut(&mut self, i: &mut Lit) {
-        visit_lit_mut(self, i)
+        visit_lit_mut(self, i);
     }
     fn visit_lit_bool_mut(&mut self, i: &mut LitBool) {
-        visit_lit_bool_mut(self, i)
+        visit_lit_bool_mut(self, i);
     }
     fn visit_lit_byte_mut(&mut self, i: &mut LitByte) {
-        visit_lit_byte_mut(self, i)
+        visit_lit_byte_mut(self, i);
     }
     fn visit_lit_byte_str_mut(&mut self, i: &mut LitByteStr) {
-        visit_lit_byte_str_mut(self, i)
+        visit_lit_byte_str_mut(self, i);
     }
     fn visit_lit_char_mut(&mut self, i: &mut LitChar) {
-        visit_lit_char_mut(self, i)
+        visit_lit_char_mut(self, i);
     }
     fn visit_lit_float_mut(&mut self, i: &mut LitFloat) {
-        visit_lit_float_mut(self, i)
+        visit_lit_float_mut(self, i);
     }
     fn visit_lit_int_mut(&mut self, i: &mut LitInt) {
-        visit_lit_int_mut(self, i)
+        visit_lit_int_mut(self, i);
     }
     fn visit_lit_str_mut(&mut self, i: &mut LitStr) {
-        visit_lit_str_mut(self, i)
+        visit_lit_str_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_local_mut(&mut self, i: &mut Local) {
-        visit_local_mut(self, i)
+        visit_local_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_macro_mut(&mut self, i: &mut Macro) {
-        visit_macro_mut(self, i)
+        visit_macro_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_macro_delimiter_mut(&mut self, i: &mut MacroDelimiter) {
-        visit_macro_delimiter_mut(self, i)
+        visit_macro_delimiter_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_member_mut(&mut self, i: &mut Member) {
-        visit_member_mut(self, i)
+        visit_member_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_meta_mut(&mut self, i: &mut Meta) {
-        visit_meta_mut(self, i)
+        visit_meta_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_meta_list_mut(&mut self, i: &mut MetaList) {
-        visit_meta_list_mut(self, i)
+        visit_meta_list_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_meta_name_value_mut(&mut self, i: &mut MetaNameValue) {
-        visit_meta_name_value_mut(self, i)
+        visit_meta_name_value_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_method_turbofish_mut(&mut self, i: &mut MethodTurbofish) {
-        visit_method_turbofish_mut(self, i)
+        visit_method_turbofish_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_nested_meta_mut(&mut self, i: &mut NestedMeta) {
-        visit_nested_meta_mut(self, i)
+        visit_nested_meta_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_parenthesized_generic_arguments_mut(&mut self, i: &mut ParenthesizedGenericArguments) {
-        visit_parenthesized_generic_arguments_mut(self, i)
+        visit_parenthesized_generic_arguments_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_pat_mut(&mut self, i: &mut Pat) {
-        visit_pat_mut(self, i)
+        visit_pat_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_pat_box_mut(&mut self, i: &mut PatBox) {
-        visit_pat_box_mut(self, i)
+        visit_pat_box_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_pat_ident_mut(&mut self, i: &mut PatIdent) {
-        visit_pat_ident_mut(self, i)
+        visit_pat_ident_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_pat_lit_mut(&mut self, i: &mut PatLit) {
-        visit_pat_lit_mut(self, i)
+        visit_pat_lit_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_pat_macro_mut(&mut self, i: &mut PatMacro) {
-        visit_pat_macro_mut(self, i)
+        visit_pat_macro_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_pat_or_mut(&mut self, i: &mut PatOr) {
-        visit_pat_or_mut(self, i)
+        visit_pat_or_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_pat_path_mut(&mut self, i: &mut PatPath) {
-        visit_pat_path_mut(self, i)
+        visit_pat_path_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_pat_range_mut(&mut self, i: &mut PatRange) {
-        visit_pat_range_mut(self, i)
+        visit_pat_range_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_pat_reference_mut(&mut self, i: &mut PatReference) {
-        visit_pat_reference_mut(self, i)
+        visit_pat_reference_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_pat_rest_mut(&mut self, i: &mut PatRest) {
-        visit_pat_rest_mut(self, i)
+        visit_pat_rest_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_pat_slice_mut(&mut self, i: &mut PatSlice) {
-        visit_pat_slice_mut(self, i)
+        visit_pat_slice_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_pat_struct_mut(&mut self, i: &mut PatStruct) {
-        visit_pat_struct_mut(self, i)
+        visit_pat_struct_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_pat_tuple_mut(&mut self, i: &mut PatTuple) {
-        visit_pat_tuple_mut(self, i)
+        visit_pat_tuple_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_pat_tuple_struct_mut(&mut self, i: &mut PatTupleStruct) {
-        visit_pat_tuple_struct_mut(self, i)
+        visit_pat_tuple_struct_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_pat_type_mut(&mut self, i: &mut PatType) {
-        visit_pat_type_mut(self, i)
+        visit_pat_type_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_pat_wild_mut(&mut self, i: &mut PatWild) {
-        visit_pat_wild_mut(self, i)
+        visit_pat_wild_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_path_mut(&mut self, i: &mut Path) {
-        visit_path_mut(self, i)
+        visit_path_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_path_arguments_mut(&mut self, i: &mut PathArguments) {
-        visit_path_arguments_mut(self, i)
+        visit_path_arguments_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_path_segment_mut(&mut self, i: &mut PathSegment) {
-        visit_path_segment_mut(self, i)
+        visit_path_segment_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_predicate_eq_mut(&mut self, i: &mut PredicateEq) {
-        visit_predicate_eq_mut(self, i)
+        visit_predicate_eq_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_predicate_lifetime_mut(&mut self, i: &mut PredicateLifetime) {
-        visit_predicate_lifetime_mut(self, i)
+        visit_predicate_lifetime_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_predicate_type_mut(&mut self, i: &mut PredicateType) {
-        visit_predicate_type_mut(self, i)
+        visit_predicate_type_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_qself_mut(&mut self, i: &mut QSelf) {
-        visit_qself_mut(self, i)
+        visit_qself_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_range_limits_mut(&mut self, i: &mut RangeLimits) {
-        visit_range_limits_mut(self, i)
+        visit_range_limits_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_receiver_mut(&mut self, i: &mut Receiver) {
-        visit_receiver_mut(self, i)
+        visit_receiver_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_return_type_mut(&mut self, i: &mut ReturnType) {
-        visit_return_type_mut(self, i)
+        visit_return_type_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_signature_mut(&mut self, i: &mut Signature) {
-        visit_signature_mut(self, i)
+        visit_signature_mut(self, i);
     }
     fn visit_span_mut(&mut self, i: &mut Span) {
-        visit_span_mut(self, i)
+        visit_span_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_stmt_mut(&mut self, i: &mut Stmt) {
-        visit_stmt_mut(self, i)
+        visit_stmt_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_trait_bound_mut(&mut self, i: &mut TraitBound) {
-        visit_trait_bound_mut(self, i)
+        visit_trait_bound_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_trait_bound_modifier_mut(&mut self, i: &mut TraitBoundModifier) {
-        visit_trait_bound_modifier_mut(self, i)
+        visit_trait_bound_modifier_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_trait_item_mut(&mut self, i: &mut TraitItem) {
-        visit_trait_item_mut(self, i)
+        visit_trait_item_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_trait_item_const_mut(&mut self, i: &mut TraitItemConst) {
-        visit_trait_item_const_mut(self, i)
+        visit_trait_item_const_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_trait_item_macro_mut(&mut self, i: &mut TraitItemMacro) {
-        visit_trait_item_macro_mut(self, i)
+        visit_trait_item_macro_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_trait_item_method_mut(&mut self, i: &mut TraitItemMethod) {
-        visit_trait_item_method_mut(self, i)
+        visit_trait_item_method_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_trait_item_type_mut(&mut self, i: &mut TraitItemType) {
-        visit_trait_item_type_mut(self, i)
+        visit_trait_item_type_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_mut(&mut self, i: &mut Type) {
-        visit_type_mut(self, i)
+        visit_type_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_array_mut(&mut self, i: &mut TypeArray) {
-        visit_type_array_mut(self, i)
+        visit_type_array_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_bare_fn_mut(&mut self, i: &mut TypeBareFn) {
-        visit_type_bare_fn_mut(self, i)
+        visit_type_bare_fn_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_group_mut(&mut self, i: &mut TypeGroup) {
-        visit_type_group_mut(self, i)
+        visit_type_group_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_impl_trait_mut(&mut self, i: &mut TypeImplTrait) {
-        visit_type_impl_trait_mut(self, i)
+        visit_type_impl_trait_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_infer_mut(&mut self, i: &mut TypeInfer) {
-        visit_type_infer_mut(self, i)
+        visit_type_infer_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_macro_mut(&mut self, i: &mut TypeMacro) {
-        visit_type_macro_mut(self, i)
+        visit_type_macro_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_never_mut(&mut self, i: &mut TypeNever) {
-        visit_type_never_mut(self, i)
+        visit_type_never_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_param_mut(&mut self, i: &mut TypeParam) {
-        visit_type_param_mut(self, i)
+        visit_type_param_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_param_bound_mut(&mut self, i: &mut TypeParamBound) {
-        visit_type_param_bound_mut(self, i)
+        visit_type_param_bound_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_paren_mut(&mut self, i: &mut TypeParen) {
-        visit_type_paren_mut(self, i)
+        visit_type_paren_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_path_mut(&mut self, i: &mut TypePath) {
-        visit_type_path_mut(self, i)
+        visit_type_path_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_ptr_mut(&mut self, i: &mut TypePtr) {
-        visit_type_ptr_mut(self, i)
+        visit_type_ptr_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_reference_mut(&mut self, i: &mut TypeReference) {
-        visit_type_reference_mut(self, i)
+        visit_type_reference_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_slice_mut(&mut self, i: &mut TypeSlice) {
-        visit_type_slice_mut(self, i)
+        visit_type_slice_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_trait_object_mut(&mut self, i: &mut TypeTraitObject) {
-        visit_type_trait_object_mut(self, i)
+        visit_type_trait_object_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_tuple_mut(&mut self, i: &mut TypeTuple) {
-        visit_type_tuple_mut(self, i)
+        visit_type_tuple_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_un_op_mut(&mut self, i: &mut UnOp) {
-        visit_un_op_mut(self, i)
+        visit_un_op_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_use_glob_mut(&mut self, i: &mut UseGlob) {
-        visit_use_glob_mut(self, i)
+        visit_use_glob_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_use_group_mut(&mut self, i: &mut UseGroup) {
-        visit_use_group_mut(self, i)
+        visit_use_group_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_use_name_mut(&mut self, i: &mut UseName) {
-        visit_use_name_mut(self, i)
+        visit_use_name_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_use_path_mut(&mut self, i: &mut UsePath) {
-        visit_use_path_mut(self, i)
+        visit_use_path_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_use_rename_mut(&mut self, i: &mut UseRename) {
-        visit_use_rename_mut(self, i)
+        visit_use_rename_mut(self, i);
     }
     #[cfg(feature = "full")]
     fn visit_use_tree_mut(&mut self, i: &mut UseTree) {
-        visit_use_tree_mut(self, i)
+        visit_use_tree_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_variadic_mut(&mut self, i: &mut Variadic) {
-        visit_variadic_mut(self, i)
+        visit_variadic_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_variant_mut(&mut self, i: &mut Variant) {
-        visit_variant_mut(self, i)
+        visit_variant_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_vis_crate_mut(&mut self, i: &mut VisCrate) {
-        visit_vis_crate_mut(self, i)
+        visit_vis_crate_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_vis_public_mut(&mut self, i: &mut VisPublic) {
-        visit_vis_public_mut(self, i)
+        visit_vis_public_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_vis_restricted_mut(&mut self, i: &mut VisRestricted) {
-        visit_vis_restricted_mut(self, i)
+        visit_vis_restricted_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_visibility_mut(&mut self, i: &mut Visibility) {
-        visit_visibility_mut(self, i)
+        visit_visibility_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_where_clause_mut(&mut self, i: &mut WhereClause) {
-        visit_where_clause_mut(self, i)
+        visit_where_clause_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_where_predicate_mut(&mut self, i: &mut WherePredicate) {
-        visit_where_predicate_mut(self, i)
+        visit_where_predicate_mut(self, i);
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
@@ -780,7 +780,7 @@ where
 {
     tokens_helper(v, &mut node.extern_token.span);
     if let Some(it) = &mut node.name {
-        v.visit_lit_str_mut(it)
+        v.visit_lit_str_mut(it);
     };
 }
 #[cfg(any(feature = "derive", feature = "full"))]
@@ -791,7 +791,7 @@ pub fn visit_angle_bracketed_generic_arguments_mut<V>(
     V: VisitMut + ?Sized,
 {
     if let Some(it) = &mut node.colon2_token {
-        tokens_helper(v, &mut it.spans)
+        tokens_helper(v, &mut it.spans);
     };
     tokens_helper(v, &mut node.lt_token.spans);
     for el in Punctuated::pairs_mut(&mut node.args) {
@@ -809,7 +809,7 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     v.visit_pat_mut(&mut node.pat);
     if let Some(it) = &mut node.guard {
@@ -819,7 +819,7 @@ where
     tokens_helper(v, &mut node.fat_arrow_token.spans);
     v.visit_expr_mut(&mut *node.body);
     if let Some(it) = &mut node.comma {
-        tokens_helper(v, &mut it.spans)
+        tokens_helper(v, &mut it.spans);
     };
 }
 #[cfg(any(feature = "derive", feature = "full"))]
@@ -851,7 +851,7 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     if let Some(it) = &mut node.name {
         v.visit_ident_mut(&mut (it).0);
@@ -967,7 +967,7 @@ where
 {
     tokens_helper(v, &mut node.brace_token.span);
     for it in &mut node.stmts {
-        v.visit_stmt_mut(it)
+        v.visit_stmt_mut(it);
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
@@ -992,17 +992,17 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     tokens_helper(v, &mut node.const_token.span);
     v.visit_ident_mut(&mut node.ident);
     tokens_helper(v, &mut node.colon_token.spans);
     v.visit_type_mut(&mut node.ty);
     if let Some(it) = &mut node.eq_token {
-        tokens_helper(v, &mut it.spans)
+        tokens_helper(v, &mut it.spans);
     };
     if let Some(it) = &mut node.default {
-        v.visit_expr_mut(it)
+        v.visit_expr_mut(it);
     };
 }
 #[cfg(any(feature = "derive", feature = "full"))]
@@ -1060,7 +1060,7 @@ where
     tokens_helper(v, &mut node.struct_token.span);
     v.visit_fields_mut(&mut node.fields);
     if let Some(it) = &mut node.semi_token {
-        tokens_helper(v, &mut it.spans)
+        tokens_helper(v, &mut it.spans);
     };
 }
 #[cfg(feature = "derive")]
@@ -1077,7 +1077,7 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     v.visit_visibility_mut(&mut node.vis);
     v.visit_ident_mut(&mut node.ident);
@@ -1219,7 +1219,7 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     tokens_helper(v, &mut node.bracket_token.span);
     for el in Punctuated::pairs_mut(&mut node.elems) {
@@ -1236,7 +1236,7 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     v.visit_expr_mut(&mut *node.left);
     tokens_helper(v, &mut node.eq_token.spans);
@@ -1248,7 +1248,7 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     v.visit_expr_mut(&mut *node.left);
     v.visit_bin_op_mut(&mut node.op);
@@ -1260,11 +1260,11 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     tokens_helper(v, &mut node.async_token.span);
     if let Some(it) = &mut node.capture {
-        tokens_helper(v, &mut it.span)
+        tokens_helper(v, &mut it.span);
     };
     v.visit_block_mut(&mut node.block);
 }
@@ -1274,7 +1274,7 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     v.visit_expr_mut(&mut *node.base);
     tokens_helper(v, &mut node.dot_token.spans);
@@ -1286,7 +1286,7 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     v.visit_expr_mut(&mut *node.left);
     v.visit_bin_op_mut(&mut node.op);
@@ -1298,10 +1298,10 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     if let Some(it) = &mut node.label {
-        v.visit_label_mut(it)
+        v.visit_label_mut(it);
     };
     v.visit_block_mut(&mut node.block);
 }
@@ -1311,7 +1311,7 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     tokens_helper(v, &mut node.box_token.span);
     v.visit_expr_mut(&mut *node.expr);
@@ -1322,14 +1322,14 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     tokens_helper(v, &mut node.break_token.span);
     if let Some(it) = &mut node.label {
-        v.visit_lifetime_mut(it)
+        v.visit_lifetime_mut(it);
     };
     if let Some(it) = &mut node.expr {
-        v.visit_expr_mut(&mut **it)
+        v.visit_expr_mut(&mut **it);
     };
 }
 #[cfg(any(feature = "derive", feature = "full"))]
@@ -1338,7 +1338,7 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     v.visit_expr_mut(&mut *node.func);
     tokens_helper(v, &mut node.paren_token.span);
@@ -1356,7 +1356,7 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     v.visit_expr_mut(&mut *node.expr);
     tokens_helper(v, &mut node.as_token.span);
@@ -1368,16 +1368,16 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     if let Some(it) = &mut node.asyncness {
-        tokens_helper(v, &mut it.span)
+        tokens_helper(v, &mut it.span);
     };
     if let Some(it) = &mut node.movability {
-        tokens_helper(v, &mut it.span)
+        tokens_helper(v, &mut it.span);
     };
     if let Some(it) = &mut node.capture {
-        tokens_helper(v, &mut it.span)
+        tokens_helper(v, &mut it.span);
     };
     tokens_helper(v, &mut node.or1_token.spans);
     for el in Punctuated::pairs_mut(&mut node.inputs) {
@@ -1397,11 +1397,11 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     tokens_helper(v, &mut node.continue_token.span);
     if let Some(it) = &mut node.label {
-        v.visit_lifetime_mut(it)
+        v.visit_lifetime_mut(it);
     };
 }
 #[cfg(any(feature = "derive", feature = "full"))]
@@ -1410,7 +1410,7 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     v.visit_expr_mut(&mut *node.base);
     tokens_helper(v, &mut node.dot_token.spans);
@@ -1422,10 +1422,10 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     if let Some(it) = &mut node.label {
-        v.visit_label_mut(it)
+        v.visit_label_mut(it);
     };
     tokens_helper(v, &mut node.for_token.span);
     v.visit_pat_mut(&mut node.pat);
@@ -1439,7 +1439,7 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     tokens_helper(v, &mut node.group_token.span);
     v.visit_expr_mut(&mut *node.expr);
@@ -1450,7 +1450,7 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     tokens_helper(v, &mut node.if_token.span);
     v.visit_expr_mut(&mut *node.cond);
@@ -1466,7 +1466,7 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     v.visit_expr_mut(&mut *node.expr);
     tokens_helper(v, &mut node.bracket_token.span);
@@ -1478,7 +1478,7 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     tokens_helper(v, &mut node.let_token.span);
     v.visit_pat_mut(&mut node.pat);
@@ -1491,7 +1491,7 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     v.visit_lit_mut(&mut node.lit);
 }
@@ -1501,10 +1501,10 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     if let Some(it) = &mut node.label {
-        v.visit_label_mut(it)
+        v.visit_label_mut(it);
     };
     tokens_helper(v, &mut node.loop_token.span);
     v.visit_block_mut(&mut node.body);
@@ -1515,7 +1515,7 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     v.visit_macro_mut(&mut node.mac);
 }
@@ -1525,13 +1525,13 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     tokens_helper(v, &mut node.match_token.span);
     v.visit_expr_mut(&mut *node.expr);
     tokens_helper(v, &mut node.brace_token.span);
     for it in &mut node.arms {
-        v.visit_arm_mut(it)
+        v.visit_arm_mut(it);
     }
 }
 #[cfg(feature = "full")]
@@ -1540,13 +1540,13 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     v.visit_expr_mut(&mut *node.receiver);
     tokens_helper(v, &mut node.dot_token.spans);
     v.visit_ident_mut(&mut node.method);
     if let Some(it) = &mut node.turbofish {
-        v.visit_method_turbofish_mut(it)
+        v.visit_method_turbofish_mut(it);
     };
     tokens_helper(v, &mut node.paren_token.span);
     for el in Punctuated::pairs_mut(&mut node.args) {
@@ -1563,7 +1563,7 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     tokens_helper(v, &mut node.paren_token.span);
     v.visit_expr_mut(&mut *node.expr);
@@ -1574,10 +1574,10 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     if let Some(it) = &mut node.qself {
-        v.visit_qself_mut(it)
+        v.visit_qself_mut(it);
     };
     v.visit_path_mut(&mut node.path);
 }
@@ -1587,14 +1587,14 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     if let Some(it) = &mut node.from {
-        v.visit_expr_mut(&mut **it)
+        v.visit_expr_mut(&mut **it);
     };
     v.visit_range_limits_mut(&mut node.limits);
     if let Some(it) = &mut node.to {
-        v.visit_expr_mut(&mut **it)
+        v.visit_expr_mut(&mut **it);
     };
 }
 #[cfg(feature = "full")]
@@ -1603,11 +1603,11 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     tokens_helper(v, &mut node.and_token.spans);
     if let Some(it) = &mut node.mutability {
-        tokens_helper(v, &mut it.span)
+        tokens_helper(v, &mut it.span);
     };
     v.visit_expr_mut(&mut *node.expr);
 }
@@ -1617,7 +1617,7 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     tokens_helper(v, &mut node.bracket_token.span);
     v.visit_expr_mut(&mut *node.expr);
@@ -1630,11 +1630,11 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     tokens_helper(v, &mut node.return_token.span);
     if let Some(it) = &mut node.expr {
-        v.visit_expr_mut(&mut **it)
+        v.visit_expr_mut(&mut **it);
     };
 }
 #[cfg(feature = "full")]
@@ -1643,7 +1643,7 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     v.visit_path_mut(&mut node.path);
     tokens_helper(v, &mut node.brace_token.span);
@@ -1655,10 +1655,10 @@ where
         }
     }
     if let Some(it) = &mut node.dot2_token {
-        tokens_helper(v, &mut it.spans)
+        tokens_helper(v, &mut it.spans);
     };
     if let Some(it) = &mut node.rest {
-        v.visit_expr_mut(&mut **it)
+        v.visit_expr_mut(&mut **it);
     };
 }
 #[cfg(feature = "full")]
@@ -1667,7 +1667,7 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     v.visit_expr_mut(&mut *node.expr);
     tokens_helper(v, &mut node.question_token.spans);
@@ -1678,7 +1678,7 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     tokens_helper(v, &mut node.try_token.span);
     v.visit_block_mut(&mut node.block);
@@ -1689,7 +1689,7 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     tokens_helper(v, &mut node.paren_token.span);
     for el in Punctuated::pairs_mut(&mut node.elems) {
@@ -1706,7 +1706,7 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     v.visit_expr_mut(&mut *node.expr);
     tokens_helper(v, &mut node.colon_token.spans);
@@ -1718,7 +1718,7 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     v.visit_un_op_mut(&mut node.op);
     v.visit_expr_mut(&mut *node.expr);
@@ -1729,7 +1729,7 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     tokens_helper(v, &mut node.unsafe_token.span);
     v.visit_block_mut(&mut node.block);
@@ -1740,10 +1740,10 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     if let Some(it) = &mut node.label {
-        v.visit_label_mut(it)
+        v.visit_label_mut(it);
     };
     tokens_helper(v, &mut node.while_token.span);
     v.visit_expr_mut(&mut *node.cond);
@@ -1755,11 +1755,11 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     tokens_helper(v, &mut node.yield_token.span);
     if let Some(it) = &mut node.expr {
-        v.visit_expr_mut(&mut **it)
+        v.visit_expr_mut(&mut **it);
     };
 }
 #[cfg(any(feature = "derive", feature = "full"))]
@@ -1768,14 +1768,14 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     v.visit_visibility_mut(&mut node.vis);
     if let Some(it) = &mut node.ident {
-        v.visit_ident_mut(it)
+        v.visit_ident_mut(it);
     };
     if let Some(it) = &mut node.colon_token {
-        tokens_helper(v, &mut it.spans)
+        tokens_helper(v, &mut it.spans);
     };
     v.visit_type_mut(&mut node.ty);
 }
@@ -1785,11 +1785,11 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     v.visit_member_mut(&mut node.member);
     if let Some(it) = &mut node.colon_token {
-        tokens_helper(v, &mut it.spans)
+        tokens_helper(v, &mut it.spans);
     };
     v.visit_pat_mut(&mut *node.pat);
 }
@@ -1799,11 +1799,11 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     v.visit_member_mut(&mut node.member);
     if let Some(it) = &mut node.colon_token {
-        tokens_helper(v, &mut it.spans)
+        tokens_helper(v, &mut it.spans);
     };
     v.visit_expr_mut(&mut node.expr);
 }
@@ -1857,10 +1857,10 @@ where
 {
     skip!(node.shebang);
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     for it in &mut node.items {
-        v.visit_item_mut(it)
+        v.visit_item_mut(it);
     }
 }
 #[cfg(feature = "full")]
@@ -1907,7 +1907,7 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     v.visit_visibility_mut(&mut node.vis);
     v.visit_signature_mut(&mut node.sig);
@@ -1919,11 +1919,11 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     v.visit_macro_mut(&mut node.mac);
     if let Some(it) = &mut node.semi_token {
-        tokens_helper(v, &mut it.spans)
+        tokens_helper(v, &mut it.spans);
     };
 }
 #[cfg(feature = "full")]
@@ -1932,12 +1932,12 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     v.visit_visibility_mut(&mut node.vis);
     tokens_helper(v, &mut node.static_token.span);
     if let Some(it) = &mut node.mutability {
-        tokens_helper(v, &mut it.span)
+        tokens_helper(v, &mut it.span);
     };
     v.visit_ident_mut(&mut node.ident);
     tokens_helper(v, &mut node.colon_token.spans);
@@ -1950,7 +1950,7 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     v.visit_visibility_mut(&mut node.vis);
     tokens_helper(v, &mut node.type_token.span);
@@ -2017,7 +2017,7 @@ where
     V: VisitMut + ?Sized,
 {
     if let Some(it) = &mut node.lt_token {
-        tokens_helper(v, &mut it.spans)
+        tokens_helper(v, &mut it.spans);
     };
     for el in Punctuated::pairs_mut(&mut node.params) {
         let (it, p) = el.into_tuple();
@@ -2027,10 +2027,10 @@ where
         }
     }
     if let Some(it) = &mut node.gt_token {
-        tokens_helper(v, &mut it.spans)
+        tokens_helper(v, &mut it.spans);
     };
     if let Some(it) = &mut node.where_clause {
-        v.visit_where_clause_mut(it)
+        v.visit_where_clause_mut(it);
     };
 }
 pub fn visit_ident_mut<V>(v: &mut V, node: &mut Ident)
@@ -2071,11 +2071,11 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     v.visit_visibility_mut(&mut node.vis);
     if let Some(it) = &mut node.defaultness {
-        tokens_helper(v, &mut it.span)
+        tokens_helper(v, &mut it.span);
     };
     tokens_helper(v, &mut node.const_token.span);
     v.visit_ident_mut(&mut node.ident);
@@ -2091,11 +2091,11 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     v.visit_macro_mut(&mut node.mac);
     if let Some(it) = &mut node.semi_token {
-        tokens_helper(v, &mut it.spans)
+        tokens_helper(v, &mut it.spans);
     };
 }
 #[cfg(feature = "full")]
@@ -2104,11 +2104,11 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     v.visit_visibility_mut(&mut node.vis);
     if let Some(it) = &mut node.defaultness {
-        tokens_helper(v, &mut it.span)
+        tokens_helper(v, &mut it.span);
     };
     v.visit_signature_mut(&mut node.sig);
     v.visit_block_mut(&mut node.block);
@@ -2119,11 +2119,11 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     v.visit_visibility_mut(&mut node.vis);
     if let Some(it) = &mut node.defaultness {
-        tokens_helper(v, &mut it.span)
+        tokens_helper(v, &mut it.span);
     };
     tokens_helper(v, &mut node.type_token.span);
     v.visit_ident_mut(&mut node.ident);
@@ -2206,7 +2206,7 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     v.visit_visibility_mut(&mut node.vis);
     tokens_helper(v, &mut node.const_token.span);
@@ -2223,7 +2223,7 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     v.visit_visibility_mut(&mut node.vis);
     tokens_helper(v, &mut node.enum_token.span);
@@ -2244,7 +2244,7 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     v.visit_visibility_mut(&mut node.vis);
     tokens_helper(v, &mut node.extern_token.span);
@@ -2262,7 +2262,7 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     v.visit_visibility_mut(&mut node.vis);
     v.visit_signature_mut(&mut node.sig);
@@ -2274,12 +2274,12 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     v.visit_abi_mut(&mut node.abi);
     tokens_helper(v, &mut node.brace_token.span);
     for it in &mut node.items {
-        v.visit_foreign_item_mut(it)
+        v.visit_foreign_item_mut(it);
     }
 }
 #[cfg(feature = "full")]
@@ -2288,19 +2288,19 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     if let Some(it) = &mut node.defaultness {
-        tokens_helper(v, &mut it.span)
+        tokens_helper(v, &mut it.span);
     };
     if let Some(it) = &mut node.unsafety {
-        tokens_helper(v, &mut it.span)
+        tokens_helper(v, &mut it.span);
     };
     tokens_helper(v, &mut node.impl_token.span);
     v.visit_generics_mut(&mut node.generics);
     if let Some(it) = &mut node.trait_ {
         if let Some(it) = &mut (it).0 {
-            tokens_helper(v, &mut it.spans)
+            tokens_helper(v, &mut it.spans);
         };
         v.visit_path_mut(&mut (it).1);
         tokens_helper(v, &mut (it).2.span);
@@ -2308,7 +2308,7 @@ where
     v.visit_type_mut(&mut *node.self_ty);
     tokens_helper(v, &mut node.brace_token.span);
     for it in &mut node.items {
-        v.visit_impl_item_mut(it)
+        v.visit_impl_item_mut(it);
     }
 }
 #[cfg(feature = "full")]
@@ -2317,14 +2317,14 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     if let Some(it) = &mut node.ident {
-        v.visit_ident_mut(it)
+        v.visit_ident_mut(it);
     };
     v.visit_macro_mut(&mut node.mac);
     if let Some(it) = &mut node.semi_token {
-        tokens_helper(v, &mut it.spans)
+        tokens_helper(v, &mut it.spans);
     };
 }
 #[cfg(feature = "full")]
@@ -2333,7 +2333,7 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     v.visit_visibility_mut(&mut node.vis);
     tokens_helper(v, &mut node.macro_token.span);
@@ -2346,7 +2346,7 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     v.visit_visibility_mut(&mut node.vis);
     tokens_helper(v, &mut node.mod_token.span);
@@ -2354,11 +2354,11 @@ where
     if let Some(it) = &mut node.content {
         tokens_helper(v, &mut (it).0.span);
         for it in &mut (it).1 {
-            v.visit_item_mut(it)
+            v.visit_item_mut(it);
         }
     };
     if let Some(it) = &mut node.semi {
-        tokens_helper(v, &mut it.spans)
+        tokens_helper(v, &mut it.spans);
     };
 }
 #[cfg(feature = "full")]
@@ -2367,12 +2367,12 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     v.visit_visibility_mut(&mut node.vis);
     tokens_helper(v, &mut node.static_token.span);
     if let Some(it) = &mut node.mutability {
-        tokens_helper(v, &mut it.span)
+        tokens_helper(v, &mut it.span);
     };
     v.visit_ident_mut(&mut node.ident);
     tokens_helper(v, &mut node.colon_token.spans);
@@ -2387,7 +2387,7 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     v.visit_visibility_mut(&mut node.vis);
     tokens_helper(v, &mut node.struct_token.span);
@@ -2395,7 +2395,7 @@ where
     v.visit_generics_mut(&mut node.generics);
     v.visit_fields_mut(&mut node.fields);
     if let Some(it) = &mut node.semi_token {
-        tokens_helper(v, &mut it.spans)
+        tokens_helper(v, &mut it.spans);
     };
 }
 #[cfg(feature = "full")]
@@ -2404,20 +2404,20 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     v.visit_visibility_mut(&mut node.vis);
     if let Some(it) = &mut node.unsafety {
-        tokens_helper(v, &mut it.span)
+        tokens_helper(v, &mut it.span);
     };
     if let Some(it) = &mut node.auto_token {
-        tokens_helper(v, &mut it.span)
+        tokens_helper(v, &mut it.span);
     };
     tokens_helper(v, &mut node.trait_token.span);
     v.visit_ident_mut(&mut node.ident);
     v.visit_generics_mut(&mut node.generics);
     if let Some(it) = &mut node.colon_token {
-        tokens_helper(v, &mut it.spans)
+        tokens_helper(v, &mut it.spans);
     };
     for el in Punctuated::pairs_mut(&mut node.supertraits) {
         let (it, p) = el.into_tuple();
@@ -2428,7 +2428,7 @@ where
     }
     tokens_helper(v, &mut node.brace_token.span);
     for it in &mut node.items {
-        v.visit_trait_item_mut(it)
+        v.visit_trait_item_mut(it);
     }
 }
 #[cfg(feature = "full")]
@@ -2437,7 +2437,7 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     v.visit_visibility_mut(&mut node.vis);
     tokens_helper(v, &mut node.trait_token.span);
@@ -2459,7 +2459,7 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     v.visit_visibility_mut(&mut node.vis);
     tokens_helper(v, &mut node.type_token.span);
@@ -2475,7 +2475,7 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     v.visit_visibility_mut(&mut node.vis);
     tokens_helper(v, &mut node.union_token.span);
@@ -2489,12 +2489,12 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     v.visit_visibility_mut(&mut node.vis);
     tokens_helper(v, &mut node.use_token.span);
     if let Some(it) = &mut node.leading_colon {
-        tokens_helper(v, &mut it.spans)
+        tokens_helper(v, &mut it.spans);
     };
     v.visit_use_tree_mut(&mut node.tree);
     tokens_helper(v, &mut node.semi_token.spans);
@@ -2520,11 +2520,11 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     v.visit_lifetime_mut(&mut node.lifetime);
     if let Some(it) = &mut node.colon_token {
-        tokens_helper(v, &mut it.spans)
+        tokens_helper(v, &mut it.spans);
     };
     for el in Punctuated::pairs_mut(&mut node.bounds) {
         let (it, p) = el.into_tuple();
@@ -2608,7 +2608,7 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     tokens_helper(v, &mut node.let_token.span);
     v.visit_pat_mut(&mut node.pat);
@@ -2810,7 +2810,7 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     tokens_helper(v, &mut node.box_token.span);
     v.visit_pat_mut(&mut *node.pat);
@@ -2821,13 +2821,13 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     if let Some(it) = &mut node.by_ref {
-        tokens_helper(v, &mut it.span)
+        tokens_helper(v, &mut it.span);
     };
     if let Some(it) = &mut node.mutability {
-        tokens_helper(v, &mut it.span)
+        tokens_helper(v, &mut it.span);
     };
     v.visit_ident_mut(&mut node.ident);
     if let Some(it) = &mut node.subpat {
@@ -2841,7 +2841,7 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     v.visit_expr_mut(&mut *node.expr);
 }
@@ -2851,7 +2851,7 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     v.visit_macro_mut(&mut node.mac);
 }
@@ -2861,10 +2861,10 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     if let Some(it) = &mut node.leading_vert {
-        tokens_helper(v, &mut it.spans)
+        tokens_helper(v, &mut it.spans);
     };
     for el in Punctuated::pairs_mut(&mut node.cases) {
         let (it, p) = el.into_tuple();
@@ -2880,10 +2880,10 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     if let Some(it) = &mut node.qself {
-        v.visit_qself_mut(it)
+        v.visit_qself_mut(it);
     };
     v.visit_path_mut(&mut node.path);
 }
@@ -2893,7 +2893,7 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     v.visit_expr_mut(&mut *node.lo);
     v.visit_range_limits_mut(&mut node.limits);
@@ -2905,11 +2905,11 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     tokens_helper(v, &mut node.and_token.spans);
     if let Some(it) = &mut node.mutability {
-        tokens_helper(v, &mut it.span)
+        tokens_helper(v, &mut it.span);
     };
     v.visit_pat_mut(&mut *node.pat);
 }
@@ -2919,7 +2919,7 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     tokens_helper(v, &mut node.dot2_token.spans);
 }
@@ -2929,7 +2929,7 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     tokens_helper(v, &mut node.bracket_token.span);
     for el in Punctuated::pairs_mut(&mut node.elems) {
@@ -2946,7 +2946,7 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     v.visit_path_mut(&mut node.path);
     tokens_helper(v, &mut node.brace_token.span);
@@ -2958,7 +2958,7 @@ where
         }
     }
     if let Some(it) = &mut node.dot2_token {
-        tokens_helper(v, &mut it.spans)
+        tokens_helper(v, &mut it.spans);
     };
 }
 #[cfg(feature = "full")]
@@ -2967,7 +2967,7 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     tokens_helper(v, &mut node.paren_token.span);
     for el in Punctuated::pairs_mut(&mut node.elems) {
@@ -2984,7 +2984,7 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     v.visit_path_mut(&mut node.path);
     v.visit_pat_tuple_mut(&mut node.pat);
@@ -2995,7 +2995,7 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     v.visit_pat_mut(&mut *node.pat);
     tokens_helper(v, &mut node.colon_token.spans);
@@ -3007,7 +3007,7 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     tokens_helper(v, &mut node.underscore_token.spans);
 }
@@ -3017,7 +3017,7 @@ where
     V: VisitMut + ?Sized,
 {
     if let Some(it) = &mut node.leading_colon {
-        tokens_helper(v, &mut it.spans)
+        tokens_helper(v, &mut it.spans);
     };
     for el in Punctuated::pairs_mut(&mut node.segments) {
         let (it, p) = el.into_tuple();
@@ -3080,7 +3080,7 @@ where
     V: VisitMut + ?Sized,
 {
     if let Some(it) = &mut node.lifetimes {
-        v.visit_bound_lifetimes_mut(it)
+        v.visit_bound_lifetimes_mut(it);
     };
     v.visit_type_mut(&mut node.bounded_ty);
     tokens_helper(v, &mut node.colon_token.spans);
@@ -3101,7 +3101,7 @@ where
     v.visit_type_mut(&mut *node.ty);
     skip!(node.position);
     if let Some(it) = &mut node.as_token {
-        tokens_helper(v, &mut it.span)
+        tokens_helper(v, &mut it.span);
     };
     tokens_helper(v, &mut node.gt_token.spans);
 }
@@ -3125,16 +3125,16 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     if let Some(it) = &mut node.reference {
         tokens_helper(v, &mut (it).0.spans);
         if let Some(it) = &mut (it).1 {
-            v.visit_lifetime_mut(it)
+            v.visit_lifetime_mut(it);
         };
     };
     if let Some(it) = &mut node.mutability {
-        tokens_helper(v, &mut it.span)
+        tokens_helper(v, &mut it.span);
     };
     tokens_helper(v, &mut node.self_token.span);
 }
@@ -3157,16 +3157,16 @@ where
     V: VisitMut + ?Sized,
 {
     if let Some(it) = &mut node.constness {
-        tokens_helper(v, &mut it.span)
+        tokens_helper(v, &mut it.span);
     };
     if let Some(it) = &mut node.asyncness {
-        tokens_helper(v, &mut it.span)
+        tokens_helper(v, &mut it.span);
     };
     if let Some(it) = &mut node.unsafety {
-        tokens_helper(v, &mut it.span)
+        tokens_helper(v, &mut it.span);
     };
     if let Some(it) = &mut node.abi {
-        v.visit_abi_mut(it)
+        v.visit_abi_mut(it);
     };
     tokens_helper(v, &mut node.fn_token.span);
     v.visit_ident_mut(&mut node.ident);
@@ -3180,7 +3180,7 @@ where
         }
     }
     if let Some(it) = &mut node.variadic {
-        v.visit_variadic_mut(it)
+        v.visit_variadic_mut(it);
     };
     v.visit_return_type_mut(&mut node.output);
 }
@@ -3216,11 +3216,11 @@ where
     V: VisitMut + ?Sized,
 {
     if let Some(it) = &mut node.paren_token {
-        tokens_helper(v, &mut it.span)
+        tokens_helper(v, &mut it.span);
     };
     v.visit_trait_bound_modifier_mut(&mut node.modifier);
     if let Some(it) = &mut node.lifetimes {
-        v.visit_bound_lifetimes_mut(it)
+        v.visit_bound_lifetimes_mut(it);
     };
     v.visit_path_mut(&mut node.path);
 }
@@ -3266,7 +3266,7 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     tokens_helper(v, &mut node.const_token.span);
     v.visit_ident_mut(&mut node.ident);
@@ -3284,11 +3284,11 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     v.visit_macro_mut(&mut node.mac);
     if let Some(it) = &mut node.semi_token {
-        tokens_helper(v, &mut it.spans)
+        tokens_helper(v, &mut it.spans);
     };
 }
 #[cfg(feature = "full")]
@@ -3297,14 +3297,14 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     v.visit_signature_mut(&mut node.sig);
     if let Some(it) = &mut node.default {
-        v.visit_block_mut(it)
+        v.visit_block_mut(it);
     };
     if let Some(it) = &mut node.semi_token {
-        tokens_helper(v, &mut it.spans)
+        tokens_helper(v, &mut it.spans);
     };
 }
 #[cfg(feature = "full")]
@@ -3313,13 +3313,13 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     tokens_helper(v, &mut node.type_token.span);
     v.visit_ident_mut(&mut node.ident);
     v.visit_generics_mut(&mut node.generics);
     if let Some(it) = &mut node.colon_token {
-        tokens_helper(v, &mut it.spans)
+        tokens_helper(v, &mut it.spans);
     };
     for el in Punctuated::pairs_mut(&mut node.bounds) {
         let (it, p) = el.into_tuple();
@@ -3404,13 +3404,13 @@ where
     V: VisitMut + ?Sized,
 {
     if let Some(it) = &mut node.lifetimes {
-        v.visit_bound_lifetimes_mut(it)
+        v.visit_bound_lifetimes_mut(it);
     };
     if let Some(it) = &mut node.unsafety {
-        tokens_helper(v, &mut it.span)
+        tokens_helper(v, &mut it.span);
     };
     if let Some(it) = &mut node.abi {
-        v.visit_abi_mut(it)
+        v.visit_abi_mut(it);
     };
     tokens_helper(v, &mut node.fn_token.span);
     tokens_helper(v, &mut node.paren_token.span);
@@ -3422,7 +3422,7 @@ where
         }
     }
     if let Some(it) = &mut node.variadic {
-        v.visit_variadic_mut(it)
+        v.visit_variadic_mut(it);
     };
     v.visit_return_type_mut(&mut node.output);
 }
@@ -3475,11 +3475,11 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     v.visit_ident_mut(&mut node.ident);
     if let Some(it) = &mut node.colon_token {
-        tokens_helper(v, &mut it.spans)
+        tokens_helper(v, &mut it.spans);
     };
     for el in Punctuated::pairs_mut(&mut node.bounds) {
         let (it, p) = el.into_tuple();
@@ -3489,10 +3489,10 @@ where
         }
     }
     if let Some(it) = &mut node.eq_token {
-        tokens_helper(v, &mut it.spans)
+        tokens_helper(v, &mut it.spans);
     };
     if let Some(it) = &mut node.default {
-        v.visit_type_mut(it)
+        v.visit_type_mut(it);
     };
 }
 #[cfg(any(feature = "derive", feature = "full"))]
@@ -3523,7 +3523,7 @@ where
     V: VisitMut + ?Sized,
 {
     if let Some(it) = &mut node.qself {
-        v.visit_qself_mut(it)
+        v.visit_qself_mut(it);
     };
     v.visit_path_mut(&mut node.path);
 }
@@ -3534,10 +3534,10 @@ where
 {
     tokens_helper(v, &mut node.star_token.spans);
     if let Some(it) = &mut node.const_token {
-        tokens_helper(v, &mut it.span)
+        tokens_helper(v, &mut it.span);
     };
     if let Some(it) = &mut node.mutability {
-        tokens_helper(v, &mut it.span)
+        tokens_helper(v, &mut it.span);
     };
     v.visit_type_mut(&mut *node.elem);
 }
@@ -3548,10 +3548,10 @@ where
 {
     tokens_helper(v, &mut node.and_token.spans);
     if let Some(it) = &mut node.lifetime {
-        v.visit_lifetime_mut(it)
+        v.visit_lifetime_mut(it);
     };
     if let Some(it) = &mut node.mutability {
-        tokens_helper(v, &mut it.span)
+        tokens_helper(v, &mut it.span);
     };
     v.visit_type_mut(&mut *node.elem);
 }
@@ -3569,7 +3569,7 @@ where
     V: VisitMut + ?Sized,
 {
     if let Some(it) = &mut node.dyn_token {
-        tokens_helper(v, &mut it.span)
+        tokens_helper(v, &mut it.span);
     };
     for el in Punctuated::pairs_mut(&mut node.bounds) {
         let (it, p) = el.into_tuple();
@@ -3685,7 +3685,7 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     tokens_helper(v, &mut node.dots.spans);
 }
@@ -3695,7 +3695,7 @@ where
     V: VisitMut + ?Sized,
 {
     for it in &mut node.attrs {
-        v.visit_attribute_mut(it)
+        v.visit_attribute_mut(it);
     }
     v.visit_ident_mut(&mut node.ident);
     v.visit_fields_mut(&mut node.fields);
@@ -3726,7 +3726,7 @@ where
     tokens_helper(v, &mut node.pub_token.span);
     tokens_helper(v, &mut node.paren_token.span);
     if let Some(it) = &mut node.in_token {
-        tokens_helper(v, &mut it.span)
+        tokens_helper(v, &mut it.span);
     };
     v.visit_path_mut(&mut *node.path);
 }
diff --git a/src/item.rs b/src/item.rs
index 28ccf8dd..acc56f86 100644
--- a/src/item.rs
+++ b/src/item.rs
@@ -2512,7 +2512,7 @@ pub mod parsing {
                 if let Type::Path(TypePath { qself: None, path }) = first_ty {
                     trait_ = Some((polarity, path, for_token));
                 } else {
-                    unreachable!()
+                    unreachable!();
                 }
             } else if !allow_verbatim_impl {
                 #[cfg(feature = "printing")]
diff --git a/src/lib.rs b/src/lib.rs
index 6816025a..fa302ad1 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -250,7 +250,7 @@
 //!   dynamic library libproc_macro from rustc toolchain.
 
 // Syn types in rustdoc of other crates get linked to here.
-#![doc(html_root_url = "https://docs.rs/syn/1.0.72")]
+#![doc(html_root_url = "https://docs.rs/syn/1.0.73")]
 #![cfg_attr(doc_cfg, feature(doc_cfg))]
 #![allow(non_camel_case_types)]
 // Ignored clippy lints.
diff --git a/src/lifetime.rs b/src/lifetime.rs
index 28cd7e36..5dc1753a 100644
--- a/src/lifetime.rs
+++ b/src/lifetime.rs
@@ -108,7 +108,7 @@ impl Ord for Lifetime {
 
 impl Hash for Lifetime {
     fn hash<H: Hasher>(&self, h: &mut H) {
-        self.ident.hash(h)
+        self.ident.hash(h);
     }
 }
 
diff --git a/src/lit.rs b/src/lit.rs
index d74e1225..9ea2e8c0 100644
--- a/src/lit.rs
+++ b/src/lit.rs
@@ -238,7 +238,7 @@ impl LitStr {
     }
 
     pub fn set_span(&mut self, span: Span) {
-        self.repr.token.set_span(span)
+        self.repr.token.set_span(span);
     }
 
     pub fn suffix(&self) -> &str {
@@ -269,7 +269,7 @@ impl LitByteStr {
     }
 
     pub fn set_span(&mut self, span: Span) {
-        self.repr.token.set_span(span)
+        self.repr.token.set_span(span);
     }
 
     pub fn suffix(&self) -> &str {
@@ -300,7 +300,7 @@ impl LitByte {
     }
 
     pub fn set_span(&mut self, span: Span) {
-        self.repr.token.set_span(span)
+        self.repr.token.set_span(span);
     }
 
     pub fn suffix(&self) -> &str {
@@ -331,7 +331,7 @@ impl LitChar {
     }
 
     pub fn set_span(&mut self, span: Span) {
-        self.repr.token.set_span(span)
+        self.repr.token.set_span(span);
     }
 
     pub fn suffix(&self) -> &str {
@@ -406,7 +406,7 @@ impl LitInt {
     }
 
     pub fn set_span(&mut self, span: Span) {
-        self.repr.token.set_span(span)
+        self.repr.token.set_span(span);
     }
 }
 
@@ -478,7 +478,7 @@ impl LitFloat {
     }
 
     pub fn set_span(&mut self, span: Span) {
-        self.repr.token.set_span(span)
+        self.repr.token.set_span(span);
     }
 }
 
@@ -1437,7 +1437,7 @@ mod value {
         }
 
         let suffix = s;
-        if suffix.is_empty() || crate::ident::xid_ok(&suffix) {
+        if suffix.is_empty() || crate::ident::xid_ok(suffix) {
             let mut repr = value.to_string();
             if negative {
                 repr.insert(0, '-');
diff --git a/src/punctuated.rs b/src/punctuated.rs
index f94edc29..5cf5235e 100644
--- a/src/punctuated.rs
+++ b/src/punctuated.rs
@@ -1017,7 +1017,7 @@ mod printing {
         P: ToTokens,
     {
         fn to_tokens(&self, tokens: &mut TokenStream) {
-            tokens.append_all(self.pairs())
+            tokens.append_all(self.pairs());
         }
     }
 
diff --git a/tests/common/eq.rs b/tests/common/eq.rs
index d632db83..3c283ca4 100644
--- a/tests/common/eq.rs
+++ b/tests/common/eq.rs
@@ -8,7 +8,7 @@ use rustc_ast::ast::{
     BinOpKind, BindingMode, Block, BlockCheckMode, BorrowKind, CaptureBy, Const, Crate, CrateSugar,
     Defaultness, EnumDef, Expr, ExprField, ExprKind, Extern, FieldDef, FloatTy, FnDecl, FnHeader,
     FnKind, FnRetTy, FnSig, ForeignItemKind, ForeignMod, GenericArg, GenericArgs, GenericBound,
-    GenericParam, GenericParamKind, Generics, GlobalAsm, ImplKind, ImplPolarity, Inline, InlineAsm,
+    GenericParam, GenericParamKind, Generics, ImplKind, ImplPolarity, Inline, InlineAsm,
     InlineAsmOperand, InlineAsmOptions, InlineAsmRegOrRegClass, InlineAsmTemplatePiece, IntTy,
     IsAuto, Item, ItemKind, Label, Lifetime, Lit, LitFloatType, LitIntType, LitKind,
     LlvmAsmDialect, LlvmInlineAsm, LlvmInlineAsmOutput, Local, MacArgs, MacCall, MacCallStmt,
@@ -307,7 +307,6 @@ spanless_eq_struct!(FnSig; header decl span);
 spanless_eq_struct!(ForeignMod; unsafety abi items);
 spanless_eq_struct!(GenericParam; id ident attrs bounds is_placeholder kind);
 spanless_eq_struct!(Generics; params where_clause span);
-spanless_eq_struct!(GlobalAsm; asm);
 spanless_eq_struct!(ImplKind; unsafety polarity defaultness constness generics of_trait self_ty items);
 spanless_eq_struct!(InlineAsm; template operands options line_spans);
 spanless_eq_struct!(Item<K>; attrs id span vis ident kind !tokens);
@@ -417,8 +416,9 @@ spanless_eq_enum!(PatKind; Wild Ident(0 1 2) Struct(0 1 2) TupleStruct(0 1)
     Or(0) Path(0 1) Tuple(0) Box(0) Ref(0 1) Lit(0) Range(0 1 2) Slice(0) Rest
     Paren(0) MacCall(0));
 spanless_eq_enum!(TyKind; Slice(0) Array(0 1) Ptr(0) Rptr(0 1) BareFn(0) Never
-    Tup(0) Path(0 1) TraitObject(0 1) ImplTrait(0 1) Paren(0) Typeof(0) Infer
-    ImplicitSelf MacCall(0) Err CVarArgs);
+    Tup(0) AnonymousStruct(0 1) AnonymousUnion(0 1) Path(0 1) TraitObject(0 1)
+    ImplTrait(0 1) Paren(0) Typeof(0) Infer ImplicitSelf MacCall(0) Err
+    CVarArgs);
 
 impl SpanlessEq for Ident {
     fn eq(&self, other: &Self) -> bool {