diff --git a/third_party/rust/darling/.cargo-checksum.json b/third_party/rust/darling/.cargo-checksum.json
index 25b465bc5b82..8090e3fc3eb4 100644
--- a/third_party/rust/darling/.cargo-checksum.json
+++ b/third_party/rust/darling/.cargo-checksum.json
@@ -1 +1 @@
-{"files":{"CHANGELOG.md":"06091817afa317ff86efb9aee3fa8d165358150a92c6369e4ab2958765c14af8","Cargo.toml":"3ec79fcbc682939731504a261f9f7a10afecdbbf298af8a10a9748abcb79172a","LICENSE":"8ea93490d74a5a1b1af3ff71d786271b3f1e5f0bea79ac16e02ec533cef040d6","README.md":"f70d772dd28cd14fc817c71d343b07ec8bfbe02dfe8d3e999a0185c6ef8731ec","examples/automatic_bounds.rs":"2716da31a5beed954da77866779ef77600686688a8890fefa7e23db628358104","examples/consume_fields.rs":"abcdd6a919a95a5c295e8d362db0367ab171fe3c8a80b23d83701765cd902d2d","examples/fallible_read.rs":"e06d5c045d3a47c0e00d3c77ed3aa1a1d5173d2c3f462dc1967379db3094af4c","examples/supports_struct.rs":"f2d84a4377e555ed7535e563c9593bd6a398a63b42f7da72381eea2fccec229f","publish.sh":"42795a155247c69402f8c4c917c9874a06dfde5a7606c8b59fc4e9ccd34233dd","src/lib.rs":"07da20edb52c4aba30f2b680b28ca96cf995859566b0db3b1d2e0ee967249a18","src/macros_public.rs":"3ed7eb99f309d9cd600d3a09ff4dcf5cc5d787fb49e8e5ead6bb00e31e5e6793","tests/accrue_errors.rs":"f873acf2a13dba88f508c3eb118d14e36515bf94b7ee914ddec2ae1eb55e381f","tests/computed_bound.rs":"2313da96a250b5948ca06bf86cb7158b55a59eba75334aa8ba27a46b28ede6b5","tests/custom_bound.rs":"4dd3e8fd76734d8f262e857773f53a820229ad6e10fe6fbbbe1f636c7da9eab0","tests/defaults.rs":"b544be90d18be26305a757e8468bf8735356889b59c167294d118e32ee7f82ea","tests/enums_newtype.rs":"723c761eab356f577e804a5e07f5efa244f70fb7525d20fceb1bc3852c8d742e","tests/enums_struct.rs":"e0097d7f947cf9e4612c9450c55ea5075c7f6fcbbf8cac7176449d92eebc9343","tests/enums_unit.rs":"8c075d5897b60b58cb71d6306e7fdd80851f5a147ae3010ba70ea100007364a3","tests/error.rs":"f989a43fad47d61d75da2bc78af6c51bac549f39f14f87a804eea226308ece32","tests/from_generics.rs":"79230ad21e8482cf6e6ceb0c74303bc0cdf77fbb951f46a6ba1006ecf1248fd5","tests/from_type_param.rs":"4369737a9d4c21cfa8595a9159cd5d98d02af3445d8b4085654ad4ce8e8bba3f","tests/from_type_param_default.rs":"a5ee72f22540004e755445c37dd4c425ef12beef496896d608695bae964afe7f","tests/from_variant.rs":"2e804326302a62b979eae963e88f0a2cdb6a21ee9667407c361d178f8c0aadba","tests/generics.rs":"3c0f43b39a8f319b8318e409d3836c7235892ae4f50f5986ea80f69b80a4080b","tests/happy_path.rs":"13cf6cd5f87920d90762fd08e45d9f0bb378563e1c92cf5ffb3ba78decdc4969","tests/multiple.rs":"b76172c396a89414b1669eec2bf854c79a7215fd3b6977123b81591ac6761670","tests/newtype.rs":"c45842fd764174a6a8177851e15445d344ab93bf2124b5f77213780d1306adea","tests/skip.rs":"fd936a5eff92c0a49b0a900e6fcda6b7a10a83dd4096ae2000201ccb3f66a738","tests/split_declaration.rs":"b191ed446bf7b8fdf1d41059354adb4b155523507f37b0d36aed3347617a2492","tests/supports.rs":"acb53d4d810dcd3e46763db13234e4fb42e425cfde2516d9bf5d7b690be72dcc"},"package":"f593353cad5af2df6d54810de2b61aa8acba5b5fbc70b0d75e7cc5bdd80aca73"}
\ No newline at end of file
+{"files":{"CHANGELOG.md":"111bee96e6baf82f8898ada5f5395888253832ed641fc6013ad803ac6afaeaf0","Cargo.toml":"66f4111240094e9fed78c1989fc56b30fb94a58f2465eb0eacbaf050cc027b81","LICENSE":"8ea93490d74a5a1b1af3ff71d786271b3f1e5f0bea79ac16e02ec533cef040d6","README.md":"05357355cb87aea0b5bda29ce9f6ef03331717cf351c6cf7554855f5d825756e","examples/automatic_bounds.rs":"dcac3391ed568475cea17ec64c324283f9771dce61adb0a0dd7b8a9ee0bf954d","examples/consume_fields.rs":"ebf4bd8baf4e54ccaa926f910957183d6a5b1decaa87ab5ebcca6c8d38b6c6b3","examples/fallible_read.rs":"aa9d1e0aaba8f3eb4580e94e133839f7eb77fca61beed254f3d5e0f6d6981f00","examples/supports_struct.rs":"d69124e09d3d6b8e04a3af07a6af96c5df7cbd3d6953a51657b39088cc2c2de7","src/lib.rs":"07da20edb52c4aba30f2b680b28ca96cf995859566b0db3b1d2e0ee967249a18","src/macros_public.rs":"3ed7eb99f309d9cd600d3a09ff4dcf5cc5d787fb49e8e5ead6bb00e31e5e6793","tests/accrue_errors.rs":"f5ac2d8cb0a12284a845d25b9472c4605aa5e8c1cd66a6dd6ad64f1c749b2caf","tests/computed_bound.rs":"2313da96a250b5948ca06bf86cb7158b55a59eba75334aa8ba27a46b28ede6b5","tests/custom_bound.rs":"4dd3e8fd76734d8f262e857773f53a820229ad6e10fe6fbbbe1f636c7da9eab0","tests/defaults.rs":"b544be90d18be26305a757e8468bf8735356889b59c167294d118e32ee7f82ea","tests/enums_newtype.rs":"a09af70072e566bee1f6cad91675f3553c47333e51a0e389ebb47ae82de776a8","tests/enums_struct.rs":"e0097d7f947cf9e4612c9450c55ea5075c7f6fcbbf8cac7176449d92eebc9343","tests/enums_unit.rs":"8c075d5897b60b58cb71d6306e7fdd80851f5a147ae3010ba70ea100007364a3","tests/error.rs":"465f7634fa23f0076c93a9c5fc16ccde16119b874d64c8dabaf275b6b7ae61f2","tests/from_generics.rs":"79230ad21e8482cf6e6ceb0c74303bc0cdf77fbb951f46a6ba1006ecf1248fd5","tests/from_type_param.rs":"7c97745cdcea18a2d6f51e4da7426055a078287bf9f2c93d487057195efa2b30","tests/from_type_param_default.rs":"80787ef6527e7f76c2aac93b1f35a006a9c5e0df8deed61698eaac1127278021","tests/from_variant.rs":"2e804326302a62b979eae963e88f0a2cdb6a21ee9667407c361d178f8c0aadba","tests/generics.rs":"e08aea8a8de8f03e3c243bde650e250defbe340cef3e4c06935b2b3e46d2a376","tests/happy_path.rs":"c32daa68e2becdc2d6204985a19b437cfb49d7f1680e890578f0760dc9749b77","tests/multiple.rs":"0391be49bab07771d7e37d35fe17f6d9bf1aa6dc57e2c0e5c0912ab8e043128f","tests/newtype.rs":"3f029724467abc7a33aaf7b6a1feb7b6898eba578576afff338e73deb9fd2b3b","tests/skip.rs":"604861aa4d1dfdc4e5f38f8261be19b7240c650eb493b64ce0178f54c24a8d2d","tests/split_declaration.rs":"f509390f88549164af9218f1e5b07564b169a4481a20b738432ffb03c517b599","tests/suggestions.rs":"0afb756949be876aaae76974f119be811c783fb134a54978ff0453c537ff3174","tests/supports.rs":"3b096c3d893bf8e76f70219bc276cbfe04529091e9e8652af140f0f1b3a91270"},"package":"9158d690bc62a3a57c3e45b85e4d50de2008b39345592c64efd79345c7e24be0"}
\ No newline at end of file
diff --git a/third_party/rust/darling/CHANGELOG.md b/third_party/rust/darling/CHANGELOG.md
index 2ec5d8675b2b..7f91819becf9 100644
--- a/third_party/rust/darling/CHANGELOG.md
+++ b/third_party/rust/darling/CHANGELOG.md
@@ -1,5 +1,31 @@
 # Changelog
 
+## v0.8.6 (March 18, 2019)
+- Added "did you mean" suggestions for unknown fields behind the `suggestions` flag [#60](https://github.com/TedDriggs/issues/60)
+- Added `Error::unknown_field_with_alts` to support the suggestion use-case.
+- Added `ast::Fields::len` and `ast::Fields::is_empty` methods.
+
+## v0.8.5 (February 4, 2019)
+- Accept unquoted positive numeric literals [#52](https://github.com/TedDriggs/issues/52)
+- Add `FromMeta` to the `syn::Lit` enum and its variants
+- Improve error message for unexpected literal formats to not say "other"
+
+## v0.8.4 (February 4, 2019)
+- Use `syn::Error` to provide precise errors before `proc_macro::Diagnostic` is available
+- Add `diagnostics` feature flag to toggle between stable and unstable error backends
+- Attach error information in more contexts
+- Add `allow_unknown_fields` to support parsing the same attribute multiple times for different macros [#51](https://github.com/darling/issues/51)
+- Proc-macro authors will now see better errors in `darling` attributes
+
+## v0.8.3 (January 21, 2019)
+- Attach spans to errors in generated trait impls [#37](https://github.com/darling/issues/37)
+- Attach spans to errors for types with provided bespoke implementations
+- Deprecate `set_span` from 0.8.2, as spans should never be broadened after being initially set
+
+## v0.8.2 (January 17, 2019)
+- Add spans to errors to make quality warnings and errors easy in darling. This is blocked on diagnostics stabilizing.
+- Add `darling::util::SpannedValue` so proc-macro authors can remember position information alongside parsed values.
+
 ## v0.8.0
 - Update dependency on `syn` to 0.15 [#44](https://github.com/darling/pull/44). Thanks to @hcpl
 
diff --git a/third_party/rust/darling/Cargo.toml b/third_party/rust/darling/Cargo.toml
index 9a88e2393b49..0d9a0c2613ad 100644
--- a/third_party/rust/darling/Cargo.toml
+++ b/third_party/rust/darling/Cargo.toml
@@ -12,18 +12,19 @@
 
 [package]
 name = "darling"
-version = "0.8.1"
+version = "0.8.6"
 authors = ["Ted Driggs <ted.driggs@outlook.com>"]
+exclude = ["/.travis.yml", "/publish.sh"]
 description = "A proc-macro library for reading attributes into structs when\nimplementing custom derives.\n"
-documentation = "https://docs.rs/darling/0.8.1"
+documentation = "https://docs.rs/darling/0.8.6"
 readme = "README.md"
 license = "MIT"
 repository = "https://github.com/TedDriggs/darling"
 [dependencies.darling_core]
-version = "=0.8.1"
+version = "=0.8.6"
 
 [dependencies.darling_macro]
-version = "=0.8.1"
+version = "=0.8.6"
 [dev-dependencies.proc-macro2]
 version = "0.4"
 
@@ -31,6 +32,10 @@ version = "0.4"
 version = "0.6"
 
 [dev-dependencies.syn]
-version = "0.15"
+version = "0.15.26"
+
+[features]
+diagnostics = ["darling_core/diagnostics"]
+suggestions = ["darling_core/suggestions"]
 [badges.travis-ci]
 repository = "TedDriggs/darling"
diff --git a/third_party/rust/darling/README.md b/third_party/rust/darling/README.md
index 9919e722236b..28d07cf43914 100644
--- a/third_party/rust/darling/README.md
+++ b/third_party/rust/darling/README.md
@@ -10,8 +10,9 @@ Darling
 `darling` provides a set of traits which can be derived or manually implemented.
 
 1. `FromMeta` is used to extract values from a meta-item in an attribute. Implementations are likely reusable for many libraries, much like `FromStr` or `serde::Deserialize`. Trait implementations are provided for primitives, some std types, and some `syn` types.
-1. `FromDeriveInput` is implemented or derived by each proc-macro crate which depends on `darling`. This is the root for input parsing; it gets access to the identity, generics, and visibility of the target type, and can specify which attribute names should be parsed or forwarded from the input AST.
-1. `FromField` is implemented or derived by each proc-macro crate which depends on `darling`. Structs deriving this trait will get access to the identity (if it exists), type, and visibility of the field.
+2. `FromDeriveInput` is implemented or derived by each proc-macro crate which depends on `darling`. This is the root for input parsing; it gets access to the identity, generics, and visibility of the target type, and can specify which attribute names should be parsed or forwarded from the input AST.
+3. `FromField` is implemented or derived by each proc-macro crate which depends on `darling`. Structs deriving this trait will get access to the identity (if it exists), type, and visibility of the field.
+4. `FromVariant` is implemented or derived by each proc-macro crate which depends on `darling`. Structs deriving this trait will get access to the identity and contents of the variant, which can be transformed the same as any other `darling` input.
 
 # Example
 
@@ -46,6 +47,49 @@ The above code will then be able to parse this input:
 pub struct ConsumingType;
 ```
 
+# Attribute Macros
+Non-derive attribute macros are supported.
+To parse arguments for attribute macros, derive `FromMeta` on the argument receiver type, then pass `&syn::AttributeArgs` to the `from_list` method.
+This will produce a normal `darling::Result<T>` that can be used the same as a result from parsing a `DeriveInput`.
+
+## Macro Code
+```rust,ignore
+use darling::FromMeta;
+use syn::{AttributeArgs, ItemFn};
+use proc_macro::TokenStream;
+
+#[derive(Debug, FromMeta)]
+pub struct MacroArgs {
+    #[darling(default)]
+    timeout_ms: Option<u16>,
+    path: String,
+}
+
+#[proc_macro_attribute]
+fn your_attr(args: TokenStream, input: TokenStream) -> TokenStream {
+    let attr_args = parse_macro_input!(args as AttributeArgs);
+    let _input = parse_macro_input!(input as ItemFn);
+
+    let _args = match MacroArgs::from_list(&attr_args) {
+        Ok(v) => v,
+        Err(e) => { return e.write_errors(); }
+    };
+
+    // do things with `args`
+    unimplemented!()
+}
+```
+
+## Consuming Code
+```rust,ignore
+use your_crate::your_attr;
+
+#[your_attr(path = "hello", timeout_ms = 15)]
+fn do_stuff() {
+    println!("Hello");
+}
+```
+
 # Features
 Darling's features are built to work well for real-world projects.
 
@@ -55,3 +99,4 @@ Darling's features are built to work well for real-world projects.
 * **Mapping function**: Use `#[darling(map="path")]` to specify a function that runs on the result of parsing a meta-item field. This can change the return type, which enables you to parse to an intermediate form and convert that to the type you need in your struct.
 * **Skip fields**: Use `#[darling(skip)]` to mark a field that shouldn't be read from attribute meta-items.
 * **Multiple-occurrence fields**: Use `#[darling(multiple)]` on a `Vec` field to allow that field to appear multiple times in the meta-item. Each occurrence will be pushed into the `Vec`.
+* **Span access**: Use `darling::util::SpannedValue` in a struct to get access to that meta item's source code span. This can be used to emit warnings that point at a specific field from your proc macro. In addition, you can use `darling::Error::write_errors` to automatically get precise error location details in most cases.
diff --git a/third_party/rust/darling/examples/automatic_bounds.rs b/third_party/rust/darling/examples/automatic_bounds.rs
index 06263f147f71..0b9aec484f46 100644
--- a/third_party/rust/darling/examples/automatic_bounds.rs
+++ b/third_party/rust/darling/examples/automatic_bounds.rs
@@ -68,7 +68,8 @@ fn main() {
             Div(String)
         }
     "#,
-    ).unwrap();
+    )
+    .unwrap();
 
     let parsed: SpeakingOptions<Phoneme, Volume> =
         FromDeriveInput::from_derive_input(&derive_input).unwrap();
diff --git a/third_party/rust/darling/examples/consume_fields.rs b/third_party/rust/darling/examples/consume_fields.rs
index d5602f303fec..4b0703f50764 100644
--- a/third_party/rust/darling/examples/consume_fields.rs
+++ b/third_party/rust/darling/examples/consume_fields.rs
@@ -64,7 +64,8 @@ impl ToTokens for MyInputReceiver {
         } = *self;
 
         let (imp, ty, wher) = generics.split_for_impl();
-        let fields = data.as_ref()
+        let fields = data
+            .as_ref()
             .take_struct()
             .expect("Should never be enum")
             .fields;
diff --git a/third_party/rust/darling/examples/fallible_read.rs b/third_party/rust/darling/examples/fallible_read.rs
index 04d573cefa2f..c487854336ed 100644
--- a/third_party/rust/darling/examples/fallible_read.rs
+++ b/third_party/rust/darling/examples/fallible_read.rs
@@ -4,7 +4,6 @@
 //! 1. Using `darling::Result` as a carrier to preserve the error for later display
 //! 1. Using `Result<T, syn::Meta>` to attempt a recovery in imperative code
 //! 1. Using the `map` darling meta-item to post-process the receiver before returning.
-
 #[macro_use]
 extern crate darling;
 
@@ -58,8 +57,8 @@ impl MyInputReceiver {
         };
 
         Self {
-            name: name,
-            frequency: frequency,
+            name,
+            frequency,
             amplitude: Ok(amplitude),
         }
     }
diff --git a/third_party/rust/darling/examples/supports_struct.rs b/third_party/rust/darling/examples/supports_struct.rs
index b76b4b707dab..dbf8238a9db9 100644
--- a/third_party/rust/darling/examples/supports_struct.rs
+++ b/third_party/rust/darling/examples/supports_struct.rs
@@ -37,8 +37,7 @@ pub struct Foo {
     let parsed = syn::parse_str(good_input).unwrap();
     let receiver = Lorem::from_derive_input(&parsed).unwrap();
     let wrong_shape_parsed = syn::parse_str(bad_input).unwrap();
-    let wrong_shape = Lorem::from_derive_input(&wrong_shape_parsed)
-        .expect_err("Shape was wrong");
+    let wrong_shape = Lorem::from_derive_input(&wrong_shape_parsed).expect_err("Shape was wrong");
 
     println!(
         r#"
diff --git a/third_party/rust/darling/publish.sh b/third_party/rust/darling/publish.sh
deleted file mode 100755
index 6531b7039287..000000000000
--- a/third_party/rust/darling/publish.sh
+++ /dev/null
@@ -1,3 +0,0 @@
-cargo publish --manifest-path core/Cargo.toml; 
-cargo publish --manifest-path macro/Cargo.toml;
-cargo publish;
\ No newline at end of file
diff --git a/third_party/rust/darling/tests/accrue_errors.rs b/third_party/rust/darling/tests/accrue_errors.rs
index 44ba7d908ddb..9ae8212765b8 100644
--- a/third_party/rust/darling/tests/accrue_errors.rs
+++ b/third_party/rust/darling/tests/accrue_errors.rs
@@ -3,7 +3,10 @@
 
 #[macro_use]
 extern crate darling;
+#[macro_use]
 extern crate syn;
+#[macro_use]
+extern crate quote;
 
 use darling::ast;
 use darling::FromDeriveInput;
@@ -30,17 +33,14 @@ struct LoremField {
 
 #[test]
 fn bad_type_and_missing_fields() {
-    let input = syn::parse_str(
-        r#"
-    #[accrue(ipsum = true, dolor(amet = "Hi"))]
-    pub struct NonConforming {
-        foo: ()
-    }
-    "#,
-    ).unwrap();
+    let input = parse_quote! {
+        #[accrue(ipsum = true, dolor(amet = "Hi"))]
+        pub struct NonConforming {
+            foo: ()
+        }
+    };
 
     let s_result: ::darling::Error = Lorem::from_derive_input(&input).unwrap_err();
-    //assert_eq!(3, s_result.len());
     let err = s_result.flatten();
     println!("{}", err);
     assert_eq!(3, err.len());
@@ -48,17 +48,15 @@ fn bad_type_and_missing_fields() {
 
 #[test]
 fn body_only_issues() {
-    let input = syn::parse_str(
-        r#"
-    #[accrue(ipsum = "Hello", dolor(sit))]
-    pub struct NonConforming {
-        foo: (),
-        bar: bool,
-    }
-    "#,
-    ).unwrap();
+    let input = parse_quote! {
+        #[accrue(ipsum = "Hello", dolor(sit))]
+        pub struct NonConforming {
+            foo: (),
+            bar: bool,
+        }
+    };
 
-    let s_err: ::darling::Error = Lorem::from_derive_input(&input).unwrap_err();
+    let s_err = Lorem::from_derive_input(&input).unwrap_err();
     println!("{:?}", s_err);
     assert_eq!(2, s_err.len());
 }
@@ -78,17 +76,15 @@ struct Month {
 
 #[test]
 fn error_in_enum_fields() {
-    let input = syn::parse_str(
-        r#"
-    #[accrue(schedule(tuesday(morning = "yes")))]
-    pub struct NonConforming {
-        foo: (),
-        bar: bool,
-    }
-    "#,
-    ).unwrap();
+    let input = parse_quote! {
+        #[accrue(schedule(tuesday(morning = "yes")))]
+        pub struct NonConforming {
+            foo: (),
+            bar: bool,
+        }
+    };
 
-    let s_err: ::darling::Error = Month::from_derive_input(&input).unwrap_err();
+    let s_err = Month::from_derive_input(&input).unwrap_err();
     assert_eq!(2, s_err.len());
     let err = s_err.flatten();
     // TODO add tests to check location path is correct
@@ -97,17 +93,15 @@ fn error_in_enum_fields() {
 
 #[test]
 fn error_in_newtype_variant() {
-    let input = syn::parse_str(
-        r#"
-    #[accrue(schedule(wednesday(sit = "yes")))]
-    pub struct NonConforming {
-        foo: (),
-        bar: bool,
-    }
-    "#,
-    ).unwrap();
+    let input = parse_quote! {
+        #[accrue(schedule(wednesday(sit = "yes")))]
+        pub struct NonConforming {
+            foo: (),
+            bar: bool,
+        }
+    };
 
-    let s_err: ::darling::Error = Month::from_derive_input(&input).unwrap_err();
+    let s_err = Month::from_derive_input(&input).unwrap_err();
     assert_eq!(1, s_err.len());
     println!("{}", s_err);
     println!("{}", s_err.flatten());
diff --git a/third_party/rust/darling/tests/enums_newtype.rs b/third_party/rust/darling/tests/enums_newtype.rs
index f17d33e5654b..0fd12f03fc77 100644
--- a/third_party/rust/darling/tests/enums_newtype.rs
+++ b/third_party/rust/darling/tests/enums_newtype.rs
@@ -1,10 +1,12 @@
 #[macro_use]
 extern crate darling;
+#[macro_use]
+extern crate syn;
+#[macro_use]
+extern crate quote;
 
 use darling::FromDeriveInput;
 
-extern crate syn;
-
 #[derive(Debug, Default, PartialEq, Eq, FromMeta)]
 #[darling(default)]
 pub struct Amet {
@@ -34,12 +36,10 @@ impl PartialEq<Lorem> for Holder {
 
 #[test]
 fn bool_word() {
-    let di = syn::parse_str(
-        r#"
+    let di = parse_quote! {
         #[hello(lorem(ipsum))]
         pub struct Bar;
-    "#,
-    ).unwrap();
+    };
 
     let pr = Holder::from_derive_input(&di).unwrap();
     assert_eq!(pr, Lorem::Ipsum(true));
@@ -47,12 +47,10 @@ fn bool_word() {
 
 #[test]
 fn bool_literal() {
-    let di = syn::parse_str(
-        r#"
+    let di = parse_quote! {
         #[hello(lorem(ipsum = false))]
         pub struct Bar;
-    "#,
-    ).unwrap();
+    };
 
     let pr = Holder::from_derive_input(&di).unwrap();
     assert_eq!(pr, Lorem::Ipsum(false));
@@ -60,12 +58,10 @@ fn bool_literal() {
 
 #[test]
 fn string_literal() {
-    let di = syn::parse_str(
-        r#"
+    let di = parse_quote! {
         #[hello(lorem(dolor = "Hello"))]
         pub struct Bar;
-    "#,
-    ).unwrap();
+    };
 
     let pr = Holder::from_derive_input(&di).unwrap();
     assert_eq!(pr, Lorem::Dolor("Hello".to_string()));
@@ -73,12 +69,10 @@ fn string_literal() {
 
 #[test]
 fn struct_nested() {
-    let di = syn::parse_str(
-        r#"
+    let di = parse_quote! {
         #[hello(lorem(sit(world = "Hello", hello = false)))]
         pub struct Bar;
-    "#,
-    ).unwrap();
+    };
 
     let pr = Holder::from_derive_input(&di).unwrap();
     assert_eq!(
@@ -93,12 +87,10 @@ fn struct_nested() {
 #[test]
 #[should_panic]
 fn format_mismatch() {
-    let di = syn::parse_str(
-        r#"
+    let di = parse_quote! {
         #[hello(lorem(dolor(world = "Hello", hello = false)))]
         pub struct Bar;
-    "#,
-    ).unwrap();
+    };
 
     Holder::from_derive_input(&di).unwrap();
 }
diff --git a/third_party/rust/darling/tests/error.rs b/third_party/rust/darling/tests/error.rs
index 6da666951fb7..edd72eb1dd97 100644
--- a/third_party/rust/darling/tests/error.rs
+++ b/third_party/rust/darling/tests/error.rs
@@ -1,7 +1,10 @@
 //! In case of bad input, parsing should fail. The error should have locations set in derived implementations.
 #[macro_use]
 extern crate darling;
+#[macro_use]
 extern crate syn;
+#[macro_use]
+extern crate quote;
 
 use darling::FromDeriveInput;
 
@@ -33,24 +36,20 @@ impl From<syn::Ident> for Lorem {
 
 #[test]
 fn parsing_fail() {
-    let di = syn::parse_str(
-        r#"
+    let di = parse_quote! {
         #[hello(ipsum(amet = "yes", world = false))]
         pub struct Foo;
-    "#,
-    ).unwrap();
+    };
 
     println!("{}", Lorem::from_derive_input(&di).unwrap_err());
 }
 
 #[test]
 fn missing_field() {
-    let di = syn::parse_str(
-        r#"
+    let di = parse_quote! {
         #[hello(ipsum(amet = true))]
         pub struct Foo;
-    "#,
-    ).unwrap();
+    };
 
     println!("{}", Lorem::from_derive_input(&di).unwrap_err());
 }
diff --git a/third_party/rust/darling/tests/from_type_param.rs b/third_party/rust/darling/tests/from_type_param.rs
index ebd7e3e269ba..adaf34dd3868 100644
--- a/third_party/rust/darling/tests/from_type_param.rs
+++ b/third_party/rust/darling/tests/from_type_param.rs
@@ -1,6 +1,9 @@
 #[macro_use]
 extern crate darling;
+#[macro_use]
 extern crate syn;
+#[macro_use]
+extern crate quote;
 
 use darling::FromTypeParam;
 use syn::{DeriveInput, GenericParam, Ident, TypeParam};
@@ -34,14 +37,13 @@ fn extract_type(param: &GenericParam) -> &TypeParam {
 
 #[test]
 fn expand_many() {
-    let di: DeriveInput = syn::parse_str(
-        r#"
+    let di: DeriveInput = parse_quote! {
         struct Baz<
             #[lorem(foo)] T,
             #[lorem(bar = "x")] U: Eq + ?Sized
         >(T, U);
-    "#,
-    ).unwrap();
+    };
+
     let params = di.generics.params;
 
     {
diff --git a/third_party/rust/darling/tests/from_type_param_default.rs b/third_party/rust/darling/tests/from_type_param_default.rs
index df24de08892a..eb0ecc766cca 100644
--- a/third_party/rust/darling/tests/from_type_param_default.rs
+++ b/third_party/rust/darling/tests/from_type_param_default.rs
@@ -1,6 +1,9 @@
 #[macro_use]
 extern crate darling;
+#[macro_use]
 extern crate syn;
+#[macro_use]
+extern crate quote;
 
 use darling::FromTypeParam;
 use syn::{DeriveInput, GenericParam, TypeParam};
@@ -22,15 +25,13 @@ fn extract_type(param: &GenericParam) -> &TypeParam {
 
 #[test]
 fn expand_many() {
-    let di: DeriveInput = syn::parse_str(
-        r#"
+    let di: DeriveInput = parse_quote! {
         struct Baz<
             #[lorem(foo)] T,
             #[lorem(bar = "x")] U: Eq + ?Sized,
             #[lorem(foo = false)] V = (),
         >(T, U, V);
-    "#,
-    ).unwrap();
+    };
     let params = di.generics.params;
 
     {
diff --git a/third_party/rust/darling/tests/generics.rs b/third_party/rust/darling/tests/generics.rs
index c268f56c0f6b..a83d03e284b7 100644
--- a/third_party/rust/darling/tests/generics.rs
+++ b/third_party/rust/darling/tests/generics.rs
@@ -1,6 +1,9 @@
 #[macro_use]
 extern crate darling;
+#[macro_use]
 extern crate syn;
+#[macro_use]
+extern crate quote;
 
 use darling::FromDeriveInput;
 
@@ -15,12 +18,10 @@ struct Foo<T> {
 
 #[test]
 fn expansion() {
-    let di = syn::parse_str(
-        r#"
+    let di = parse_quote! {
         #[hello(lorem = "Hello")]
         pub struct Foo;
-    "#,
-    ).unwrap();
+    };
 
-    let _parsed = Foo::<String>::from_derive_input(&di).unwrap();
+    Foo::<String>::from_derive_input(&di).unwrap();
 }
diff --git a/third_party/rust/darling/tests/happy_path.rs b/third_party/rust/darling/tests/happy_path.rs
index d5d7b54fb9fa..df1bfadd754f 100644
--- a/third_party/rust/darling/tests/happy_path.rs
+++ b/third_party/rust/darling/tests/happy_path.rs
@@ -1,6 +1,5 @@
 #[macro_use]
 extern crate darling;
-
 #[macro_use]
 extern crate syn;
 #[macro_use]
@@ -34,13 +33,11 @@ struct TraitCore {
 
 #[test]
 fn simple() {
-    let di = syn::parse_str(
-        r#"
+    let di = parse_quote! {
         #[derive(Foo)]
         #[darling_demo(lorem(ipsum))]
         pub struct Bar;
-    "#,
-    ).unwrap();
+    };
 
     assert_eq!(
         Core::from_derive_input(&di).unwrap(),
@@ -58,13 +55,11 @@ fn simple() {
 
 #[test]
 fn trait_type() {
-    let di = syn::parse_str(
-        r#"
+    let di = parse_quote! {
         #[derive(Foo)]
         #[darling_demo(lorem(dolor = "hello"))]
         pub struct Bar;
-    "#,
-    ).unwrap();
+    };
 
     assert_eq!(
         TraitCore::from_derive_input(&di).unwrap(),
diff --git a/third_party/rust/darling/tests/multiple.rs b/third_party/rust/darling/tests/multiple.rs
index 111c1f402a6b..e70528063352 100644
--- a/third_party/rust/darling/tests/multiple.rs
+++ b/third_party/rust/darling/tests/multiple.rs
@@ -1,6 +1,9 @@
 #[macro_use]
 extern crate darling;
+#[macro_use]
 extern crate syn;
+#[macro_use]
+extern crate quote;
 
 use darling::FromDeriveInput;
 
@@ -20,12 +23,10 @@ struct Ipsum {
 
 #[test]
 fn expand_many() {
-    let di = syn::parse_str(
-        r#"
+    let di = parse_quote! {
         #[hello(ipsum(dolor = "Hello", dolor = "World"))]
         pub struct Baz;
-    "#,
-    ).unwrap();
+    };
 
     let lorem: Lorem = Lorem::from_derive_input(&di).unwrap();
     assert_eq!(
diff --git a/third_party/rust/darling/tests/newtype.rs b/third_party/rust/darling/tests/newtype.rs
index 16cb95994b0f..5219d9ad93e0 100644
--- a/third_party/rust/darling/tests/newtype.rs
+++ b/third_party/rust/darling/tests/newtype.rs
@@ -2,8 +2,10 @@
 
 #[macro_use]
 extern crate darling;
-
+#[macro_use]
 extern crate syn;
+#[macro_use]
+extern crate quote;
 
 use darling::FromDeriveInput;
 
@@ -18,13 +20,11 @@ struct DemoContainer {
 
 #[test]
 fn generated() {
-    let di = syn::parse_str(
-        r#"
+    let di = parse_quote! {
         #[derive(Baz)]
         #[newtype(lorem = false)]
         pub struct Foo;
-    "#,
-    ).unwrap();
+    };
 
     let c = DemoContainer::from_derive_input(&di).unwrap();
 
diff --git a/third_party/rust/darling/tests/skip.rs b/third_party/rust/darling/tests/skip.rs
index a46dbfdda21b..b4e0f64dc13a 100644
--- a/third_party/rust/darling/tests/skip.rs
+++ b/third_party/rust/darling/tests/skip.rs
@@ -2,7 +2,10 @@
 
 #[macro_use]
 extern crate darling;
+#[macro_use]
 extern crate syn;
+#[macro_use]
+extern crate quote;
 
 use darling::FromDeriveInput;
 
@@ -34,12 +37,10 @@ pub enum Sit {
 
 #[test]
 fn verify_skipped_field_not_required() {
-    let di = syn::parse_str(
-        r#"
+    let di = parse_quote! {
         #[skip_test(ipsum = "Hello")]
         struct Baz;
-    "#,
-    ).unwrap();
+    };
 
     assert_eq!(
         Lorem::from_derive_input(&di).unwrap(),
diff --git a/third_party/rust/darling/tests/split_declaration.rs b/third_party/rust/darling/tests/split_declaration.rs
index 5eb492a34aae..23d458d17371 100644
--- a/third_party/rust/darling/tests/split_declaration.rs
+++ b/third_party/rust/darling/tests/split_declaration.rs
@@ -3,7 +3,10 @@
 
 #[macro_use]
 extern crate darling;
+#[macro_use]
 extern crate syn;
+#[macro_use]
+extern crate quote;
 
 use std::string::ToString;
 
@@ -18,13 +21,11 @@ struct Lorem {
 
 #[test]
 fn split_attributes_accrue_to_instance() {
-    let di = syn::parse_str(
-        r#"
+    let di = parse_quote! {
         #[split(foo = "Hello")]
         #[split(bar)]
         pub struct Foo;
-    "#,
-    ).unwrap();
+    };
 
     let parsed = Lorem::from_derive_input(&di).unwrap();
     assert_eq!(
@@ -38,39 +39,37 @@ fn split_attributes_accrue_to_instance() {
 
 #[test]
 fn duplicates_across_split_attrs_error() {
-    let di = syn::parse_str(
-        r#"
+    let di = parse_quote! {
         #[split(foo = "Hello")]
         #[split(foo = "World", bar)]
         pub struct Foo;
-    "#,
-    ).unwrap();
+    };
 
-    let pr = Lorem::from_derive_input(&di);
+    let pr = Lorem::from_derive_input(&di).unwrap_err();
+    assert!(pr.has_span());
     assert_eq!(
-        pr.unwrap_err().to_string(),
+        pr.to_string(),
         Error::duplicate_field("foo").to_string()
     );
 }
 
 #[test]
 fn multiple_errors_accrue_to_instance() {
-    let di = syn::parse_str(
-        r#"
+    let di = parse_quote! {
         #[split(foo = "Hello")]
         #[split(foo = "World")]
         pub struct Foo;
-    "#,
-    ).unwrap();
+    };
 
     let pr = Lorem::from_derive_input(&di);
     let err: Error = pr.unwrap_err();
     assert_eq!(2, err.len());
-    let mut errs = err.into_iter();
+    let mut errs = err.into_iter().peekable();
     assert_eq!(
-        errs.next().unwrap().to_string(),
+        errs.peek().unwrap().to_string(),
         Error::duplicate_field("foo").to_string()
     );
+    assert!(errs.next().unwrap().has_span());
     assert_eq!(
         errs.next().unwrap().to_string(),
         Error::missing_field("bar").to_string()
diff --git a/third_party/rust/darling/tests/suggestions.rs b/third_party/rust/darling/tests/suggestions.rs
new file mode 100644
index 000000000000..3499e9ed9ad6
--- /dev/null
+++ b/third_party/rust/darling/tests/suggestions.rs
@@ -0,0 +1,34 @@
+#![cfg(feature = "suggestions")]
+
+#[macro_use]
+extern crate darling;
+#[macro_use]
+extern crate syn;
+#[macro_use]
+extern crate quote;
+
+use darling::FromDeriveInput;
+
+#[derive(Debug, FromDeriveInput)]
+#[darling(attributes(suggest))]
+struct Lorem {
+    ipsum: String,
+    dolor: Dolor,
+}
+
+#[derive(Debug, FromMeta)]
+struct Dolor {
+    sit: bool,
+}
+
+#[test]
+fn suggest_dolor() {
+    let input: syn::DeriveInput = parse_quote! {
+        #[suggest(ipsum = "Hello", dolorr(sit))]
+        pub struct Foo;
+    };
+
+    let result = Lorem::from_derive_input(&input).unwrap_err();
+    assert_eq!(2, result.len());
+    assert!(format!("{}", result).contains("Did you mean"));
+}
diff --git a/third_party/rust/darling/tests/supports.rs b/third_party/rust/darling/tests/supports.rs
index 0681a5f7b42a..9408a49da8dc 100644
--- a/third_party/rust/darling/tests/supports.rs
+++ b/third_party/rust/darling/tests/supports.rs
@@ -1,6 +1,9 @@
 #[macro_use]
 extern crate darling;
+#[macro_use]
 extern crate syn;
+#[macro_use]
+extern crate quote;
 
 use darling::ast;
 use darling::FromDeriveInput;
@@ -28,41 +31,35 @@ mod source {
     use syn::{self, DeriveInput};
 
     pub fn newtype_enum() -> DeriveInput {
-        syn::parse_str(
-            r#"
-        enum Hello {
-            World(bool),
-            String(String),
+        parse_quote!{
+            enum Hello {
+                World(bool),
+                String(String),
+            }
         }
-    "#,
-        ).unwrap()
     }
 
     pub fn named_field_enum() -> DeriveInput {
-        syn::parse_str(
-            r#"
-        enum Hello {
-            Foo(u16),
-            World {
-                name: String
-            },
+        parse_quote! {
+            enum Hello {
+                Foo(u16),
+                World {
+                    name: String
+                },
+            }
         }
-    "#,
-        ).unwrap()
     }
 
     pub fn named_struct() -> DeriveInput {
-        syn::parse_str(
-            r#"
-        struct Hello {
-            world: bool,
+        parse_quote! {
+            struct Hello {
+                world: bool,
+            }
         }
-    "#,
-        ).unwrap()
     }
 
     pub fn tuple_struct() -> DeriveInput {
-        syn::parse_str("struct Hello(String, bool);").unwrap()
+        parse_quote! { struct Hello(String, bool); }
     }
 }
 
diff --git a/third_party/rust/darling_core/.cargo-checksum.json b/third_party/rust/darling_core/.cargo-checksum.json
index bb0f5aa9cd8c..dd18c0525ced 100644
--- a/third_party/rust/darling_core/.cargo-checksum.json
+++ b/third_party/rust/darling_core/.cargo-checksum.json
@@ -1 +1 @@
-{"files":{"Cargo.toml":"b24c1abec4095a1afce8e302bc39f9de6027b55b0c308fb6b8bc4d684f6c2577","src/ast/data.rs":"c95e469d870f7918e77707da0e9e5e945e205e640bf34637355ef863b6efb28f","src/ast/generics.rs":"3bdfe1abdbee64f5aaa9b189dc5c58e222568f196ed206e9d6d91ea5f29673e7","src/ast/mod.rs":"58a58eeb1db7682e5994732cc8eb04088f6ca662805460ef443cf089e5c24e2c","src/codegen/attr_extractor.rs":"d13a3ba16f3a93f4a540421bb9df54a8f74cc6ee0e9e769b78b6c8045f285408","src/codegen/default_expr.rs":"60f23b77ddf80da70ec92fd0d8cb5a97143535df85eafa0e47943ac797ec46d2","src/codegen/error.rs":"50d0a1a2a392560ca10d3eb622ba745612761bf18846404742bd30caf2436228","src/codegen/field.rs":"d8b20dd1dda2c5591f5dcd4a2e5b8442ffae3daa23378323a81a682637080ea1","src/codegen/from_derive_impl.rs":"2a1e331d205db9334218b800760afcb64539fa2b25b0b2b014586b49b5b25882","src/codegen/from_field.rs":"af6f848ed7c6d2274e15d6307b011a1b8bcba66172ef68b0e665c9b4ae85157d","src/codegen/from_meta_impl.rs":"a937808b081e5d8bd16020fea8da0461e7e45872516cc0ee9e8a8cc957858a76","src/codegen/from_type_param.rs":"48493227f4a81fe1a533bd958b89207d56b1c70f754a2a28fb0e9eb9114a9aeb","src/codegen/from_variant_impl.rs":"3d9b10d60e3eb969946bbd210ce93a43375b9c8d3ffa827c7e87ab9235e2c3f3","src/codegen/mod.rs":"2dc3ee7f18177b2ef9c27c4f0cabc5bbd49f970abdba28a0539d81c70d81b6e2","src/codegen/outer_from_impl.rs":"059c3c05e4d6c7ba3876d23855ccbffa9e6158e7af7f6dc619b4d9770587f161","src/codegen/trait_impl.rs":"0e479f9e5b7253a3da2f77fd0bd63ea44a08a27dba2bd7dd992f05dc40b1d2a2","src/codegen/variant.rs":"3bc37ceb0e3dbf7eb02d7b66178adb3b165a24e92afa3295c012cf2f091d7328","src/codegen/variant_data.rs":"2467651663bfbb0ab35370b421d456948b053c26d0a23581a6c91ae7789b2db3","src/error.rs":"77436dc9a30172e94c434bdb61e3620ce37b2d64848a4fa19daba6e9c9329c95","src/from_derive_input.rs":"b2a04fefa4e14684061c819387ea0384297c67c7f50d5d0959aa69ab19075e76","src/from_field.rs":"f667924422ab4ab8d8b16ebfd42f61e74864cfaa80e96b49de5d1e1287e3d1d3","src/from_generic_param.rs":"49c5a8335eb0a9010998c5600c95c89440f7febe03265afb625d818dbc883d92","src/from_generics.rs":"7285b0fd213507e87c1da413cd1bc9eeada485d4a8f9d19630848d02a4d41c4a","src/from_meta.rs":"daa3d9a82b2f659147572f7d0e7fdef38139583e61e8319986098a4a73106453","src/from_type_param.rs":"9b611f276871002ade78146266fde3b6f9101b360082681a2fa2dafc16431f84","src/from_variant.rs":"70a23b5b4cb93c7e5a498fe9d16420b9b93bd69c1376d7703bc7cefd9417d159","src/lib.rs":"ea8f2d28793e4c0e367c4905e55e405417fbee9eb7ef0577f883b91aee1b5a57","src/macros_private.rs":"ef249cd9ca593aac423b4242df1c39c31610438da094c21562d74a7e5823c700","src/macros_public.rs":"3ed7eb99f309d9cd600d3a09ff4dcf5cc5d787fb49e8e5ead6bb00e31e5e6793","src/options/core.rs":"2dfb29a85a68d5ed6dccc46fe521c46ea8483bcd5d73cf21dbf21a7163ec318a","src/options/forward_attrs.rs":"89d8294a2204d6c32e5f58b797c23f4b035a8ff424bcf1b1c7db973ada89a4bc","src/options/from_derive.rs":"c8e41d2779e570dadd76c28b9cc9dd9cee57d8ef027766b4b5f39460a29df5d1","src/options/from_field.rs":"0b06590092a5c13d5c8eedf4e2d0518d869206813f828a06c65605d6cb8decc4","src/options/from_meta.rs":"ef268f78480f1d3df4e56cbc630aa4013ab5128cbb4471c4e85e9ff5a3980e7b","src/options/from_type_param.rs":"80d1fa60bac5bb31d0895e321faf1b8af99e407d9594028a01704b424be1dd4c","src/options/from_variant.rs":"99d4b60e48f8feef9c1fc2414ac0a420e66551c14e40c4a718668cca8e1f8cb5","src/options/input_field.rs":"f5e2529cfef4255710b9596c10422d7e7161978de93693cd25966eaebd7b5aee","src/options/input_variant.rs":"e0878260b04260a982f1de2de25159a38a338e67285f47da5e3eb8de2f60b68e","src/options/mod.rs":"30aefb531716954bad2b484c321baa333ef1d7d07ca55a0430df26bf4c1afb15","src/options/outer_from.rs":"e60196f2b9ea3ae014eaf3444607c6cf2a227c8d8aa4a5d64f59454602a0a5e6","src/options/shape.rs":"841e5cacfc40df74cd34c1dfc6895a99a21df79f48375de539d06bc15aec2248","src/usage/generics_ext.rs":"340774fe43033680e6b494c76dd4f558ada7ca4f09e91f9e4d076f125a729fc2","src/usage/ident_set.rs":"30edb2f0a599284967e3c6b579da31e5f9b15f3dd67bc9a82d6335eb44133df0","src/usage/lifetimes.rs":"19a63490660eb416bbccd4be9c060079a630dd15d5fd23c39e3c6c8c5498e369","src/usage/mod.rs":"bcf0ffb2257aed3b7b2cdad91c0136743384f39ff8f61f25c195c73b8fcdf144","src/usage/options.rs":"0491c995aad0d55783b24cce8a4e40f0f4435988c54ce2ded34763ac9b199fcf","src/usage/type_params.rs":"5aecf7f89c4b0623010e4717f5b32388b06d15e8511fde7b72f1d72e88fd3cb0","src/util/ident_list.rs":"fb6314436435547c111539213b209abd8d2593c28331560b84468a03b52d7c44","src/util/ident_string.rs":"06441e502d3bad342e292e42d083aff9070735a93d45f204aee5ef5f0144fdd0","src/util/ignored.rs":"7c979fbef880498ff64efda7396e759d80bf77fb1c7df0313bed8e533a16c0e0","src/util/mod.rs":"027793775e7079ea425f45b9bdad8b8fa309defcee02bf8ee6b6c556ec016342","src/util/over_ride.rs":"e90b3aeb41dd3364753f3ee6f8c6bbd85bf51d51569bf048396ec6e7735c569f","src/util/with_original.rs":"a545b38ba9d624fdc939eb844f001b7fc4102717b1d3683b4cbd0aae00fa7ef2"},"package":"168c246e87e727d58575d9b4595491010627f0cdc910e3e6ea3b36db2b9a9d9a"}
\ No newline at end of file
+{"files":{"Cargo.toml":"1b000960f407d3a318f55d3dd742f2ca5ddb7f7b3b1cb370023970bdc3072e64","LICENSE":"8ea93490d74a5a1b1af3ff71d786271b3f1e5f0bea79ac16e02ec533cef040d6","src/ast/data.rs":"560a0b89a93b7839317abb2e7e3bc0af93f40ce476c4a8a706ae0ad0fd240bb8","src/ast/generics.rs":"3bdfe1abdbee64f5aaa9b189dc5c58e222568f196ed206e9d6d91ea5f29673e7","src/ast/mod.rs":"58a58eeb1db7682e5994732cc8eb04088f6ca662805460ef443cf089e5c24e2c","src/codegen/attr_extractor.rs":"439950febbf04b139b578eb75ad70e1529a2bd6e5480f936e08770e9e354d9ac","src/codegen/default_expr.rs":"60f23b77ddf80da70ec92fd0d8cb5a97143535df85eafa0e47943ac797ec46d2","src/codegen/error.rs":"1a415136f93adde7458e39cab91413adc9a64243b718c7b74fdeba748959b5af","src/codegen/field.rs":"82104df8f3e733b23764fd6683e60d24ce62912b8b29a22dadbbc55d6a42f158","src/codegen/from_derive_impl.rs":"2a1e331d205db9334218b800760afcb64539fa2b25b0b2b014586b49b5b25882","src/codegen/from_field.rs":"af6f848ed7c6d2274e15d6307b011a1b8bcba66172ef68b0e665c9b4ae85157d","src/codegen/from_meta_impl.rs":"f769e1288aaa218303c987a2fba9286b93a104106fba63277e134ce19cd1047c","src/codegen/from_type_param.rs":"48493227f4a81fe1a533bd958b89207d56b1c70f754a2a28fb0e9eb9114a9aeb","src/codegen/from_variant_impl.rs":"3d9b10d60e3eb969946bbd210ce93a43375b9c8d3ffa827c7e87ab9235e2c3f3","src/codegen/mod.rs":"2dc3ee7f18177b2ef9c27c4f0cabc5bbd49f970abdba28a0539d81c70d81b6e2","src/codegen/outer_from_impl.rs":"9a91e67986787df1e0249559dd287e87b6fbfd757bd5f2632f43777b14a7d690","src/codegen/trait_impl.rs":"48080df3d025be7782604e883c46d53bcd62ea301dac379a36b27ce7e270e56c","src/codegen/variant.rs":"69ee861a63e31feb158611e93d0a355fdd94d6c8f3adc6c550864b7f5906d0ba","src/codegen/variant_data.rs":"2baa4328f01f6cdff008538a1492eb9fb5af2a88883a816ae6da7db3dc67b39e","src/derive.rs":"89180c13798b61510a6d266781e065114b75ca0be27e172a24656347b9baf1d3","src/error/kind.rs":"877f025ff72839ede46b8c7460331dac32ec56a7539816820179110381f8d0fb","src/error/mod.rs":"9908925c5798d81f34961c17aef8838d0730d825105bb9a8fa95e3958f25eda5","src/from_derive_input.rs":"b2a04fefa4e14684061c819387ea0384297c67c7f50d5d0959aa69ab19075e76","src/from_field.rs":"f667924422ab4ab8d8b16ebfd42f61e74864cfaa80e96b49de5d1e1287e3d1d3","src/from_generic_param.rs":"49c5a8335eb0a9010998c5600c95c89440f7febe03265afb625d818dbc883d92","src/from_generics.rs":"7285b0fd213507e87c1da413cd1bc9eeada485d4a8f9d19630848d02a4d41c4a","src/from_meta.rs":"d3847786280239d5e4260e2b88cb9986cb6feaaa1d3a2e2fb0678956eb936363","src/from_type_param.rs":"9b611f276871002ade78146266fde3b6f9101b360082681a2fa2dafc16431f84","src/from_variant.rs":"70a23b5b4cb93c7e5a498fe9d16420b9b93bd69c1376d7703bc7cefd9417d159","src/lib.rs":"ff9d4957c48641e9a63f18fe83d1153ea01994ebad93d1d905cc76d5fa58d3c9","src/macros_private.rs":"ef249cd9ca593aac423b4242df1c39c31610438da094c21562d74a7e5823c700","src/macros_public.rs":"3ed7eb99f309d9cd600d3a09ff4dcf5cc5d787fb49e8e5ead6bb00e31e5e6793","src/options/core.rs":"925a95513f7a6b9121f63998b1195f52f3bb9d76341ffa7544520443c77d9fe4","src/options/forward_attrs.rs":"89d8294a2204d6c32e5f58b797c23f4b035a8ff424bcf1b1c7db973ada89a4bc","src/options/from_derive.rs":"a53c5c991b5e25fdff47e9cb3f3f5aa48020e931546e7851bbd0711f98e9084c","src/options/from_field.rs":"67f338df3ffc270b3baf08b35cbe985802a65c1360c4e540cc5b937f6f08f915","src/options/from_meta.rs":"81a2ae765d390f64fbcbb1d30d40e895d77f8cd4f4c5f7167b1eacb48e066195","src/options/from_type_param.rs":"d3c8add6c8f5f7ee3d4a487c53e1f85002a2da43b943c03d4ce856fa6e7c8453","src/options/from_variant.rs":"84bd6294ebefe128c755f4cce1ef10117535435d4a2f631125b8d59170677cb4","src/options/input_field.rs":"094ef2865bbfba00e6894463f3440f523c3d1c53f938a414b23f9c78f7b1e01d","src/options/input_variant.rs":"6760a47a1d415b29c54202255a3937dd743e9e247cd8fe31767124b8b01d06db","src/options/mod.rs":"8fe5c94c3999d210cb024c6f6b181da92a0cc1a4a862e5d46ec49904c6692e11","src/options/outer_from.rs":"e60196f2b9ea3ae014eaf3444607c6cf2a227c8d8aa4a5d64f59454602a0a5e6","src/options/shape.rs":"c177cabcbee698351af6f7f3f9e848381197e041ed1628f0324e5cf52fd218f5","src/usage/generics_ext.rs":"340774fe43033680e6b494c76dd4f558ada7ca4f09e91f9e4d076f125a729fc2","src/usage/ident_set.rs":"30edb2f0a599284967e3c6b579da31e5f9b15f3dd67bc9a82d6335eb44133df0","src/usage/lifetimes.rs":"6ac25eb43b291414c274785d26912b0213e0b1d0d29d722cd4ffd915d4a58709","src/usage/mod.rs":"bcf0ffb2257aed3b7b2cdad91c0136743384f39ff8f61f25c195c73b8fcdf144","src/usage/options.rs":"0491c995aad0d55783b24cce8a4e40f0f4435988c54ce2ded34763ac9b199fcf","src/usage/type_params.rs":"0f4376ee9322d2c319ae15f41223595c72cb8a453a097879c2a0ee7f602c2f8c","src/util/ident_list.rs":"ea5f0419d7cb7fe6eb517ed2d3d2e0b00e1c7203be690157641f451a772355f1","src/util/ident_string.rs":"2b7fdbe9664c2e306114ffa830fde9710d849a0240029636cbb244457795b13f","src/util/ignored.rs":"7c979fbef880498ff64efda7396e759d80bf77fb1c7df0313bed8e533a16c0e0","src/util/mod.rs":"32b6df88e22444e44662ad745bb199df22964795194d2860c67c8b91a9a61a06","src/util/over_ride.rs":"e90b3aeb41dd3364753f3ee6f8c6bbd85bf51d51569bf048396ec6e7735c569f","src/util/spanned_value.rs":"3938cfc5169237cde1f19d65b653e1da8699663d1abfcf005359d48bbcee7d0b","src/util/with_original.rs":"a545b38ba9d624fdc939eb844f001b7fc4102717b1d3683b4cbd0aae00fa7ef2"},"package":"d2a368589465391e127e10c9e3a08efc8df66fd49b87dc8524c764bbe7f2ef82"}
\ No newline at end of file
diff --git a/third_party/rust/darling_core/Cargo.toml b/third_party/rust/darling_core/Cargo.toml
index af5a8dfd2b0c..713366c1ace8 100644
--- a/third_party/rust/darling_core/Cargo.toml
+++ b/third_party/rust/darling_core/Cargo.toml
@@ -12,7 +12,7 @@
 
 [package]
 name = "darling_core"
-version = "0.8.1"
+version = "0.8.6"
 authors = ["Ted Driggs <ted.driggs@outlook.com>"]
 description = "Helper crate for proc-macro library for reading attributes into structs when\nimplementing custom derives. Use https://crates.io/crates/darling in your code.\n"
 license = "MIT"
@@ -24,14 +24,20 @@ version = "1.0.6"
 version = "1.0.0"
 
 [dependencies.proc-macro2]
-version = "0.4.2"
+version = "0.4.26"
 
 [dependencies.quote]
 version = "0.6"
 
+[dependencies.strsim]
+version = "0.8.0"
+optional = true
+
 [dependencies.syn]
-version = "0.15"
+version = "0.15.26"
 features = ["extra-traits"]
 
 [features]
 default = ["syn/full"]
+diagnostics = []
+suggestions = ["strsim"]
diff --git a/third_party/rust/darling_core/LICENSE b/third_party/rust/darling_core/LICENSE
new file mode 100644
index 000000000000..0b48eadc9d03
--- /dev/null
+++ b/third_party/rust/darling_core/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Ted Driggs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/third_party/rust/darling_core/src/ast/data.rs b/third_party/rust/darling_core/src/ast/data.rs
index 1c2cd798fbcf..8ea42bd36c87 100644
--- a/third_party/rust/darling_core/src/ast/data.rs
+++ b/third_party/rust/darling_core/src/ast/data.rs
@@ -1,4 +1,4 @@
-use std::slice;
+use std::{slice, vec};
 
 use syn;
 
@@ -16,7 +16,7 @@ pub enum Data<V, F> {
     Struct(Fields<F>),
 }
 
-#[deprecated(since = "0.3", note = "this has been renamed to Data")]
+#[deprecated(since = "0.3.0", note = "this has been renamed to Data")]
 pub type Body<V, F> = Data<V, F>;
 
 impl<V, F> Data<V, F> {
@@ -32,7 +32,7 @@ impl<V, F> Data<V, F> {
     /// Creates a new `Data<&'a V, &'a F>` instance from `Data<V, F>`.
     pub fn as_ref<'a>(&'a self) -> Data<&'a V, &'a F> {
         match *self {
-            Data::Enum(ref variants) => Data::Enum(variants.into_iter().collect()),
+            Data::Enum(ref variants) => Data::Enum(variants.iter().collect()),
             Data::Struct(ref data) => Data::Struct(data.as_ref()),
         }
     }
@@ -107,11 +107,7 @@ impl<V: FromVariant, F: FromField> Data<V, F> {
             syn::Data::Enum(ref data) => {
                 let mut items = Vec::with_capacity(data.variants.len());
                 let mut errors = Vec::new();
-                for v_result in data.variants
-                    .clone()
-                    .into_iter()
-                    .map(|v| FromVariant::from_variant(&v))
-                {
+                for v_result in data.variants.iter().map(FromVariant::from_variant) {
                     match v_result {
                         Ok(val) => items.push(val),
                         Err(err) => errors.push(err),
@@ -156,13 +152,14 @@ impl<V: UsesLifetimes, F: UsesLifetimes> UsesLifetimes for Data<V, F> {
     }
 }
 
+/// Equivalent to `syn::Fields`, but replaces the AST element with a generic.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Fields<T> {
     pub style: Style,
     pub fields: Vec<T>,
 }
 
-#[deprecated(since = "0.3", note = "this has been renamed to Fields")]
+#[deprecated(since = "0.3.0", note = "this has been renamed to Fields")]
 pub type VariantData<T> = Fields<T>;
 
 impl<T> Fields<T> {
@@ -181,7 +178,7 @@ impl<T> Fields<T> {
 
     /// Returns true if this variant's data makes it a newtype.
     pub fn is_newtype(&self) -> bool {
-        self.style == Style::Tuple && self.fields.len() == 1
+        self.style == Style::Tuple && self.len() == 1
     }
 
     pub fn is_unit(&self) -> bool {
@@ -216,6 +213,16 @@ impl<T> Fields<T> {
     pub fn iter(&self) -> slice::Iter<T> {
         self.fields.iter()
     }
+
+    /// Returns the number of fields in the structure.
+    pub fn len(&self) -> usize {
+        self.fields.len()
+    }
+
+    /// Returns `true` if the `Fields` contains no fields.
+    pub fn is_empty(&self) -> bool {
+        self.fields.is_empty()
+    }
 }
 
 impl<F: FromField> Fields<F> {
@@ -226,8 +233,7 @@ impl<F: FromField> Fields<F> {
                 let mut errors = Vec::new();
 
                 for field in &fields.named {
-                    let f_result = FromField::from_field(field);
-                    match f_result {
+                    match FromField::from_field(field) {
                         Ok(val) => items.push(val),
                         Err(err) => errors.push(if let Some(ref ident) = field.ident {
                             err.at(ident)
@@ -244,8 +250,7 @@ impl<F: FromField> Fields<F> {
                 let mut errors = Vec::new();
 
                 for field in &fields.unnamed {
-                    let f_result = FromField::from_field(field);
-                    match f_result {
+                    match FromField::from_field(field) {
                         Ok(val) => items.push(val),
                         Err(err) => errors.push(if let Some(ref ident) = field.ident {
                             err.at(ident)
@@ -271,6 +276,15 @@ impl<F: FromField> Fields<F> {
     }
 }
 
+impl<T> IntoIterator for Fields<T> {
+    type Item = T;
+    type IntoIter = vec::IntoIter<T>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.fields.into_iter()
+    }
+}
+
 impl<T> From<Style> for Fields<T> {
     fn from(style: Style) -> Self {
         Fields {
@@ -314,16 +328,16 @@ pub enum Style {
 }
 
 impl Style {
-    pub fn is_unit(&self) -> bool {
-        *self == Style::Unit
+    pub fn is_unit(self) -> bool {
+        self == Style::Unit
     }
 
-    pub fn is_tuple(&self) -> bool {
-        *self == Style::Tuple
+    pub fn is_tuple(self) -> bool {
+        self == Style::Tuple
     }
 
-    pub fn is_struct(&self) -> bool {
-        *self == Style::Struct
+    pub fn is_struct(self) -> bool {
+        self == Style::Struct
     }
 
     /// Creates a new `Fields` of the specified style with the passed-in fields.
diff --git a/third_party/rust/darling_core/src/codegen/attr_extractor.rs b/third_party/rust/darling_core/src/codegen/attr_extractor.rs
index 0b610044cb7d..828974797112 100644
--- a/third_party/rust/darling_core/src/codegen/attr_extractor.rs
+++ b/third_party/rust/darling_core/src/codegen/attr_extractor.rs
@@ -37,7 +37,8 @@ pub trait ExtractAttribute {
         let declarations = self.declarations();
 
         let will_parse_any = !self.attr_names().is_empty();
-        let will_fwd_any = self.forwarded_attrs()
+        let will_fwd_any = self
+            .forwarded_attrs()
             .map(|fa| !fa.is_empty())
             .unwrap_or_default();
 
@@ -56,7 +57,7 @@ pub trait ExtractAttribute {
             let core_loop = self.core_loop();
             quote!(
                 #(#attr_names)|* => {
-                    if let Some(::syn::Meta::List(ref __data)) = __attr.interpret_meta() {
+                    if let ::darling::export::Some(::syn::Meta::List(ref __data)) = __attr.interpret_meta() {
                         let __items = &__data.nested;
 
                         #core_loop
@@ -106,4 +107,4 @@ fn forwards_to_local(behavior: &ForwardAttrs) -> TokenStream {
             )
         }
     }
-}
\ No newline at end of file
+}
diff --git a/third_party/rust/darling_core/src/codegen/error.rs b/third_party/rust/darling_core/src/codegen/error.rs
index 9c36d96eff42..bfa18d2d337d 100644
--- a/third_party/rust/darling_core/src/codegen/error.rs
+++ b/third_party/rust/darling_core/src/codegen/error.rs
@@ -2,38 +2,27 @@ use proc_macro2::TokenStream;
 use quote::{TokenStreamExt, ToTokens};
 
 /// Declares the local variable into which errors will be accumulated.
+#[derive(Default)]
 pub struct ErrorDeclaration {
     __hidden: (),
 }
 
-impl ErrorDeclaration {
-    pub fn new() -> Self {
-        ErrorDeclaration { __hidden: () }
-    }
-}
-
 impl ToTokens for ErrorDeclaration {
     fn to_tokens(&self, tokens: &mut TokenStream) {
         tokens.append_all(quote! {
-            let mut __errors = Vec::new();
+            let mut __errors = ::darling::export::Vec::new();
         })
     }
 }
 
 /// Returns early if attribute or body parsing has caused any errors.
+#[derive(Default)]
 pub struct ErrorCheck<'a> {
     location: Option<&'a str>,
     __hidden: (),
 }
 
 impl<'a> ErrorCheck<'a> {
-    pub fn new() -> Self {
-        ErrorCheck {
-            location: None,
-            __hidden: (),
-        }
-    }
-
     pub fn with_location(location: &'a str) -> Self {
         ErrorCheck {
             location: Some(location),
diff --git a/third_party/rust/darling_core/src/codegen/field.rs b/third_party/rust/darling_core/src/codegen/field.rs
index d80cfa56a95f..ae32f88d5c1e 100644
--- a/third_party/rust/darling_core/src/codegen/field.rs
+++ b/third_party/rust/darling_core/src/codegen/field.rs
@@ -1,5 +1,7 @@
+use std::borrow::Cow;
+
 use proc_macro2::TokenStream;
-use quote::{TokenStreamExt, ToTokens};
+use quote::{ToTokens, TokenStreamExt};
 use syn::{Ident, Path, Type};
 
 use codegen::DefaultExpression;
@@ -11,7 +13,7 @@ use usage::{self, IdentRefSet, IdentSet, UsesTypeParams};
 pub struct Field<'a> {
     /// The name presented to the user of the library. This will appear
     /// in error messages and will be looked when parsing names.
-    pub name_in_attr: String,
+    pub name_in_attr: Cow<'a, String>,
 
     /// The name presented to the author of the library. This will appear
     /// in the setters or temporary variables which contain the values.
@@ -20,13 +22,17 @@ pub struct Field<'a> {
     /// The type of the field in the input.
     pub ty: &'a Type,
     pub default_expression: Option<DefaultExpression<'a>>,
-    pub with_path: Path,
+    pub with_path: Cow<'a, Path>,
     pub map: Option<&'a Path>,
     pub skip: bool,
     pub multiple: bool,
 }
 
 impl<'a> Field<'a> {
+    pub fn as_name(&'a self) -> &'a str {
+        &self.name_in_attr
+    }
+
     pub fn as_declaration(&'a self) -> Declaration<'a> {
         Declaration(self, !self.skip)
     }
@@ -104,7 +110,12 @@ impl<'a> ToTokens for MatchArm<'a> {
                 quote!(#name_str)
             };
 
-            let mut extractor = quote!(#with_path(__inner).map_err(|e| e.at(#location)));
+            // Add the span immediately on extraction failure, so that it's as specific as possible.
+            // The behavior of `with_span` makes this safe to do; if the child applied an
+            // even-more-specific span, our attempt here will not overwrite that and will only cost
+            // us one `if` check.
+            let mut extractor =
+                quote!(#with_path(__inner).map_err(|e| e.with_span(&__inner).at(#location)));
             if let Some(ref map) = field.map {
                 extractor = quote!(#extractor.map(#map))
             }
@@ -116,10 +127,10 @@ impl<'a> ToTokens for MatchArm<'a> {
                         // it for error reporting.
                         let __len = #ident.len();
                         match #extractor {
-                            Ok(__val) => {
+                            ::darling::export::Ok(__val) => {
                                 #ident.push(__val)
                             }
-                            Err(__err) => {
+                            ::darling::export::Err(__err) => {
                                 __errors.push(__err)
                             }
                         }
@@ -130,16 +141,16 @@ impl<'a> ToTokens for MatchArm<'a> {
                     #name_str => {
                         if !#ident.0 {
                             match #extractor {
-                                Ok(__val) => {
+                                ::darling::export::Ok(__val) => {
                                     #ident = (true, ::darling::export::Some(__val));
                                 }
-                                Err(__err) => {
+                                ::darling::export::Err(__err) => {
                                     #ident = (true, None);
                                     __errors.push(__err);
                                 }
                             }
                         } else {
-                            __errors.push(::darling::Error::duplicate_field(#name_str));
+                            __errors.push(::darling::Error::duplicate_field(#name_str).with_span(&__inner));
                         }
                     }
                 )
@@ -165,15 +176,13 @@ impl<'a> ToTokens for Initializer<'a> {
             } else {
                 quote!(#ident: #ident)
             }
+        } else if let Some(ref expr) = field.default_expression {
+            quote!(#ident: match #ident.1 {
+                ::darling::export::Some(__val) => __val,
+                ::darling::export::None => #expr,
+            })
         } else {
-            if let Some(ref expr) = field.default_expression {
-                quote!(#ident: match #ident.1 {
-                    ::darling::export::Some(__val) => __val,
-                    ::darling::export::None => #expr,
-                })
-            } else {
-                quote!(#ident: #ident.1.expect("Uninitialized fields without defaults were already checked"))
-            }
+            quote!(#ident: #ident.1.expect("Uninitialized fields without defaults were already checked"))
         });
     }
 }
diff --git a/third_party/rust/darling_core/src/codegen/from_meta_impl.rs b/third_party/rust/darling_core/src/codegen/from_meta_impl.rs
index 3744d4fd076e..06add97c9fd6 100644
--- a/third_party/rust/darling_core/src/codegen/from_meta_impl.rs
+++ b/third_party/rust/darling_core/src/codegen/from_meta_impl.rs
@@ -19,7 +19,7 @@ impl<'a> ToTokens for FromMetaImpl<'a> {
                 let ty_ident = base.ident;
                 quote!(
                     fn from_word() -> ::darling::Result<Self> {
-                        Ok(#ty_ident)
+                        ::darling::export::Ok(#ty_ident)
                     }
                 )
             }
@@ -29,12 +29,13 @@ impl<'a> ToTokens for FromMetaImpl<'a> {
                 ref fields,
                 style: Style::Tuple,
                 ..
-            }) if fields.len() == 1 =>
-            {
+            }) if fields.len() == 1 => {
                 let ty_ident = base.ident;
                 quote!(
                     fn from_meta(__item: &::syn::Meta) -> ::darling::Result<Self> {
-                        Ok(#ty_ident(::darling::FromMeta::from_meta(__item)?))
+                        ::darling::FromMeta::from_meta(__item)
+                            .map_err(|e| e.with_span(&__item))
+                            .map(#ty_ident)
                     }
                 )
             }
@@ -79,6 +80,17 @@ impl<'a> ToTokens for FromMetaImpl<'a> {
                 let unit_arms = variants.iter().map(Variant::as_unit_match_arm);
                 let struct_arms = variants.iter().map(Variant::as_data_match_arm);
 
+                let unknown_variant_err = if !variants.is_empty() {
+                    let names = variants.iter().map(Variant::as_name);
+                    quote! {
+                        unknown_field_with_alts(__other, &[#(#names),*])
+                    }
+                } else {
+                    quote! {
+                        unknown_field(__other)
+                    }
+                };
+
                 quote!(
                     fn from_list(__outer: &[::syn::NestedMeta]) -> ::darling::Result<Self> {
                         // An enum must have exactly one value inside the parentheses if it's not a unit
@@ -89,7 +101,7 @@ impl<'a> ToTokens for FromMetaImpl<'a> {
                                 if let ::syn::NestedMeta::Meta(ref __nested) = __outer[0] {
                                     match __nested.name().to_string().as_ref() {
                                         #(#struct_arms)*
-                                        __other => ::darling::export::Err(::darling::Error::unknown_value(__other))
+                                        __other => ::darling::export::Err(::darling::Error::#unknown_variant_err.with_span(__nested))
                                     }
                                 } else {
                                     ::darling::export::Err(::darling::Error::unsupported_format("literal"))
diff --git a/third_party/rust/darling_core/src/codegen/outer_from_impl.rs b/third_party/rust/darling_core/src/codegen/outer_from_impl.rs
index 13ea8af30521..f21b3bc024eb 100644
--- a/third_party/rust/darling_core/src/codegen/outer_from_impl.rs
+++ b/third_party/rust/darling_core/src/codegen/outer_from_impl.rs
@@ -49,7 +49,7 @@ fn compute_impl_bounds(bound: Path, mut generics: Generics, applies_to: &IdentSe
     });
 
     for mut param in generics.params.iter_mut() {
-        if let &mut GenericParam::Type(ref mut typ) = param {
+        if let GenericParam::Type(ref mut typ) = *param {
             if applies_to.contains(&typ.ident) {
                 typ.bounds.push(added_bound.clone());
             }
diff --git a/third_party/rust/darling_core/src/codegen/trait_impl.rs b/third_party/rust/darling_core/src/codegen/trait_impl.rs
index 601a6daf018b..a2fa9893cd92 100644
--- a/third_party/rust/darling_core/src/codegen/trait_impl.rs
+++ b/third_party/rust/darling_core/src/codegen/trait_impl.rs
@@ -15,6 +15,7 @@ pub struct TraitImpl<'a> {
     pub default: Option<DefaultExpression<'a>>,
     pub map: Option<&'a Path>,
     pub bound: Option<&'a [WherePredicate]>,
+    pub allow_unknown_fields: bool,
 }
 
 impl<'a> TraitImpl<'a> {
@@ -44,17 +45,18 @@ impl<'a> TraitImpl<'a> {
         let declared = self.declared_type_params();
         match self.data {
             Data::Struct(ref v) => self.type_params_in_fields(v, &field_filter, &declared),
-            Data::Enum(ref v) => v.iter().filter(variant_filter).fold(
-                Default::default(),
-                |mut state, variant| {
-                    state.extend(self.type_params_in_fields(
-                        &variant.data,
-                        &field_filter,
-                        &declared,
-                    ));
-                    state
-                },
-            ),
+            Data::Enum(ref v) => {
+                v.iter()
+                    .filter(variant_filter)
+                    .fold(Default::default(), |mut state, variant| {
+                        state.extend(self.type_params_in_fields(
+                            &variant.data,
+                            &field_filter,
+                            &declared,
+                        ));
+                        state
+                    })
+            }
         }
     }
 
@@ -78,12 +80,12 @@ impl<'a> TraitImpl<'a> {
 impl<'a> TraitImpl<'a> {
     /// Gets the `let` declaration for errors accumulated during parsing.
     pub fn declare_errors(&self) -> ErrorDeclaration {
-        ErrorDeclaration::new()
+        ErrorDeclaration::default()
     }
 
     /// Gets the check which performs an early return if errors occurred during parsing.
     pub fn check_errors(&self) -> ErrorCheck {
-        ErrorCheck::new()
+        ErrorCheck::default()
     }
 
     /// Generate local variable declarations for all fields.
@@ -129,21 +131,18 @@ impl<'a> TraitImpl<'a> {
     }
 
     pub(in codegen) fn initializers(&self) -> TokenStream {
-        let foo = match self.data {
-            Data::Enum(_) => panic!("Core loop on enums isn't supported"),
-            Data::Struct(ref data) => FieldsGen(data),
-        };
-
-        foo.initializers()
+        self.make_field_ctx().initializers()
     }
 
     /// Generate the loop which walks meta items looking for property matches.
     pub(in codegen) fn core_loop(&self) -> TokenStream {
-        let foo = match self.data {
-            Data::Enum(_) => panic!("Core loop on enums isn't supported"),
-            Data::Struct(ref data) => FieldsGen(data),
-        };
+        self.make_field_ctx().core_loop()
+    }
 
-        foo.core_loop()
+    fn make_field_ctx(&'a self) -> FieldsGen<'a> {
+        match self.data {
+            Data::Enum(_) => panic!("Core loop on enums isn't supported"),
+            Data::Struct(ref data) => FieldsGen::new(data, self.allow_unknown_fields),
+        }
     }
 }
diff --git a/third_party/rust/darling_core/src/codegen/variant.rs b/third_party/rust/darling_core/src/codegen/variant.rs
index d4ab868a0507..e982a2e81568 100644
--- a/third_party/rust/darling_core/src/codegen/variant.rs
+++ b/third_party/rust/darling_core/src/codegen/variant.rs
@@ -1,5 +1,7 @@
+use std::borrow::Cow;
+
 use proc_macro2::TokenStream;
-use quote::{TokenStreamExt, ToTokens};
+use quote::{ToTokens, TokenStreamExt};
 use syn::Ident;
 
 use ast::Fields;
@@ -7,11 +9,11 @@ use codegen::error::{ErrorCheck, ErrorDeclaration};
 use codegen::{Field, FieldsGen};
 use usage::{self, IdentRefSet, IdentSet, UsesTypeParams};
 
-/// An enum variant.
+/// A variant of the enum which is deriving `FromMeta`.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Variant<'a> {
     /// The name which will appear in code passed to the `FromMeta` input.
-    pub name_in_attr: String,
+    pub name_in_attr: Cow<'a, String>,
 
     /// The name of the variant which will be returned for a given `name_in_attr`.
     pub variant_ident: &'a Ident,
@@ -23,9 +25,15 @@ pub struct Variant<'a> {
 
     /// Whether or not the variant should be skipped in the generated code.
     pub skip: bool,
+
+    pub allow_unknown_fields: bool,
 }
 
 impl<'a> Variant<'a> {
+    pub fn as_name(&'a self) -> &'a str {
+        &self.name_in_attr
+    }
+
     pub fn as_unit_match_arm(&'a self) -> UnitMatchArm<'a> {
         UnitMatchArm(self)
     }
@@ -45,6 +53,9 @@ impl<'a> UsesTypeParams for Variant<'a> {
     }
 }
 
+/// Code generator for an enum variant in a unit match position.
+/// This is placed in generated `from_string` calls for the parent enum.
+/// Value-carrying variants wrapped in this type will emit code to produce an "unsupported format" error.
 pub struct UnitMatchArm<'a>(&'a Variant<'a>);
 
 impl<'a> ToTokens for UnitMatchArm<'a> {
@@ -72,6 +83,9 @@ impl<'a> ToTokens for UnitMatchArm<'a> {
     }
 }
 
+/// Code generator for an enum variant in a data-carrying match position.
+/// This is placed in generated `from_list` calls for the parent enum.
+/// Unit variants wrapped in this type will emit code to produce an "unsupported format" error.
 pub struct DataMatchArm<'a>(&'a Variant<'a>);
 
 impl<'a> ToTokens for DataMatchArm<'a> {
@@ -94,10 +108,10 @@ impl<'a> ToTokens for DataMatchArm<'a> {
             return;
         }
 
-        let vdg = FieldsGen(&val.data);
+        let vdg = FieldsGen::new(&val.data, val.allow_unknown_fields);
 
         if val.data.is_struct() {
-            let declare_errors = ErrorDeclaration::new();
+            let declare_errors = ErrorDeclaration::default();
             let check_errors = ErrorCheck::with_location(&name_in_attr);
             let require_fields = vdg.require_fields();
             let decls = vdg.declarations();
diff --git a/third_party/rust/darling_core/src/codegen/variant_data.rs b/third_party/rust/darling_core/src/codegen/variant_data.rs
index 250e4c63c73e..54fc02db7471 100644
--- a/third_party/rust/darling_core/src/codegen/variant_data.rs
+++ b/third_party/rust/darling_core/src/codegen/variant_data.rs
@@ -2,19 +2,29 @@ use proc_macro2::TokenStream;
 
 use ast::Fields;
 use ast::Style;
-use codegen::field;
 use codegen::Field;
 
-pub struct FieldsGen<'a>(pub &'a Fields<Field<'a>>);
+pub struct FieldsGen<'a> {
+    fields: &'a Fields<Field<'a>>,
+    allow_unknown_fields: bool,
+}
 
 impl<'a> FieldsGen<'a> {
+    pub fn new(fields: &'a Fields<Field<'a>>, allow_unknown_fields: bool) -> Self {
+        Self {
+            fields,
+            allow_unknown_fields,
+        }
+    }
+
+    /// Create declarations for all the fields in the struct.
     pub(in codegen) fn declarations(&self) -> TokenStream {
-        match *self.0 {
+        match *self.fields {
             Fields {
                 style: Style::Struct,
                 ref fields,
             } => {
-                let vdr = fields.into_iter().map(Field::as_declaration);
+                let vdr = fields.iter().map(Field::as_declaration);
                 quote!(#(#vdr)*)
             }
             _ => panic!("FieldsGen doesn't support tuples yet"),
@@ -23,7 +33,26 @@ impl<'a> FieldsGen<'a> {
 
     /// Generate the loop which walks meta items looking for property matches.
     pub(in codegen) fn core_loop(&self) -> TokenStream {
-        let arms: Vec<field::MatchArm> = self.0.as_ref().map(Field::as_match).fields;
+        let arms = self.fields.as_ref().map(Field::as_match);
+
+        // If we're allowing unknown fields, then handling one is a no-op.
+        // Otherwise, we're going to push a new spanned error pointing at the field.
+        let handle_unknown = if self.allow_unknown_fields {
+            quote!()
+        } else {
+            // We can't call `unknown_field_with_alts` with an empty slice, or else it fails to
+            // infer the type of the slice item.
+            let err_fn = if arms.is_empty() {
+                quote!(unknown_field(__other))
+            } else {
+                let names = self.fields.as_ref().map(Field::as_name);
+                quote!(unknown_field_with_alts(__other, &[#(#names),*]))
+            };
+
+            quote! {
+                __errors.push(::darling::Error::#err_fn.with_span(__inner));
+            }
+        };
 
         quote!(
             for __item in __items {
@@ -31,7 +60,7 @@ impl<'a> FieldsGen<'a> {
                     let __name = __inner.name().to_string();
                     match __name.as_str() {
                         #(#arms)*
-                        __other => { __errors.push(::darling::Error::unknown_field(__other)); }
+                        __other => { #handle_unknown }
                     }
                 }
             }
@@ -39,12 +68,12 @@ impl<'a> FieldsGen<'a> {
     }
 
     pub fn require_fields(&self) -> TokenStream {
-        match *self.0 {
+        match *self.fields {
             Fields {
                 style: Style::Struct,
                 ref fields,
             } => {
-                let checks = fields.into_iter().map(Field::as_presence_check);
+                let checks = fields.iter().map(Field::as_presence_check);
                 quote!(#(#checks)*)
             }
             _ => panic!("FieldsGen doesn't support tuples for requirement checks"),
@@ -52,7 +81,7 @@ impl<'a> FieldsGen<'a> {
     }
 
     pub(in codegen) fn initializers(&self) -> TokenStream {
-        let inits: Vec<_> = self.0.as_ref().map(Field::as_initializer).fields;
+        let inits = self.fields.as_ref().map(Field::as_initializer);
 
         quote!(#(#inits),*)
     }
diff --git a/third_party/rust/darling_core/src/derive.rs b/third_party/rust/darling_core/src/derive.rs
new file mode 100644
index 000000000000..92dce8e1a924
--- /dev/null
+++ b/third_party/rust/darling_core/src/derive.rs
@@ -0,0 +1,54 @@
+//! Functions to derive `darling`'s traits from well-formed input, without directly depending
+//! on `proc_macro`.
+
+use proc_macro2::TokenStream;
+use quote::ToTokens;
+use syn::DeriveInput;
+
+use options;
+
+/// Run an expression which returns a `darling::Result`, then either return the tokenized
+/// representation of the `Ok` value, or the tokens of the compiler errors in the `Err` case.
+macro_rules! emit_impl_or_error {
+    ($e:expr) => {
+        match $e {
+            Ok(val) => val.into_token_stream(),
+            Err(err) => err.write_errors(),
+        }
+    };
+}
+
+/// Create tokens for a `darling::FromMeta` impl from a `DeriveInput`. If
+/// the input cannot produce a valid impl, the returned tokens will contain
+/// compile errors instead.
+pub fn from_meta(input: &DeriveInput) -> TokenStream {
+    emit_impl_or_error!(options::FromMetaOptions::new(input))
+}
+
+/// Create tokens for a `darling::FromDeriveInput` impl from a `DeriveInput`. If
+/// the input cannot produce a valid impl, the returned tokens will contain
+/// compile errors instead.
+pub fn from_derive_input(input: &DeriveInput) -> TokenStream {
+    emit_impl_or_error!(options::FdiOptions::new(&input))
+}
+
+/// Create tokens for a `darling::FromField` impl from a `DeriveInput`. If
+/// the input cannot produce a valid impl, the returned tokens will contain
+/// compile errors instead.
+pub fn from_field(input: &DeriveInput) -> TokenStream {
+    emit_impl_or_error!(options::FromFieldOptions::new(input))
+}
+
+/// Create tokens for a `darling::FromTypeParam` impl from a `DeriveInput`. If
+/// the input cannot produce a valid impl, the returned tokens will contain
+/// compile errors instead.
+pub fn from_type_param(input: &DeriveInput) -> TokenStream {
+    emit_impl_or_error!(options::FromTypeParamOptions::new(input))
+}
+
+/// Create tokens for a `darling::FromVariant` impl from a `DeriveInput`. If
+/// the input cannot produce a valid impl, the returned tokens will contain
+/// compile errors instead.
+pub fn from_variant(input: &DeriveInput) -> TokenStream {
+    emit_impl_or_error!(options::FromVariantOptions::new(input))
+}
diff --git a/third_party/rust/darling_core/src/error.rs b/third_party/rust/darling_core/src/error.rs
deleted file mode 100644
index 73bda734d3c0..000000000000
--- a/third_party/rust/darling_core/src/error.rs
+++ /dev/null
@@ -1,373 +0,0 @@
-//! Types for working with darling errors and results.
-
-use std::error::Error as StdError;
-use std::fmt;
-use std::iter::{self, Iterator};
-use std::string::ToString;
-use std::vec;
-
-/// An alias of `Result` specific to attribute parsing.
-pub type Result<T> = ::std::result::Result<T, Error>;
-
-/// An error encountered during attribute parsing.
-///
-/// Given that most errors darling encounters represent code bugs in dependent crates,
-/// the internal structure of the error is deliberately opaque.
-#[derive(Debug)]
-// Don't want to publicly commit to Error supporting equality yet, but
-// not having it makes testing very difficult.
-#[cfg_attr(test, derive(Clone, PartialEq, Eq))]
-pub struct Error {
-    kind: ErrorKind,
-    locations: Vec<String>,
-}
-
-impl Error {
-    fn new(kind: ErrorKind) -> Self {
-        Error {
-            kind: kind,
-            locations: Vec::new(),
-        }
-    }
-
-    /// Creates a new error with a custom message.
-    pub fn custom<T: fmt::Display>(msg: T) -> Self {
-        Error::new(ErrorKind::Custom(msg.to_string()))
-    }
-
-    /// Creates a new error for a field that appears twice in the input.
-    pub fn duplicate_field(name: &str) -> Self {
-        Error::new(ErrorKind::DuplicateField(name.into()))
-    }
-
-    /// Creates a new error for a non-optional field that does not appear in the input.
-    pub fn missing_field(name: &str) -> Self {
-        Error::new(ErrorKind::MissingField(name.into()))
-    }
-
-    /// Creates a new error for a field name that appears in the input but does not correspond
-    /// to a known field.
-    pub fn unknown_field(name: &str) -> Self {
-        Error::new(ErrorKind::UnknownField(name.into()))
-    }
-
-    /// Creates a new error for a struct or variant that does not adhere to the supported shape.
-    pub fn unsupported_shape(shape: &str) -> Self {
-        Error::new(ErrorKind::UnsupportedShape(shape.into()))
-    }
-
-    pub fn unsupported_format(format: &str) -> Self {
-        Error::new(ErrorKind::UnexpectedFormat(format.into()))
-    }
-
-    /// Creates a new error for a field which has an unexpected literal type.
-    pub fn unexpected_type(ty: &str) -> Self {
-        Error::new(ErrorKind::UnexpectedType(ty.into()))
-    }
-
-    /// Creates a new error for a value which doesn't match a set of expected literals.
-    pub fn unknown_value(value: &str) -> Self {
-        Error::new(ErrorKind::UnknownValue(value.into()))
-    }
-
-    /// Creates a new error for a list which did not get enough items to proceed.
-    pub fn too_few_items(min: usize) -> Self {
-        Error::new(ErrorKind::TooFewItems(min))
-    }
-
-    /// Creates a new error when a list got more items than it supports. The `max` argument
-    /// is the largest number of items the receiver could accept.
-    pub fn too_many_items(max: usize) -> Self {
-        Error::new(ErrorKind::TooManyItems(max))
-    }
-
-    /// Bundle a set of multiple errors into a single `Error` instance.
-    ///
-    /// # Panics
-    /// This function will panic if `errors.is_empty() == true`.
-    pub fn multiple(mut errors: Vec<Error>) -> Self {
-        if errors.len() > 1 {
-            Error::new(ErrorKind::Multiple(errors))
-        } else if errors.len() == 1 {
-            errors
-                .pop()
-                .expect("Error array of length 1 has a first item")
-        } else {
-            panic!("Can't deal with 0 errors")
-        }
-    }
-
-    /// Recursively converts a tree of errors to a flattened list.
-    pub fn flatten(self) -> Self {
-        Error::multiple(self.to_vec())
-    }
-
-    fn to_vec(self) -> Vec<Self> {
-        if let ErrorKind::Multiple(errors) = self.kind {
-            let mut flat = Vec::new();
-            for error in errors {
-                flat.extend(error.prepend_at(self.locations.clone()).to_vec());
-            }
-
-            flat
-        } else {
-            vec![self]
-        }
-    }
-
-    /// Adds a location to the error, such as a field or variant.
-    /// Locations must be added in reverse order of specificity.
-    pub fn at<T: fmt::Display>(mut self, location: T) -> Self {
-        self.locations.insert(0, location.to_string());
-        self
-    }
-
-    /// Gets the number of individual errors in this error.
-    ///
-    /// This function should never return `0`, as it shouldn't be possible to construct
-    /// a multi-error from an empty `Vec`.
-    pub fn len(&self) -> usize {
-        self.kind.len()
-    }
-
-    /// Adds a location chain to the head of the error's existing locations.
-    fn prepend_at(mut self, mut locations: Vec<String>) -> Self {
-        if !locations.is_empty() {
-            locations.extend(self.locations);
-            self.locations = locations;
-        }
-
-        self
-    }
-
-    /// Gets the location slice.
-    #[cfg(test)]
-    pub(crate) fn location(&self) -> Vec<&str> {
-        self.locations.iter().map(|i| i.as_str()).collect()
-    }
-}
-
-impl StdError for Error {
-    fn description(&self) -> &str {
-        &self.kind.description()
-    }
-
-    fn cause(&self) -> Option<&StdError> {
-        None
-    }
-}
-
-impl fmt::Display for Error {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}", self.kind)?;
-        if !self.locations.is_empty() {
-            write!(f, " at {}", self.locations.join("/"))?;
-        }
-
-        Ok(())
-    }
-}
-
-impl IntoIterator for Error {
-    type Item = Error;
-    type IntoIter = IntoIter;
-
-    fn into_iter(self) -> IntoIter {
-        if let ErrorKind::Multiple(errors) = self.kind {
-            IntoIter {
-                inner: IntoIterEnum::Multiple(errors.into_iter()),
-            }
-        } else {
-            IntoIter {
-                inner: IntoIterEnum::Single(iter::once(self)),
-            }
-        }
-    }
-}
-
-enum IntoIterEnum {
-    Single(iter::Once<Error>),
-    Multiple(vec::IntoIter<Error>),
-}
-
-impl Iterator for IntoIterEnum {
-    type Item = Error;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        match *self {
-            IntoIterEnum::Single(ref mut content) => content.next(),
-            IntoIterEnum::Multiple(ref mut content) => content.next(),
-        }
-    }
-}
-
-/// An iterator that moves out of an `Error`.
-pub struct IntoIter {
-    inner: IntoIterEnum,
-}
-
-impl Iterator for IntoIter {
-    type Item = Error;
-
-    fn next(&mut self) -> Option<Error> {
-        self.inner.next()
-    }
-}
-
-type DeriveInputShape = String;
-type FieldName = String;
-type MetaFormat = String;
-
-#[derive(Debug)]
-// Don't want to publicly commit to ErrorKind supporting equality yet, but
-// not having it makes testing very difficult.
-#[cfg_attr(test, derive(Clone, PartialEq, Eq))]
-enum ErrorKind {
-    /// An arbitrary error message.
-    Custom(String),
-    DuplicateField(FieldName),
-    MissingField(FieldName),
-    UnsupportedShape(DeriveInputShape),
-    UnknownField(FieldName),
-    UnexpectedFormat(MetaFormat),
-    UnexpectedType(String),
-    UnknownValue(String),
-    TooFewItems(usize),
-    TooManyItems(usize),
-    /// A set of errors.
-    Multiple(Vec<Error>),
-
-    // TODO make this variant take `!` so it can't exist
-    #[doc(hidden)]
-    __NonExhaustive,
-}
-
-impl ErrorKind {
-    pub fn description(&self) -> &str {
-        use self::ErrorKind::*;
-
-        match *self {
-            Custom(ref s) => s,
-            DuplicateField(_) => "Duplicate field",
-            MissingField(_) => "Missing field",
-            UnknownField(_) => "Unexpected field",
-            UnsupportedShape(_) => "Unsupported shape",
-            UnexpectedFormat(_) => "Unexpected meta-item format",
-            UnexpectedType(_) => "Unexpected literal type",
-            UnknownValue(_) => "Unknown literal value",
-            TooFewItems(_) => "Too few items",
-            TooManyItems(_) => "Too many items",
-            Multiple(_) => "Multiple errors",
-            __NonExhaustive => unreachable!(),
-        }
-    }
-
-    /// Deeply counts the number of errors this item represents.
-    pub fn len(&self) -> usize {
-        if let ErrorKind::Multiple(ref items) = *self {
-            items.iter().map(Error::len).sum()
-        } else {
-            1
-        }
-    }
-}
-
-impl fmt::Display for ErrorKind {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use self::ErrorKind::*;
-
-        match *self {
-            Custom(ref s) => s.fmt(f),
-            DuplicateField(ref field) => write!(f, "Duplicate field `{}`", field),
-            MissingField(ref field) => write!(f, "Missing field `{}`", field),
-            UnknownField(ref field) => write!(f, "Unexpected field `{}`", field),
-            UnsupportedShape(ref shape) => write!(f, "Unsupported shape `{}`", shape),
-            UnexpectedFormat(ref format) => write!(f, "Unexpected meta-item format `{}`", format),
-            UnexpectedType(ref ty) => write!(f, "Unexpected literal type `{}`", ty),
-            UnknownValue(ref val) => write!(f, "Unknown literal value `{}`", val),
-            TooFewItems(ref min) => write!(f, "Too few items: Expected at least {}", min),
-            TooManyItems(ref max) => write!(f, "Too many items: Expected no more than {}", max),
-            Multiple(ref items) if items.len() == 1 => items[0].fmt(f),
-            Multiple(ref items) => {
-                write!(f, "Multiple errors: (")?;
-                let mut first = true;
-                for item in items {
-                    if !first {
-                        write!(f, ", ")?;
-                    } else {
-                        first = false;
-                    }
-
-                    item.fmt(f)?;
-                }
-
-                write!(f, ")")
-            }
-            __NonExhaustive => unreachable!(),
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::Error;
-
-    #[test]
-    fn flatten_noop() {
-        let err = Error::duplicate_field("hello").at("world");
-        assert_eq!(err.clone().flatten(), err);
-    }
-
-    #[test]
-    fn flatten_simple() {
-        let err = Error::multiple(vec![
-            Error::unknown_field("hello").at("world"),
-            Error::missing_field("hell_no").at("world"),
-        ]).at("foo")
-            .flatten();
-
-        assert!(err.location().is_empty());
-
-        let mut err_iter = err.into_iter();
-
-        let first = err_iter.next();
-        assert!(first.is_some());
-        assert_eq!(first.unwrap().location(), vec!["foo", "world"]);
-
-        let second = err_iter.next();
-        assert!(second.is_some());
-
-        assert_eq!(second.unwrap().location(), vec!["foo", "world"]);
-
-        assert!(err_iter.next().is_none());
-    }
-
-    #[test]
-    fn len_single() {
-        let err = Error::duplicate_field("hello");
-        assert_eq!(1, err.len());
-    }
-
-    #[test]
-    fn len_multiple() {
-        let err = Error::multiple(vec![
-            Error::duplicate_field("hello"),
-            Error::missing_field("hell_no"),
-        ]);
-        assert_eq!(2, err.len());
-    }
-
-    #[test]
-    fn len_nested() {
-        let err = Error::multiple(vec![
-            Error::duplicate_field("hello"),
-            Error::multiple(vec![
-                Error::duplicate_field("hi"),
-                Error::missing_field("bye"),
-                Error::multiple(vec![Error::duplicate_field("whatsup")]),
-            ]),
-        ]);
-
-        assert_eq!(4, err.len());
-    }
-}
diff --git a/third_party/rust/darling_core/src/error/kind.rs b/third_party/rust/darling_core/src/error/kind.rs
new file mode 100644
index 000000000000..92d4afeb37ad
--- /dev/null
+++ b/third_party/rust/darling_core/src/error/kind.rs
@@ -0,0 +1,201 @@
+use std::fmt;
+
+use error::Error;
+
+type DeriveInputShape = String;
+type FieldName = String;
+type MetaFormat = String;
+
+#[derive(Debug)]
+// Don't want to publicly commit to ErrorKind supporting equality yet, but
+// not having it makes testing very difficult.
+#[cfg_attr(test, derive(Clone, PartialEq, Eq))]
+pub(in error) enum ErrorKind {
+    /// An arbitrary error message.
+    Custom(String),
+    DuplicateField(FieldName),
+    MissingField(FieldName),
+    UnsupportedShape(DeriveInputShape),
+    UnknownField(ErrorUnknownField),
+    UnexpectedFormat(MetaFormat),
+    UnexpectedType(String),
+    UnknownValue(String),
+    TooFewItems(usize),
+    TooManyItems(usize),
+    /// A set of errors.
+    Multiple(Vec<Error>),
+
+    // TODO make this variant take `!` so it can't exist
+    #[doc(hidden)]
+    __NonExhaustive,
+}
+
+impl ErrorKind {
+    pub fn description(&self) -> &str {
+        use self::ErrorKind::*;
+
+        match *self {
+            Custom(ref s) => s,
+            DuplicateField(_) => "Duplicate field",
+            MissingField(_) => "Missing field",
+            UnknownField(_) => "Unexpected field",
+            UnsupportedShape(_) => "Unsupported shape",
+            UnexpectedFormat(_) => "Unexpected meta-item format",
+            UnexpectedType(_) => "Unexpected literal type",
+            UnknownValue(_) => "Unknown literal value",
+            TooFewItems(_) => "Too few items",
+            TooManyItems(_) => "Too many items",
+            Multiple(_) => "Multiple errors",
+            __NonExhaustive => unreachable!(),
+        }
+    }
+
+    /// Deeply counts the number of errors this item represents.
+    pub fn len(&self) -> usize {
+        if let ErrorKind::Multiple(ref items) = *self {
+            items.iter().map(Error::len).sum()
+        } else {
+            1
+        }
+    }
+}
+
+impl fmt::Display for ErrorKind {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        use self::ErrorKind::*;
+
+        match *self {
+            Custom(ref s) => s.fmt(f),
+            DuplicateField(ref field) => write!(f, "Duplicate field `{}`", field),
+            MissingField(ref field) => write!(f, "Missing field `{}`", field),
+            UnknownField(ref field) => field.fmt(f),
+            UnsupportedShape(ref shape) => write!(f, "Unsupported shape `{}`", shape),
+            UnexpectedFormat(ref format) => write!(f, "Unexpected meta-item format `{}`", format),
+            UnexpectedType(ref ty) => write!(f, "Unexpected literal type `{}`", ty),
+            UnknownValue(ref val) => write!(f, "Unknown literal value `{}`", val),
+            TooFewItems(ref min) => write!(f, "Too few items: Expected at least {}", min),
+            TooManyItems(ref max) => write!(f, "Too many items: Expected no more than {}", max),
+            Multiple(ref items) if items.len() == 1 => items[0].fmt(f),
+            Multiple(ref items) => {
+                write!(f, "Multiple errors: (")?;
+                let mut first = true;
+                for item in items {
+                    if !first {
+                        write!(f, ", ")?;
+                    } else {
+                        first = false;
+                    }
+
+                    item.fmt(f)?;
+                }
+
+                write!(f, ")")
+            }
+            __NonExhaustive => unreachable!(),
+        }
+    }
+}
+
+impl From<ErrorUnknownField> for ErrorKind {
+    fn from(err: ErrorUnknownField) -> Self {
+        ErrorKind::UnknownField(err)
+    }
+}
+
+/// An error for an unknown field, with a possible "did-you-mean" suggestion to get
+/// the user back on the right track.
+#[derive(Debug)]
+// Don't want to publicly commit to ErrorKind supporting equality yet, but
+// not having it makes testing very difficult.
+#[cfg_attr(test, derive(Clone, PartialEq, Eq))]
+pub(in error) struct ErrorUnknownField {
+    name: String,
+    did_you_mean: Option<String>,
+}
+
+impl ErrorUnknownField {
+    pub fn new<I: Into<String>>(name: I, did_you_mean: Option<String>) -> Self {
+        ErrorUnknownField {
+            name: name.into(),
+            did_you_mean,
+        }
+    }
+
+    pub fn with_alts<'a, T, I>(field: &str, alternates: I) -> Self
+    where
+        T: AsRef<str> + 'a,
+        I: IntoIterator<Item = &'a T>,
+    {
+        ErrorUnknownField::new(field, did_you_mean(field, alternates))
+    }
+
+    #[cfg(feature = "diagnostics")]
+    pub fn to_diagnostic(self, span: Option<::proc_macro2::Span>) -> ::proc_macro::Diagnostic {
+        let base = span
+            .unwrap_or_else(::proc_macro2::Span::call_site)
+            .unwrap()
+            .error(self.top_line());
+        match self.did_you_mean {
+            Some(alt_name) => base.help(format!("did you mean `{}`?", alt_name)),
+            None => base,
+        }
+    }
+
+    #[cfg(feature = "diagnostics")]
+    fn top_line(&self) -> String {
+        format!("Unknown field: `{}`", self.name)
+    }
+}
+
+impl From<String> for ErrorUnknownField {
+    fn from(name: String) -> Self {
+        ErrorUnknownField::new(name, None)
+    }
+}
+
+impl<'a> From<&'a str> for ErrorUnknownField {
+    fn from(name: &'a str) -> Self {
+        ErrorUnknownField::new(name, None)
+    }
+}
+
+impl fmt::Display for ErrorUnknownField {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "Unknown field: `{}`", self.name)?;
+
+        if let Some(ref did_you_mean) = self.did_you_mean {
+            write!(f, ". Did you mean `{}`?", did_you_mean)?;
+        }
+
+        Ok(())
+    }
+}
+
+#[cfg(feature = "suggestions")]
+fn did_you_mean<'a, T, I>(field: &str, alternates: I) -> Option<String>
+where
+    T: AsRef<str> + 'a,
+    I: IntoIterator<Item = &'a T>,
+{
+    let mut candidate: Option<(f64, &str)> = None;
+    for pv in alternates {
+        let confidence = ::strsim::jaro_winkler(field, pv.as_ref());
+        if confidence > 0.8 && (candidate.is_none() || (candidate.as_ref().unwrap().0 < confidence))
+        {
+            candidate = Some((confidence, pv.as_ref()));
+        }
+    }
+    match candidate {
+        None => None,
+        Some((_, candidate)) => Some(candidate.into()),
+    }
+}
+
+#[cfg(not(feature = "suggestions"))]
+fn did_you_mean<'a, T, I>(_field: &str, _alternates: I) -> Option<String>
+where
+    T: AsRef<str> + 'a,
+    I: IntoIterator<Item = &'a T>,
+{
+    None
+}
diff --git a/third_party/rust/darling_core/src/error/mod.rs b/third_party/rust/darling_core/src/error/mod.rs
new file mode 100644
index 000000000000..74e7f881c446
--- /dev/null
+++ b/third_party/rust/darling_core/src/error/mod.rs
@@ -0,0 +1,505 @@
+//! The `darling::Error` type and its internals.
+//!
+//! Error handling is one of the core values of `darling`; creating great errors is hard and
+//! never the reason that a proc-macro author started writing their crate. As a result, the
+//! `Error` type in `darling` tries to make adding span information, suggestions, and other
+//! help content easy when manually implementing `darling` traits, and automatic when deriving
+//! them.
+
+use proc_macro2::{Span, TokenStream};
+use std::error::Error as StdError;
+use std::fmt;
+use std::iter::{self, Iterator};
+use std::string::ToString;
+use std::vec;
+use syn::spanned::Spanned;
+use syn::{Lit, LitStr};
+
+mod kind;
+
+use self::kind::{ErrorKind, ErrorUnknownField};
+
+/// An alias of `Result` specific to attribute parsing.
+pub type Result<T> = ::std::result::Result<T, Error>;
+
+/// An error encountered during attribute parsing.
+///
+/// Given that most errors darling encounters represent code bugs in dependent crates,
+/// the internal structure of the error is deliberately opaque.
+#[derive(Debug)]
+#[cfg_attr(test, derive(Clone))]
+pub struct Error {
+    kind: ErrorKind,
+    locations: Vec<String>,
+    /// The span to highlight in the emitted diagnostic.
+    span: Option<Span>,
+}
+
+/// Error creation functions
+impl Error {
+    pub(in error) fn new(kind: ErrorKind) -> Self {
+        Error {
+            kind,
+            locations: Vec::new(),
+            span: None,
+        }
+    }
+
+    /// Creates a new error with a custom message.
+    pub fn custom<T: fmt::Display>(msg: T) -> Self {
+        Error::new(ErrorKind::Custom(msg.to_string()))
+    }
+
+    /// Creates a new error for a field that appears twice in the input.
+    pub fn duplicate_field(name: &str) -> Self {
+        Error::new(ErrorKind::DuplicateField(name.into()))
+    }
+
+    /// Creates a new error for a non-optional field that does not appear in the input.
+    pub fn missing_field(name: &str) -> Self {
+        Error::new(ErrorKind::MissingField(name.into()))
+    }
+
+    /// Creates a new error for a field name that appears in the input but does not correspond
+    /// to a known field.
+    pub fn unknown_field(name: &str) -> Self {
+        Error::new(ErrorKind::UnknownField(name.into()))
+    }
+
+    /// Creates a new error for a field name that appears in the input but does not correspond to
+    /// a known attribute. The second argument is the list of known attributes; if a similar name
+    /// is found that will be shown in the emitted error message.
+    pub fn unknown_field_with_alts<'a, T, I>(field: &str, alternates: I) -> Self
+    where
+        T: AsRef<str> + 'a,
+        I: IntoIterator<Item = &'a T>,
+    {
+        Error::new(ErrorUnknownField::with_alts(field, alternates).into())
+    }
+
+    /// Creates a new error for a struct or variant that does not adhere to the supported shape.
+    pub fn unsupported_shape(shape: &str) -> Self {
+        Error::new(ErrorKind::UnsupportedShape(shape.into()))
+    }
+
+    pub fn unsupported_format(format: &str) -> Self {
+        Error::new(ErrorKind::UnexpectedFormat(format.into()))
+    }
+
+    /// Creates a new error for a field which has an unexpected literal type.
+    pub fn unexpected_type(ty: &str) -> Self {
+        Error::new(ErrorKind::UnexpectedType(ty.into()))
+    }
+
+    /// Creates a new error for a field which has an unexpected literal type. This will automatically
+    /// extract the literal type name from the passed-in `Lit` and set the span to encompass only the
+    /// literal value.
+    ///
+    /// # Usage
+    /// This is most frequently used in overrides of the `FromMeta::from_value` method.
+    ///
+    /// ```rust
+    /// # // pretend darling_core is darling so the doc example looks correct.
+    /// # extern crate darling_core as darling;
+    /// # extern crate syn;
+    ///
+    /// use darling::{FromMeta, Error, Result};
+    /// use syn::{Lit, LitStr};
+    ///
+    /// pub struct Foo(String);
+    ///
+    /// impl FromMeta for Foo {
+    ///     fn from_value(value: &Lit) -> Result<Self> {
+    ///         if let Lit::Str(ref lit_str) = value {
+    ///             Ok(Foo(lit_str.value()))
+    ///         } else {
+    ///             Err(Error::unexpected_lit_type(value))
+    ///         }
+    ///     }
+    /// }
+    ///
+    /// # fn main() {}
+    /// ```
+    pub fn unexpected_lit_type(lit: &Lit) -> Self {
+        Error::unexpected_type(match *lit {
+            Lit::Str(_) => "string",
+            Lit::ByteStr(_) => "byte string",
+            Lit::Byte(_) => "byte",
+            Lit::Char(_) => "char",
+            Lit::Int(_) => "int",
+            Lit::Float(_) => "float",
+            Lit::Bool(_) => "bool",
+            Lit::Verbatim(_) => "verbatim",
+        })
+        .with_span(lit)
+    }
+
+    /// Creates a new error for a value which doesn't match a set of expected literals.
+    pub fn unknown_value(value: &str) -> Self {
+        Error::new(ErrorKind::UnknownValue(value.into()))
+    }
+
+    /// Creates a new error for a list which did not get enough items to proceed.
+    pub fn too_few_items(min: usize) -> Self {
+        Error::new(ErrorKind::TooFewItems(min))
+    }
+
+    /// Creates a new error when a list got more items than it supports. The `max` argument
+    /// is the largest number of items the receiver could accept.
+    pub fn too_many_items(max: usize) -> Self {
+        Error::new(ErrorKind::TooManyItems(max))
+    }
+
+    /// Bundle a set of multiple errors into a single `Error` instance.
+    ///
+    /// # Panics
+    /// This function will panic if `errors.is_empty() == true`.
+    pub fn multiple(mut errors: Vec<Error>) -> Self {
+        if errors.len() > 1 {
+            Error::new(ErrorKind::Multiple(errors))
+        } else if errors.len() == 1 {
+            errors
+                .pop()
+                .expect("Error array of length 1 has a first item")
+        } else {
+            panic!("Can't deal with 0 errors")
+        }
+    }
+}
+
+impl Error {
+    /// Create a new error about a literal string that doesn't match a set of known
+    /// or permissible values. This function can be made public if the API proves useful
+    /// beyond impls for `syn` types.
+    pub(crate) fn unknown_lit_str_value(value: &LitStr) -> Self {
+        Error::unknown_value(&value.value()).with_span(value)
+    }
+}
+
+/// Error instance methods
+impl Error {
+    /// Check if this error is associated with a span in the token stream.
+    pub fn has_span(&self) -> bool {
+        self.span.is_some()
+    }
+
+    /// Override the source code location of this error with a new one.
+    #[deprecated(
+        since = "0.8.3",
+        note = "Callers should not broaden error spans. Use with_span instead."
+    )]
+    pub fn set_span(&mut self, span: Span) {
+        self.span = Some(span)
+    }
+
+    /// Tie a span to the error if none is already present. This is used in `darling::FromMeta`
+    /// and other traits to attach errors to the most specific possible location in the input
+    /// source code.
+    ///
+    /// All `darling`-built impls, either from the crate or from the proc macro, will call this
+    /// when appropriate during parsing, so it should not be necessary to call this unless you have
+    /// overridden:
+    ///
+    /// * `FromMeta::from_meta`
+    /// * `FromMeta::from_nested_meta`
+    /// * `FromMeta::from_value`
+    pub fn with_span<T: Spanned>(mut self, node: &T) -> Self {
+        if !self.has_span() {
+            self.span = Some(node.span());
+        }
+
+        self
+    }
+
+    /// Recursively converts a tree of errors to a flattened list.
+    pub fn flatten(self) -> Self {
+        Error::multiple(self.into_vec())
+    }
+
+    fn into_vec(self) -> Vec<Self> {
+        if let ErrorKind::Multiple(errors) = self.kind {
+            let mut flat = Vec::new();
+            for error in errors {
+                flat.extend(error.prepend_at(self.locations.clone()).into_vec());
+            }
+
+            flat
+        } else {
+            vec![self]
+        }
+    }
+
+    /// Adds a location to the error, such as a field or variant.
+    /// Locations must be added in reverse order of specificity.
+    pub fn at<T: fmt::Display>(mut self, location: T) -> Self {
+        self.locations.insert(0, location.to_string());
+        self
+    }
+
+    /// Gets the number of individual errors in this error.
+    ///
+    /// This function never returns `0`, as it's impossible to construct
+    /// a multi-error from an empty `Vec`.
+    pub fn len(&self) -> usize {
+        self.kind.len()
+    }
+
+    /// Adds a location chain to the head of the error's existing locations.
+    fn prepend_at(mut self, mut locations: Vec<String>) -> Self {
+        if !locations.is_empty() {
+            locations.extend(self.locations);
+            self.locations = locations;
+        }
+
+        self
+    }
+
+    /// Gets the location slice.
+    #[cfg(test)]
+    pub(crate) fn location(&self) -> Vec<&str> {
+        self.locations.iter().map(|i| i.as_str()).collect()
+    }
+
+    /// Write this error and any children as compile errors into a `TokenStream` to
+    /// be returned by the proc-macro.
+    ///
+    /// The behavior of this method will be slightly different if the `diagnostics` feature
+    /// is enabled: In that case, the diagnostics will be emitted immediately by this call,
+    /// and an empty `TokenStream` will be returned.
+    ///
+    /// Return these tokens unmodified to avoid disturbing the attached span information.
+    ///
+    /// # Usage
+    /// ```rust,ignore
+    /// // in your proc-macro function
+    /// let opts = match MyOptions::from_derive_input(&ast) {
+    ///     Ok(val) => val,
+    ///     Err(err) => {
+    ///         return err.write_errors();
+    ///     }
+    /// }
+    /// ```
+    pub fn write_errors(self) -> TokenStream {
+        #[cfg(feature = "diagnostics")]
+        {
+            self.emit();
+            quote!()
+        }
+
+        #[cfg(not(feature = "diagnostics"))]
+        {
+            self.flatten()
+                .into_iter()
+                .map(|e| e.single_to_syn_error().to_compile_error())
+                .collect()
+        }
+    }
+
+    #[cfg(not(feature = "diagnostics"))]
+    fn single_to_syn_error(self) -> ::syn::Error {
+        match self.span {
+            Some(span) => ::syn::Error::new(span, self.kind),
+            None => ::syn::Error::new(Span::call_site(), self),
+        }
+    }
+
+    #[cfg(feature = "diagnostics")]
+    fn single_to_diagnostic(self) -> ::proc_macro::Diagnostic {
+        use proc_macro::{Diagnostic, Level};
+
+        // Delegate to dedicated error formatters when applicable.
+        //
+        // If span information is available, don't include the error property path
+        // since it's redundant and not consistent with native compiler diagnostics.
+        match self.kind {
+            ErrorKind::UnknownField(euf) => euf.to_diagnostic(self.span),
+            _ => match self.span {
+                Some(span) => span.unwrap().error(self.kind.to_string()),
+                None => Diagnostic::new(Level::Error, self.to_string()),
+            },
+        }
+    }
+
+    /// Transform this error and its children into a list of compiler diagnostics
+    /// and emit them. If the `Error` has associated span information, the diagnostics
+    /// will identify the correct location in source code automatically.
+    ///
+    /// # Stability
+    /// This is only available on `nightly` until the compiler `proc_macro_diagnostic`
+    /// feature stabilizes. Until then, it may break at any time.
+    #[cfg(feature = "diagnostics")]
+    pub fn emit(self) {
+        for error in self.flatten() {
+            error.single_to_diagnostic().emit()
+        }
+    }
+
+    /// Transform the error into a compiler diagnostic and - if the diagnostic points to
+    /// a specific code location - add a spanned help child diagnostic that points to the
+    /// parent derived trait.
+    ///
+    /// This is experimental and therefore not exposed outside the crate.
+    #[cfg(feature = "diagnostics")]
+    #[allow(dead_code)]
+    fn emit_with_macro_help_span(self) {
+        use proc_macro::Diagnostic;
+
+        for error in self.flatten() {
+            let needs_help = error.has_span();
+            let diagnostic = error.single_to_diagnostic();
+            Diagnostic::emit(if needs_help {
+                diagnostic.span_help(
+                    Span::call_site().unwrap(),
+                    "Encountered as part of this derive-mode-macro",
+                )
+            } else {
+                diagnostic
+            })
+        }
+    }
+}
+
+impl StdError for Error {
+    fn description(&self) -> &str {
+        &self.kind.description()
+    }
+
+    fn cause(&self) -> Option<&StdError> {
+        None
+    }
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", self.kind)?;
+        if !self.locations.is_empty() {
+            write!(f, " at {}", self.locations.join("/"))?;
+        }
+
+        Ok(())
+    }
+}
+
+// Don't want to publicly commit to Error supporting equality yet, but
+// not having it makes testing very difficult. Note that spans are not
+// considered for equality since that would break testing in most cases.
+#[cfg(test)]
+impl PartialEq for Error {
+    fn eq(&self, other: &Self) -> bool {
+        self.kind == other.kind && self.locations == other.locations
+    }
+}
+
+#[cfg(test)]
+impl Eq for Error {}
+
+impl IntoIterator for Error {
+    type Item = Error;
+    type IntoIter = IntoIter;
+
+    fn into_iter(self) -> IntoIter {
+        if let ErrorKind::Multiple(errors) = self.kind {
+            IntoIter {
+                inner: IntoIterEnum::Multiple(errors.into_iter()),
+            }
+        } else {
+            IntoIter {
+                inner: IntoIterEnum::Single(iter::once(self)),
+            }
+        }
+    }
+}
+
+enum IntoIterEnum {
+    Single(iter::Once<Error>),
+    Multiple(vec::IntoIter<Error>),
+}
+
+impl Iterator for IntoIterEnum {
+    type Item = Error;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        match *self {
+            IntoIterEnum::Single(ref mut content) => content.next(),
+            IntoIterEnum::Multiple(ref mut content) => content.next(),
+        }
+    }
+}
+
+/// An iterator that moves out of an `Error`.
+pub struct IntoIter {
+    inner: IntoIterEnum,
+}
+
+impl Iterator for IntoIter {
+    type Item = Error;
+
+    fn next(&mut self) -> Option<Error> {
+        self.inner.next()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Error;
+
+    #[test]
+    fn flatten_noop() {
+        let err = Error::duplicate_field("hello").at("world");
+        assert_eq!(err.clone().flatten(), err);
+    }
+
+    #[test]
+    fn flatten_simple() {
+        let err = Error::multiple(vec![
+            Error::unknown_field("hello").at("world"),
+            Error::missing_field("hell_no").at("world"),
+        ])
+        .at("foo")
+        .flatten();
+
+        assert!(err.location().is_empty());
+
+        let mut err_iter = err.into_iter();
+
+        let first = err_iter.next();
+        assert!(first.is_some());
+        assert_eq!(first.unwrap().location(), vec!["foo", "world"]);
+
+        let second = err_iter.next();
+        assert!(second.is_some());
+
+        assert_eq!(second.unwrap().location(), vec!["foo", "world"]);
+
+        assert!(err_iter.next().is_none());
+    }
+
+    #[test]
+    fn len_single() {
+        let err = Error::duplicate_field("hello");
+        assert_eq!(1, err.len());
+    }
+
+    #[test]
+    fn len_multiple() {
+        let err = Error::multiple(vec![
+            Error::duplicate_field("hello"),
+            Error::missing_field("hell_no"),
+        ]);
+        assert_eq!(2, err.len());
+    }
+
+    #[test]
+    fn len_nested() {
+        let err = Error::multiple(vec![
+            Error::duplicate_field("hello"),
+            Error::multiple(vec![
+                Error::duplicate_field("hi"),
+                Error::missing_field("bye"),
+                Error::multiple(vec![Error::duplicate_field("whatsup")]),
+            ]),
+        ]);
+
+        assert_eq!(4, err.len());
+    }
+}
diff --git a/third_party/rust/darling_core/src/from_meta.rs b/third_party/rust/darling_core/src/from_meta.rs
index dc03f993b5c3..cce4d7d50635 100644
--- a/third_party/rust/darling_core/src/from_meta.rs
+++ b/third_party/rust/darling_core/src/from_meta.rs
@@ -1,5 +1,6 @@
 use std::cell::RefCell;
 use std::collections::hash_map::{Entry, HashMap};
+use std::hash::BuildHasher;
 use std::rc::Rc;
 use std::sync::atomic::AtomicBool;
 use std::sync::Arc;
@@ -26,6 +27,10 @@ use {Error, Result};
 /// * As a string literal, e.g. `foo = "hello"`.
 /// * As a raw string literal, e.g. `foo = r#"hello "world""#`.
 ///
+/// ## Number
+/// * As a string literal, e.g. `foo = "-25"`.
+/// * As an unquoted positive value, e.g. `foo = 404`. Negative numbers must be in quotation marks.
+///
 /// ## ()
 /// * Word with no value specified, e.g. `foo`. This is best used with `Option`.
 ///   See `darling::util::Flag` for a more strongly-typed alternative.
@@ -38,26 +43,34 @@ use {Error, Result};
 ///   parse attempt.
 pub trait FromMeta: Sized {
     fn from_nested_meta(item: &NestedMeta) -> Result<Self> {
-        match *item {
+        (match *item {
             NestedMeta::Literal(ref lit) => Self::from_value(lit),
             NestedMeta::Meta(ref mi) => Self::from_meta(mi),
-        }
+        })
+        .map_err(|e| e.with_span(item))
     }
 
     /// Create an instance from a `syn::Meta` by dispatching to the format-appropriate
     /// trait function. This generally should not be overridden by implementers.
+    ///
+    /// # Error Spans
+    /// If this method is overridden and can introduce errors that weren't passed up from
+    /// other `from_meta` calls, the override must call `with_span` on the error using the
+    /// `item` to make sure that the emitted diagnostic points to the correct location in
+    /// source code.
     fn from_meta(item: &Meta) -> Result<Self> {
-        match *item {
+        (match *item {
             Meta::Word(_) => Self::from_word(),
             Meta::List(ref value) => Self::from_list(
                 &value
                     .nested
-                    .clone()
-                    .into_iter()
+                    .iter()
+                    .cloned()
                     .collect::<Vec<syn::NestedMeta>>()[..],
             ),
             Meta::NameValue(ref value) => Self::from_value(&value.lit),
-        }
+        })
+        .map_err(|e| e.with_span(item))
     }
 
     /// Create an instance from the presence of the word in the attribute with no
@@ -75,12 +88,17 @@ pub trait FromMeta: Sized {
     /// Create an instance from a literal value of either `foo = "bar"` or `foo("bar")`.
     /// This dispatches to the appropriate method based on the type of literal encountered,
     /// and generally should not be overridden by implementers.
+    ///
+    /// # Error Spans
+    /// If this method is overridden, the override must make sure to add `value`'s span
+    /// information to the returned error by calling `with_span(value)` on the `Error` instance.
     fn from_value(value: &Lit) -> Result<Self> {
-        match *value {
+        (match *value {
             Lit::Bool(ref b) => Self::from_bool(b.value),
             Lit::Str(ref s) => Self::from_string(&s.value()),
-            ref _other => Err(Error::unexpected_type("other")),
-        }
+            _ => Err(Error::unexpected_lit_type(value)),
+        })
+        .map_err(|e| e.with_span(value))
     }
 
     /// Create an instance from a char literal in a value position.
@@ -126,7 +144,9 @@ impl FromMeta for bool {
 
 impl FromMeta for AtomicBool {
     fn from_meta(mi: &Meta) -> Result<Self> {
-        FromMeta::from_meta(mi).map(AtomicBool::new)
+        FromMeta::from_meta(mi)
+            .map(AtomicBool::new)
+            .map_err(|e| e.with_span(mi))
     }
 }
 
@@ -136,84 +156,127 @@ impl FromMeta for String {
     }
 }
 
-impl FromMeta for u8 {
-    fn from_string(s: &str) -> Result<Self> {
-        s.parse().map_err(|_| Error::unknown_value(s))
-    }
+/// Generate an impl of `FromMeta` that will accept strings which parse to numbers or
+/// integer literals.
+macro_rules! from_meta_num {
+    ($ty:ident) => {
+        impl FromMeta for $ty {
+            fn from_string(s: &str) -> Result<Self> {
+                s.parse().map_err(|_| Error::unknown_value(s))
+            }
+
+            fn from_value(value: &Lit) -> Result<Self> {
+                (match *value {
+                    Lit::Str(ref s) => Self::from_string(&s.value()),
+                    Lit::Int(ref s) => Ok(s.value() as $ty),
+                    _ => Err(Error::unexpected_lit_type(value)),
+                })
+                .map_err(|e| e.with_span(value))
+            }
+        }
+    };
 }
 
-impl FromMeta for u16 {
-    fn from_string(s: &str) -> Result<Self> {
-        s.parse().map_err(|_| Error::unknown_value(s))
-    }
+from_meta_num!(u8);
+from_meta_num!(u16);
+from_meta_num!(u32);
+from_meta_num!(u64);
+from_meta_num!(usize);
+from_meta_num!(i8);
+from_meta_num!(i16);
+from_meta_num!(i32);
+from_meta_num!(i64);
+from_meta_num!(isize);
+
+/// Generate an impl of `FromMeta` that will accept strings which parse to floats or
+/// float literals.
+macro_rules! from_meta_float {
+    ($ty:ident) => {
+        impl FromMeta for $ty {
+            fn from_string(s: &str) -> Result<Self> {
+                s.parse().map_err(|_| Error::unknown_value(s))
+            }
+
+            fn from_value(value: &Lit) -> Result<Self> {
+                (match *value {
+                    Lit::Str(ref s) => Self::from_string(&s.value()),
+                    Lit::Float(ref s) => Ok(s.value() as $ty),
+                    _ => Err(Error::unexpected_lit_type(value)),
+                })
+                .map_err(|e| e.with_span(value))
+            }
+        }
+    };
 }
 
-impl FromMeta for u32 {
-    fn from_string(s: &str) -> Result<Self> {
-        s.parse().map_err(|_| Error::unknown_value(s))
-    }
-}
-
-impl FromMeta for u64 {
-    fn from_string(s: &str) -> Result<Self> {
-        s.parse().map_err(|_| Error::unknown_value(s))
-    }
-}
-
-impl FromMeta for usize {
-    fn from_string(s: &str) -> Result<Self> {
-        s.parse().map_err(|_| Error::unknown_value(s))
-    }
-}
-
-impl FromMeta for i8 {
-    fn from_string(s: &str) -> Result<Self> {
-        s.parse().map_err(|_| Error::unknown_value(s))
-    }
-}
-
-impl FromMeta for i16 {
-    fn from_string(s: &str) -> Result<Self> {
-        s.parse().map_err(|_| Error::unknown_value(s))
-    }
-}
-
-impl FromMeta for i32 {
-    fn from_string(s: &str) -> Result<Self> {
-        s.parse().map_err(|_| Error::unknown_value(s))
-    }
-}
-
-impl FromMeta for i64 {
-    fn from_string(s: &str) -> Result<Self> {
-        s.parse().map_err(|_| Error::unknown_value(s))
-    }
-}
-
-impl FromMeta for isize {
-    fn from_string(s: &str) -> Result<Self> {
-        s.parse().map_err(|_| Error::unknown_value(s))
-    }
-}
+from_meta_float!(f32);
+from_meta_float!(f64);
 
+/// Parsing support for identifiers. This attempts to preserve span information
+/// when available, but also supports parsing strings with the call site as the
+/// emitted span.
 impl FromMeta for syn::Ident {
     fn from_string(value: &str) -> Result<Self> {
         Ok(syn::Ident::new(value, ::proc_macro2::Span::call_site()))
     }
+
+    fn from_value(value: &Lit) -> Result<Self> {
+        if let Lit::Str(ref ident) = *value {
+            ident
+                .parse()
+                .map_err(|_| Error::unknown_lit_str_value(ident))
+        } else {
+            Err(Error::unexpected_lit_type(value))
+        }
+    }
 }
 
+/// Parsing support for paths. This attempts to preserve span information when available,
+/// but also supports parsing strings with the call site as the emitted span.
 impl FromMeta for syn::Path {
     fn from_string(value: &str) -> Result<Self> {
         syn::parse_str(value).map_err(|_| Error::unknown_value(value))
     }
-}
-/*
-impl FromMeta for syn::TypeParamBound {
-    fn from_string(value: &str) -> Result<Self> {
-        Ok(syn::TypeParamBound::from(value))
+
+    fn from_value(value: &Lit) -> Result<Self> {
+        if let Lit::Str(ref path_str) = *value {
+            path_str
+                .parse()
+                .map_err(|_| Error::unknown_lit_str_value(path_str))
+        } else {
+            Err(Error::unexpected_lit_type(value))
+        }
     }
 }
-*/
+
+impl FromMeta for syn::Lit {
+    fn from_value(value: &Lit) -> Result<Self> {
+        Ok(value.clone())
+    }
+}
+
+macro_rules! from_meta_lit {
+    ($impl_ty:path, $lit_variant:path) => {
+        impl FromMeta for $impl_ty {
+            fn from_value(value: &Lit) -> Result<Self> {
+                if let $lit_variant(ref value) = *value {
+                    Ok(value.clone())
+                } else {
+                    Err(Error::unexpected_lit_type(value))
+                }
+            }
+        }
+    };
+}
+
+from_meta_lit!(syn::LitInt, Lit::Int);
+from_meta_lit!(syn::LitFloat, Lit::Float);
+from_meta_lit!(syn::LitStr, Lit::Str);
+from_meta_lit!(syn::LitByte, Lit::Byte);
+from_meta_lit!(syn::LitByteStr, Lit::ByteStr);
+from_meta_lit!(syn::LitChar, Lit::Char);
+from_meta_lit!(syn::LitBool, Lit::Bool);
+from_meta_lit!(syn::LitVerbatim, Lit::Verbatim);
 
 impl FromMeta for syn::Meta {
     fn from_meta(value: &syn::Meta) -> Result<Self> {
@@ -286,14 +349,20 @@ impl<T: FromMeta> FromMeta for RefCell<T> {
     }
 }
 
-impl<V: FromMeta> FromMeta for HashMap<String, V> {
+impl<V: FromMeta, S: BuildHasher + Default> FromMeta for HashMap<String, V, S> {
     fn from_list(nested: &[syn::NestedMeta]) -> Result<Self> {
-        let mut map = HashMap::with_capacity(nested.len());
+        let mut map = HashMap::with_capacity_and_hasher(nested.len(), Default::default());
         for item in nested {
             if let syn::NestedMeta::Meta(ref inner) = *item {
                 match map.entry(inner.name().to_string()) {
-                    Entry::Occupied(_) => return Err(Error::duplicate_field(&inner.name().to_string())),
+                    Entry::Occupied(_) => {
+                        return Err(
+                            Error::duplicate_field(&inner.name().to_string()).with_span(inner)
+                        );
+                    }
                     Entry::Vacant(entry) => {
+                        // In the error case, extend the error's path, but assume the inner `from_meta`
+                        // set the span, and that subsequently we don't have to.
                         entry.insert(FromMeta::from_meta(inner).map_err(|e| e.at(inner.name()))?);
                     }
                 }
@@ -311,7 +380,7 @@ mod tests {
     use proc_macro2::TokenStream;
     use syn;
 
-    use {FromMeta, Result};
+    use {Error, FromMeta, Result};
 
     /// parse a string as a syn::Meta instance.
     fn pm(tokens: TokenStream) -> ::std::result::Result<syn::Meta, String> {
@@ -356,6 +425,24 @@ mod tests {
     fn number_succeeds() {
         assert_eq!(fm::<u8>(quote!(ignore = "2")), 2u8);
         assert_eq!(fm::<i16>(quote!(ignore = "-25")), -25i16);
+        assert_eq!(fm::<f64>(quote!(ignore = "1.4e10")), 1.4e10);
+    }
+
+    #[test]
+    fn int_without_quotes() {
+        assert_eq!(fm::<u8>(quote!(ignore = 2)), 2u8);
+        assert_eq!(fm::<u16>(quote!(ignore = 255)), 255u16);
+        assert_eq!(fm::<u32>(quote!(ignore = 5000)), 5000u32);
+
+        // Check that we aren't tripped up by incorrect suffixes
+        assert_eq!(fm::<u32>(quote!(ignore = 5000i32)), 5000u32);
+    }
+
+    #[test]
+    fn float_without_quotes() {
+        assert_eq!(fm::<f32>(quote!(ignore = 2.)), 2.0f32);
+        assert_eq!(fm::<f32>(quote!(ignore = 2.0)), 2.0f32);
+        assert_eq!(fm::<f64>(quote!(ignore = 1.4e10)), 1.4e10f64);
     }
 
     #[test]
@@ -386,6 +473,21 @@ mod tests {
         );
     }
 
+    /// Check that a `HashMap` cannot have duplicate keys, and that the generated error
+    /// is assigned a span to correctly target the diagnostic message.
+    #[test]
+    fn hash_map_duplicate() {
+        use std::collections::HashMap;
+
+        let err: Result<HashMap<String, bool>> =
+            FromMeta::from_meta(&pm(quote!(ignore(hello, hello = false))).unwrap());
+
+        let err = err.expect_err("Duplicate keys in HashMap should error");
+
+        assert!(err.has_span());
+        assert_eq!(err.to_string(), Error::duplicate_field("hello").to_string());
+    }
+
     /// Tests that fallible parsing will always produce an outer `Ok` (from `fm`),
     /// and will accurately preserve the inner contents.
     #[test]
diff --git a/third_party/rust/darling_core/src/lib.rs b/third_party/rust/darling_core/src/lib.rs
index 5a45bae321da..4cb73a42d03b 100644
--- a/third_party/rust/darling_core/src/lib.rs
+++ b/third_party/rust/darling_core/src/lib.rs
@@ -1,14 +1,17 @@
 #![recursion_limit = "256"]
+#![cfg_attr(feature = "diagnostics", feature(proc_macro_diagnostic))]
 
 #[macro_use]
 extern crate quote;
-
 #[macro_use]
 extern crate syn;
-extern crate proc_macro2;
-
 extern crate fnv;
 extern crate ident_case;
+#[cfg(feature = "diagnostics")]
+extern crate proc_macro;
+extern crate proc_macro2;
+#[cfg(feature = "suggestions")]
+extern crate strsim;
 
 #[macro_use]
 mod macros_private;
@@ -17,6 +20,7 @@ mod macros_public;
 
 pub mod ast;
 pub mod codegen;
+pub mod derive;
 pub mod error;
 mod from_derive_input;
 mod from_field;
@@ -40,4 +44,4 @@ pub use from_variant::FromVariant;
 
 // Re-export tokenizer
 #[doc(hidden)]
-pub use quote::ToTokens;
\ No newline at end of file
+pub use quote::ToTokens;
diff --git a/third_party/rust/darling_core/src/options/core.rs b/third_party/rust/darling_core/src/options/core.rs
index adce7513c291..f4cd834c0bad 100644
--- a/third_party/rust/darling_core/src/options/core.rs
+++ b/third_party/rust/darling_core/src/options/core.rs
@@ -4,6 +4,7 @@ use syn;
 use ast::{Data, Fields, Style};
 use codegen;
 use options::{DefaultExpression, InputField, InputVariant, ParseAttribute, ParseData};
+use util::Flag;
 use {Error, FromMeta, Result};
 
 /// A struct or enum which should have `FromMeta` or `FromDeriveInput` implementations
@@ -33,6 +34,9 @@ pub struct Core {
 
     /// The custom bound to apply to the generated impl
     pub bound: Option<Vec<syn::WherePredicate>>,
+
+    /// Whether or not unknown fields should produce an error at compilation time.
+    pub allow_unknown_fields: Flag,
 }
 
 impl Core {
@@ -52,6 +56,7 @@ impl Core {
             },
             map: Default::default(),
             bound: Default::default(),
+            allow_unknown_fields: Default::default(),
         }
     }
 
@@ -70,7 +75,7 @@ impl ParseAttribute for Core {
         match mi.name().to_string().as_str() {
             "default" => {
                 if self.default.is_some() {
-                    Err(Error::duplicate_field("default"))
+                    Err(Error::duplicate_field("default").with_span(mi))
                 } else {
                     self.default = FromMeta::from_meta(mi)?;
                     Ok(())
@@ -84,7 +89,7 @@ impl ParseAttribute for Core {
             }
             "map" => {
                 if self.map.is_some() {
-                    Err(Error::duplicate_field("map"))
+                    Err(Error::duplicate_field("map").with_span(mi))
                 } else {
                     self.map = FromMeta::from_meta(mi)?;
                     Ok(())
@@ -94,7 +99,15 @@ impl ParseAttribute for Core {
                 self.bound = FromMeta::from_meta(mi)?;
                 Ok(())
             }
-            n => Err(Error::unknown_field(n.as_ref())),
+            "allow_unknown_fields" => {
+                if self.allow_unknown_fields.is_some() {
+                    Err(Error::duplicate_field("allow_unknown_fields").with_span(mi))
+                } else {
+                    self.allow_unknown_fields = FromMeta::from_meta(mi)?;
+                    Ok(())
+                }
+            }
+            n => Err(Error::unknown_field(n).with_span(mi)),
         }
     }
 }
@@ -133,13 +146,15 @@ impl<'a> From<&'a Core> for codegen::TraitImpl<'a> {
         codegen::TraitImpl {
             ident: &v.ident,
             generics: &v.generics,
-            data: v.data
+            data: v
+                .data
                 .as_ref()
                 .map_struct_fields(InputField::as_codegen_field)
                 .map_enum_variants(|variant| variant.as_codegen_variant(&v.ident)),
             default: v.as_codegen_default(),
             map: v.map.as_ref(),
             bound: v.bound.as_ref().map(|i| i.as_slice()),
+            allow_unknown_fields: v.allow_unknown_fields.into(),
         }
     }
 }
diff --git a/third_party/rust/darling_core/src/options/from_derive.rs b/third_party/rust/darling_core/src/options/from_derive.rs
index 23664bd12dec..25eefd6702a1 100644
--- a/third_party/rust/darling_core/src/options/from_derive.rs
+++ b/third_party/rust/darling_core/src/options/from_derive.rs
@@ -1,6 +1,8 @@
+use proc_macro2::TokenStream;
+use quote::ToTokens;
 use syn::{self, Ident};
 
-use codegen;
+use codegen::FromDeriveInputImpl;
 use options::{OuterFrom, ParseAttribute, ParseData, Shape};
 use {FromMeta, Result};
 
@@ -27,8 +29,9 @@ impl FdiOptions {
             generics: Default::default(),
             data: Default::default(),
             supports: Default::default(),
-        }).parse_attributes(&di.attrs)?
-            .parse_body(&di.data)
+        })
+        .parse_attributes(&di.attrs)?
+        .parse_body(&di.data)
     }
 }
 
@@ -74,9 +77,9 @@ impl ParseData for FdiOptions {
     }
 }
 
-impl<'a> From<&'a FdiOptions> for codegen::FromDeriveInputImpl<'a> {
+impl<'a> From<&'a FdiOptions> for FromDeriveInputImpl<'a> {
     fn from(v: &'a FdiOptions) -> Self {
-        codegen::FromDeriveInputImpl {
+        FromDeriveInputImpl {
             base: (&v.base.container).into(),
             attr_names: &v.base.attr_names,
             from_ident: v.base.from_ident,
@@ -90,3 +93,9 @@ impl<'a> From<&'a FdiOptions> for codegen::FromDeriveInputImpl<'a> {
         }
     }
 }
+
+impl ToTokens for FdiOptions {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
+        FromDeriveInputImpl::from(self).to_tokens(tokens)
+    }
+}
diff --git a/third_party/rust/darling_core/src/options/from_field.rs b/third_party/rust/darling_core/src/options/from_field.rs
index 215bdb0f925f..266d1fa043ab 100644
--- a/third_party/rust/darling_core/src/options/from_field.rs
+++ b/third_party/rust/darling_core/src/options/from_field.rs
@@ -1,3 +1,5 @@
+use proc_macro2::TokenStream;
+use quote::ToTokens;
 use syn::{self, Ident};
 
 use codegen::FromFieldImpl;
@@ -17,8 +19,9 @@ impl FromFieldOptions {
             base: OuterFrom::start(di),
             vis: Default::default(),
             ty: Default::default(),
-        }).parse_attributes(&di.attrs)?
-            .parse_body(&di.data)
+        })
+        .parse_attributes(&di.attrs)?
+        .parse_body(&di.data)
     }
 }
 
@@ -68,3 +71,9 @@ impl<'a> From<&'a FromFieldOptions> for FromFieldImpl<'a> {
         }
     }
 }
+
+impl ToTokens for FromFieldOptions {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
+        FromFieldImpl::from(self).to_tokens(tokens)
+    }
+}
diff --git a/third_party/rust/darling_core/src/options/from_meta.rs b/third_party/rust/darling_core/src/options/from_meta.rs
index c8d40c48ce64..d9088562a599 100644
--- a/third_party/rust/darling_core/src/options/from_meta.rs
+++ b/third_party/rust/darling_core/src/options/from_meta.rs
@@ -1,6 +1,8 @@
+use proc_macro2::TokenStream;
+use quote::ToTokens;
 use syn;
 
-use codegen;
+use codegen::FromMetaImpl;
 use options::{Core, ParseAttribute, ParseData};
 use Result;
 
@@ -12,8 +14,9 @@ impl FromMetaOptions {
     pub fn new(di: &syn::DeriveInput) -> Result<Self> {
         (FromMetaOptions {
             base: Core::start(di),
-        }).parse_attributes(&di.attrs)?
-            .parse_body(&di.data)
+        })
+        .parse_attributes(&di.attrs)?
+        .parse_body(&di.data)
     }
 }
 
@@ -33,10 +36,16 @@ impl ParseData for FromMetaOptions {
     }
 }
 
-impl<'a> From<&'a FromMetaOptions> for codegen::FromMetaImpl<'a> {
+impl<'a> From<&'a FromMetaOptions> for FromMetaImpl<'a> {
     fn from(v: &'a FromMetaOptions) -> Self {
-        codegen::FromMetaImpl {
+        FromMetaImpl {
             base: (&v.base).into(),
         }
     }
 }
+
+impl ToTokens for FromMetaOptions {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
+        FromMetaImpl::from(self).to_tokens(tokens)
+    }
+}
diff --git a/third_party/rust/darling_core/src/options/from_type_param.rs b/third_party/rust/darling_core/src/options/from_type_param.rs
index e6735efa95f3..701ca1b83eee 100644
--- a/third_party/rust/darling_core/src/options/from_type_param.rs
+++ b/third_party/rust/darling_core/src/options/from_type_param.rs
@@ -1,3 +1,5 @@
+use proc_macro2::TokenStream;
+use quote::ToTokens;
 use syn::{self, Ident};
 
 use codegen::FromTypeParamImpl;
@@ -17,8 +19,9 @@ impl FromTypeParamOptions {
             base: OuterFrom::start(di),
             bounds: None,
             default: None,
-        }).parse_attributes(&di.attrs)?
-            .parse_body(&di.data)
+        })
+        .parse_attributes(&di.attrs)?
+        .parse_body(&di.data)
     }
 }
 
@@ -68,3 +71,9 @@ impl<'a> From<&'a FromTypeParamOptions> for FromTypeParamImpl<'a> {
         }
     }
 }
+
+impl ToTokens for FromTypeParamOptions {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
+        FromTypeParamImpl::from(self).to_tokens(tokens)
+    }
+}
diff --git a/third_party/rust/darling_core/src/options/from_variant.rs b/third_party/rust/darling_core/src/options/from_variant.rs
index bc1cf781781e..9f36f85378df 100644
--- a/third_party/rust/darling_core/src/options/from_variant.rs
+++ b/third_party/rust/darling_core/src/options/from_variant.rs
@@ -1,3 +1,5 @@
+use proc_macro2::TokenStream;
+use quote::ToTokens;
 use syn::{DeriveInput, Field, Ident, Meta};
 
 use codegen::FromVariantImpl;
@@ -17,8 +19,9 @@ impl FromVariantOptions {
             base: OuterFrom::start(di),
             fields: Default::default(),
             supports: Default::default(),
-        }).parse_attributes(&di.attrs)?
-            .parse_body(&di.data)
+        })
+        .parse_attributes(&di.attrs)?
+        .parse_body(&di.data)
     }
 }
 
@@ -66,3 +69,9 @@ impl ParseData for FromVariantOptions {
         }
     }
 }
+
+impl ToTokens for FromVariantOptions {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
+        FromVariantImpl::from(self).to_tokens(tokens)
+    }
+}
diff --git a/third_party/rust/darling_core/src/options/input_field.rs b/third_party/rust/darling_core/src/options/input_field.rs
index 4ba48910d865..232ab221c137 100644
--- a/third_party/rust/darling_core/src/options/input_field.rs
+++ b/third_party/rust/darling_core/src/options/input_field.rs
@@ -1,3 +1,5 @@
+use std::borrow::Cow;
+
 use syn;
 
 use codegen;
@@ -24,14 +26,16 @@ impl InputField {
     pub fn as_codegen_field<'a>(&'a self) -> codegen::Field<'a> {
         codegen::Field {
             ident: &self.ident,
-            name_in_attr: self.attr_name
-                .clone()
-                .unwrap_or_else(|| self.ident.to_string()),
+            name_in_attr: self
+                .attr_name
+                .as_ref()
+                .map_or_else(|| Cow::Owned(self.ident.to_string()), Cow::Borrowed),
             ty: &self.ty,
             default_expression: self.as_codegen_default(),
-            with_path: self.with
-                .clone()
-                .unwrap_or_else(|| parse_quote!(::darling::FromMeta::from_meta)),
+            with_path: self.with.as_ref().map_or_else(
+                || Cow::Owned(parse_quote!(::darling::FromMeta::from_meta)),
+                Cow::Borrowed,
+            ),
             skip: self.skip,
             map: self.map.as_ref(),
             multiple: self.multiple,
@@ -62,10 +66,10 @@ impl InputField {
     }
 
     pub fn from_field(f: &syn::Field, parent: Option<&Core>) -> Result<Self> {
-        let ident = f.ident.clone().unwrap_or_else(|| syn::Ident::new(
-            "__unnamed",
-            ::proc_macro2::Span::call_site(),
-        ));
+        let ident = f
+            .ident
+            .clone()
+            .unwrap_or_else(|| syn::Ident::new("__unnamed", ::proc_macro2::Span::call_site()));
         let ty = f.ty.clone();
         let base = Self::new(ident, ty).parse_attributes(&f.attrs)?;
 
@@ -137,7 +141,7 @@ impl ParseAttribute for InputField {
                 self.multiple = FromMeta::from_meta(mi)?;
                 Ok(())
             }
-            n => Err(Error::unknown_field(n)),
+            n => Err(Error::unknown_field(n).with_span(mi)),
         }
     }
 }
diff --git a/third_party/rust/darling_core/src/options/input_variant.rs b/third_party/rust/darling_core/src/options/input_variant.rs
index 4e69a261944a..6f3cad365e5c 100644
--- a/third_party/rust/darling_core/src/options/input_variant.rs
+++ b/third_party/rust/darling_core/src/options/input_variant.rs
@@ -1,6 +1,8 @@
+use std::borrow::Cow;
+
 use syn;
 
-use ast::{Fields, Style};
+use ast::Fields;
 use codegen;
 use options::{Core, InputField, ParseAttribute};
 use {Error, FromMeta, Result};
@@ -11,6 +13,8 @@ pub struct InputVariant {
     attr_name: Option<String>,
     data: Fields<InputField>,
     skip: bool,
+    /// Whether or not unknown fields are acceptable in this
+    allow_unknown_fields: Option<bool>,
 }
 
 impl InputVariant {
@@ -18,11 +22,13 @@ impl InputVariant {
         codegen::Variant {
             ty_ident,
             variant_ident: &self.ident,
-            name_in_attr: self.attr_name
-                .clone()
-                .unwrap_or_else(|| self.ident.to_string()),
+            name_in_attr: self
+                .attr_name
+                .as_ref()
+                .map_or_else(|| Cow::Owned(self.ident.to_string()), Cow::Borrowed),
             data: self.data.as_ref().map(InputField::as_codegen_field),
             skip: self.skip,
+            allow_unknown_fields: self.allow_unknown_fields.unwrap_or_default(),
         }
     }
 
@@ -32,20 +38,19 @@ impl InputVariant {
             attr_name: Default::default(),
             data: Fields::empty_from(&v.fields),
             skip: Default::default(),
-        }).parse_attributes(&v.attrs)?;
+            allow_unknown_fields: None,
+        })
+        .parse_attributes(&v.attrs)?;
 
-        starter.data = match v.fields {
-            syn::Fields::Unit => Style::Unit.into(),
+        starter.data.fields = match v.fields {
+            syn::Fields::Unit => vec![],
             syn::Fields::Unnamed(ref fields) => {
                 let mut items = Vec::with_capacity(fields.unnamed.len());
                 for item in &fields.unnamed {
                     items.push(InputField::from_field(item, parent)?);
                 }
 
-                Fields {
-                    style: v.fields.clone().into(),
-                    fields: items,
-                }
+                items
             }
             syn::Fields::Named(ref fields) => {
                 let mut items = Vec::with_capacity(fields.named.len());
@@ -53,10 +58,7 @@ impl InputVariant {
                     items.push(InputField::from_field(item, parent)?);
                 }
 
-                Fields {
-                    style: v.fields.clone().into(),
-                    fields: items,
-                }
+                items
             }
         };
 
@@ -72,6 +74,10 @@ impl InputVariant {
             self.attr_name = Some(parent.rename_rule.apply_to_variant(self.ident.to_string()));
         }
 
+        if self.allow_unknown_fields.is_none() {
+            self.allow_unknown_fields = Some(parent.allow_unknown_fields.is_some());
+        }
+
         self
     }
 }
@@ -88,7 +94,7 @@ impl ParseAttribute for InputVariant {
                 self.skip = FromMeta::from_meta(mi)?;
                 Ok(())
             }
-            n => Err(Error::unknown_field(n)),
+            n => Err(Error::unknown_field(n).with_span(mi)),
         }
     }
 }
diff --git a/third_party/rust/darling_core/src/options/mod.rs b/third_party/rust/darling_core/src/options/mod.rs
index f8ea7d651073..a884f5afba7c 100644
--- a/third_party/rust/darling_core/src/options/mod.rs
+++ b/third_party/rust/darling_core/src/options/mod.rs
@@ -42,23 +42,37 @@ impl FromMeta for DefaultExpression {
         Ok(DefaultExpression::Trait)
     }
 
-    fn from_string(lit: &str) -> Result<Self> {
-        Ok(DefaultExpression::Explicit(
-            syn::parse_str(lit).map_err(|_| Error::unknown_value(lit))?
-        ))
+    fn from_value(value: &syn::Lit) -> Result<Self> {
+        syn::Path::from_value(value).map(DefaultExpression::Explicit)
     }
 }
 
-/// Middleware for extracting attribute values.
+/// Run a parsing task, and if it produces an error push it into `$errors`
+macro_rules! collect_error {
+    ($errors:ident, $task:expr) => {
+        if let Err(e) = $task {
+            $errors.push(e);
+        }
+    };
+}
+
+/// Middleware for extracting attribute values. Implementers are expected to override
+/// `parse_nested` so they can apply individual items to themselves, while `parse_attributes`
+/// is responsible for looping through distinct outer attributes and collecting errors.
 pub trait ParseAttribute: Sized {
     fn parse_attributes(mut self, attrs: &[syn::Attribute]) -> Result<Self> {
+        let mut errors = Vec::new();
         for attr in attrs {
             if attr.path == parse_quote!(darling) {
-                parse_attr(attr, &mut self)?;
+                collect_error!(errors, parse_attr(attr, &mut self));
             }
         }
 
-        Ok(self)
+        if !errors.is_empty() {
+            Err(Error::multiple(errors))
+        } else {
+            Ok(self)
+        }
     }
 
     /// Read a meta-item, and apply its values to the current instance.
@@ -66,66 +80,75 @@ pub trait ParseAttribute: Sized {
 }
 
 fn parse_attr<T: ParseAttribute>(attr: &syn::Attribute, target: &mut T) -> Result<()> {
-    match attr.interpret_meta() {
+    let mut errors = Vec::new();
+    match attr.parse_meta().ok() {
         Some(syn::Meta::List(data)) => {
             for item in data.nested {
                 if let syn::NestedMeta::Meta(ref mi) = item {
-                    target.parse_nested(mi)?;
+                    collect_error!(errors, target.parse_nested(mi));
                 } else {
                     panic!("Wasn't able to parse: `{:?}`", item);
                 }
             }
 
-            Ok(())
+            if !errors.is_empty() {
+                Err(Error::multiple(errors))
+            } else {
+                Ok(())
+            }
         }
         Some(ref item) => panic!("Wasn't able to parse: `{:?}`", item),
         None => panic!("Unable to parse {:?}", attr),
     }
 }
 
+/// Middleware for extracting values from the body of the derive input. Implementers are
+/// expected to override `parse_field` or `parse_variant` as appropriate for their use-case,
+/// while `parse_body` dispatches to the appropriate methods and handles error collection.
 pub trait ParseData: Sized {
     fn parse_body(mut self, body: &syn::Data) -> Result<Self> {
         use syn::{Data, Fields};
 
+        let mut errors = Vec::new();
+
         match *body {
             Data::Struct(ref data) => match data.fields {
-                Fields::Unit => Ok(self),
+                Fields::Unit => {}
                 Fields::Named(ref fields) => {
                     for field in &fields.named {
-                        self.parse_field(field)?;
+                        collect_error!(errors, self.parse_field(field));
                     }
-                    Ok(self)
                 }
                 Fields::Unnamed(ref fields) => {
                     for field in &fields.unnamed {
-                        self.parse_field(field)?;
+                        collect_error!(errors, self.parse_field(field));
                     }
-
-                    Ok(self)
                 }
             },
             Data::Enum(ref data) => {
                 for variant in &data.variants {
-                    self.parse_variant(variant)?;
+                    collect_error!(errors, self.parse_variant(variant));
                 }
-
-                Ok(self)
             }
             Data::Union(_) => unreachable!(),
+        };
+
+        if !errors.is_empty() {
+            Err(Error::multiple(errors))
+        } else {
+            Ok(self)
         }
     }
 
     /// Apply the next found variant to the object, returning an error
     /// if parsing goes wrong.
-    #[allow(unused_variables)]
     fn parse_variant(&mut self, variant: &syn::Variant) -> Result<()> {
-        Err(Error::unsupported_format("enum variant"))
+        Err(Error::unsupported_format("enum variant").with_span(variant))
     }
 
     /// Apply the next found struct field to the object, returning an error
     /// if parsing goes wrong.
-    #[allow(unused_variables)]
     fn parse_field(&mut self, field: &syn::Field) -> Result<()> {
-        Err(Error::unsupported_format("struct field"))
+        Err(Error::unsupported_format("struct field").with_span(field))
     }
 }
diff --git a/third_party/rust/darling_core/src/options/shape.rs b/third_party/rust/darling_core/src/options/shape.rs
index 4f6170f9aca4..fe9f25f1d939 100644
--- a/third_party/rust/darling_core/src/options/shape.rs
+++ b/third_party/rust/darling_core/src/options/shape.rs
@@ -1,5 +1,5 @@
 use proc_macro2::TokenStream;
-use quote::{TokenStreamExt, ToTokens};
+use quote::{ToTokens, TokenStreamExt};
 use syn::{Meta, NestedMeta};
 
 use {Error, FromMeta, Result};
@@ -40,14 +40,18 @@ impl FromMeta for Shape {
                 if word == "any" {
                     new.any = true;
                 } else if word.starts_with("enum_") {
-                    new.enum_values.set_word(word)?;
+                    new.enum_values
+                        .set_word(word)
+                        .map_err(|e| e.with_span(ident))?;
                 } else if word.starts_with("struct_") {
-                    new.struct_values.set_word(word)?;
+                    new.struct_values
+                        .set_word(word)
+                        .map_err(|e| e.with_span(ident))?;
                 } else {
-                    return Err(Error::unknown_value(word));
+                    return Err(Error::unknown_value(word).with_span(ident));
                 }
             } else {
-                return Err(Error::unsupported_format("non-word"));
+                return Err(Error::unsupported_format("non-word").with_span(item));
             }
         }
 
@@ -57,7 +61,7 @@ impl FromMeta for Shape {
 
 impl ToTokens for Shape {
     fn to_tokens(&self, tokens: &mut TokenStream) {
-        let fn_body = if self.any == true {
+        let fn_body = if self.any {
             quote!(::darling::export::Ok(()))
         } else {
             let en = &self.enum_values;
@@ -84,24 +88,27 @@ impl ToTokens for Shape {
             }
         };
 
-        // FIXME: Remove the &[]
-        tokens.append_all(&[quote!{
+        tokens.append_all(quote! {
             #[allow(unused_variables)]
             fn __validate_body(__body: &::syn::Data) -> ::darling::Result<()> {
                 #fn_body
             }
-        }]);
+        });
     }
 }
 
 #[derive(Debug, Clone, Default, PartialEq, Eq)]
 pub struct DataShape {
+    /// The kind of shape being described. This can be `struct_` or `enum_`.
     prefix: &'static str,
     newtype: bool,
     named: bool,
     tuple: bool,
     unit: bool,
     any: bool,
+    /// Control whether the emitted code should be inside a function or not.
+    /// This is `true` when creating a `Shape` for `FromDeriveInput`, but false
+    /// when deriving `FromVariant`.
     embedded: bool,
 }
 
@@ -147,16 +154,24 @@ impl DataShape {
 
 impl FromMeta for DataShape {
     fn from_list(items: &[NestedMeta]) -> Result<Self> {
+        let mut errors = Vec::new();
         let mut new = DataShape::default();
+
         for item in items {
             if let NestedMeta::Meta(Meta::Word(ref ident)) = *item {
-                new.set_word(ident.to_string().as_str())?;
+                if let Err(e) = new.set_word(&ident.to_string()) {
+                    errors.push(e.with_span(ident));
+                }
             } else {
-                return Err(Error::unsupported_format("non-word"));
+                errors.push(Error::unsupported_format("non-word").with_span(item));
             }
         }
 
-        Ok(new)
+        if !errors.is_empty() {
+            Err(Error::multiple(errors))
+        } else {
+            Ok(new)
+        }
     }
 }
 
@@ -183,15 +198,13 @@ impl ToTokens for DataShape {
         };
 
         if self.embedded {
-            // FIXME: Remove the &[]
-            tokens.append_all(&[body]);
+            body.to_tokens(tokens);
         } else {
-            // FIXME: Remove the &[]
-            tokens.append_all(&[quote! {
+            tokens.append_all(quote! {
                 fn __validate_data(data: &::syn::Fields) -> ::darling::Result<()> {
                     #body
                 }
-            }]);
+            });
         }
     }
 }
@@ -215,7 +228,7 @@ mod tests {
     /// parse a string as a syn::Meta instance.
     fn pm(tokens: TokenStream) -> ::std::result::Result<syn::Meta, String> {
         let attribute: syn::Attribute = parse_quote!(#[#tokens]);
-        attribute.interpret_meta().ok_or("Unable to parse".into())
+        attribute.parse_meta().or(Err("Unable to parse".into()))
     }
 
     fn fm<T: FromMeta>(tokens: TokenStream) -> T {
diff --git a/third_party/rust/darling_core/src/usage/lifetimes.rs b/third_party/rust/darling_core/src/usage/lifetimes.rs
index eed944d89993..7e2a57b3c073 100644
--- a/third_party/rust/darling_core/src/usage/lifetimes.rs
+++ b/third_party/rust/darling_core/src/usage/lifetimes.rs
@@ -99,10 +99,9 @@ impl<T: UsesLifetimes> UsesLifetimes for Option<T> {
         options: &Options,
         lifetimes: &'a LifetimeSet,
     ) -> LifetimeRefSet<'a> {
-        self.as_ref().map_or_else(
-            || Default::default(),
-            |v| v.uses_lifetimes(options, lifetimes),
-        )
+        self.as_ref()
+            .map(|v| v.uses_lifetimes(options, lifetimes))
+            .unwrap_or_default()
     }
 }
 
@@ -288,13 +287,14 @@ mod tests {
     use usage::GenericsExt;
     use usage::Purpose::*;
 
-    fn parse(src: &str) -> DeriveInput {
-        syn::parse_str(src).unwrap()
-    }
-
     #[test]
     fn struct_named() {
-        let input = parse("struct Foo<'a, 'b: 'a> { parent: &'b Bar, child: &'a Baz, }");
+        let input: DeriveInput = parse_quote! {
+            struct Foo<'a, 'b: 'a> {
+                parent: &'b Bar,
+                child: &'a Baz,
+            }
+        };
         let omitted = syn::Lifetime::new("'c", Span::call_site());
 
         let lifetimes = {
@@ -309,9 +309,12 @@ mod tests {
 
     #[test]
     fn qself() {
-        let input = parse(
-            "struct Foo<'a, 'b: 'a> { parent: &'b Bar, child: <Bar<'a> as MyIterator>::Item, }",
-        );
+        let input: DeriveInput = parse_quote! {
+            struct Foo<'a, 'b: 'a> {
+                parent: &'b Bar,
+                child: <Bar<'a> as MyIterator>::Item,
+            }
+        };
         let lifetimes = input.generics.declared_lifetimes();
         let matches = input.data.uses_lifetimes(&BoundImpl.into(), &lifetimes);
         assert_eq!(matches.len(), 1);
diff --git a/third_party/rust/darling_core/src/usage/type_params.rs b/third_party/rust/darling_core/src/usage/type_params.rs
index 310b381eaf4b..963da9c8f543 100644
--- a/third_party/rust/darling_core/src/usage/type_params.rs
+++ b/third_party/rust/darling_core/src/usage/type_params.rs
@@ -246,16 +246,12 @@ impl UsesTypeParams for syn::TypeParamBound {
 #[cfg(test)]
 mod tests {
     use proc_macro2::Span;
-    use syn::{self, Ident};
+    use syn::{DeriveInput, Ident};
 
     use super::UsesTypeParams;
     use usage::IdentSet;
     use usage::Purpose::*;
 
-    fn given_src(src: &str) -> syn::DeriveInput {
-        syn::parse_str(src).unwrap()
-    }
-
     fn ident_set(idents: Vec<&str>) -> IdentSet {
         idents
             .into_iter()
@@ -265,7 +261,7 @@ mod tests {
 
     #[test]
     fn finds_simple() {
-        let input = given_src("struct Foo<T, U>(T, i32, A, U);");
+        let input: DeriveInput = parse_quote! { struct Foo<T, U>(T, i32, A, U); };
         let generics = ident_set(vec!["T", "U", "X"]);
         let matches = input.data.uses_type_params(&BoundImpl.into(), &generics);
         assert_eq!(matches.len(), 2);
@@ -277,14 +273,12 @@ mod tests {
 
     #[test]
     fn finds_named() {
-        let input = given_src(
-            r#"
-        struct Foo<T, U = usize> {
-            bar: T,
-            world: U,
-        }
-        "#,
-        );
+        let input: DeriveInput = parse_quote! {
+            struct Foo<T, U = usize> {
+                bar: T,
+                world: U,
+            }
+        };
 
         let generics = ident_set(vec!["T", "U", "X"]);
 
@@ -299,14 +293,12 @@ mod tests {
 
     #[test]
     fn finds_as_type_arg() {
-        let input = given_src(
-            r#"
-        struct Foo<T, U> {
-            bar: T,
-            world: Vec<U>,
-        }
-        "#,
-        );
+        let input: DeriveInput = parse_quote! {
+            struct Foo<T, U> {
+                bar: T,
+                world: Vec<U>,
+            }
+        };
 
         let generics = ident_set(vec!["T", "U", "X"]);
 
@@ -321,7 +313,8 @@ mod tests {
 
     #[test]
     fn associated_type() {
-        let input = given_src("struct Foo<'a, T> where T: Iterator { peek: T::Item }");
+        let input: DeriveInput =
+            parse_quote! { struct Foo<'a, T> where T: Iterator { peek: T::Item } };
         let generics = ident_set(vec!["T", "INTO"]);
         let matches = input.data.uses_type_params(&BoundImpl.into(), &generics);
         assert_eq!(matches.len(), 1);
@@ -329,7 +322,7 @@ mod tests {
 
     #[test]
     fn box_fn_output() {
-        let input = given_src("struct Foo<T>(Box<Fn() -> T>);");
+        let input: DeriveInput = parse_quote! { struct Foo<T>(Box<Fn() -> T>); };
         let generics = ident_set(vec!["T"]);
         let matches = input.data.uses_type_params(&BoundImpl.into(), &generics);
         assert_eq!(matches.len(), 1);
@@ -338,7 +331,7 @@ mod tests {
 
     #[test]
     fn box_fn_input() {
-        let input = given_src("struct Foo<T>(Box<Fn(&T) -> ()>);");
+        let input: DeriveInput = parse_quote! { struct Foo<T>(Box<Fn(&T) -> ()>); };
         let generics = ident_set(vec!["T"]);
         let matches = input.data.uses_type_params(&BoundImpl.into(), &generics);
         assert_eq!(matches.len(), 1);
@@ -349,7 +342,8 @@ mod tests {
     /// search can execute in.
     #[test]
     fn qself_vec() {
-        let input = given_src("struct Foo<T>(<Vec<T> as a::b::Trait>::AssociatedItem);");
+        let input: DeriveInput =
+            parse_quote! { struct Foo<T>(<Vec<T> as a::b::Trait>::AssociatedItem); };
         let generics = ident_set(vec!["T", "U"]);
 
         let bound_matches = input.data.uses_type_params(&BoundImpl.into(), &generics);
diff --git a/third_party/rust/darling_core/src/util/ident_list.rs b/third_party/rust/darling_core/src/util/ident_list.rs
index d81697cfccb6..4da04a9d5653 100644
--- a/third_party/rust/darling_core/src/util/ident_list.rs
+++ b/third_party/rust/darling_core/src/util/ident_list.rs
@@ -52,10 +52,50 @@ impl FromMeta for IdentList {
             if let NestedMeta::Meta(Meta::Word(ref ident)) = *nmi {
                 idents.push(ident.clone());
             } else {
-                return Err(Error::unexpected_type("non-word"));
+                return Err(Error::unexpected_type("non-word").with_span(nmi));
             }
         }
 
         Ok(IdentList(idents))
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::IdentList;
+    use proc_macro2::TokenStream;
+    use FromMeta;
+
+    /// parse a string as a syn::Meta instance.
+    fn pm(tokens: TokenStream) -> ::std::result::Result<syn::Meta, String> {
+        let attribute: syn::Attribute = parse_quote!(#[#tokens]);
+        attribute.interpret_meta().ok_or("Unable to parse".into())
+    }
+
+    fn fm<T: FromMeta>(tokens: TokenStream) -> T {
+        FromMeta::from_meta(&pm(tokens).expect("Tests should pass well-formed input"))
+            .expect("Tests should pass valid input")
+    }
+
+    #[test]
+    fn succeeds() {
+        let idents = fm::<IdentList>(quote!(ignore(Debug, Clone, Eq)));
+        assert_eq!(
+            idents.to_strings(),
+            vec![
+                String::from("Debug"),
+                String::from("Clone"),
+                String::from("Eq")
+            ]
+        );
+    }
+
+    /// Check that the parser rejects non-word members of the list, and that the error
+    /// has an associated span.
+    #[test]
+    fn fails_non_word() {
+        let input = IdentList::from_meta(&pm(quote!(ignore(Debug, Clone = false))).unwrap());
+        let err = input.unwrap_err();
+        assert!(err.has_span());
+    }
+}
diff --git a/third_party/rust/darling_core/src/util/ident_string.rs b/third_party/rust/darling_core/src/util/ident_string.rs
index 529891f71fd9..293610e2f603 100644
--- a/third_party/rust/darling_core/src/util/ident_string.rs
+++ b/third_party/rust/darling_core/src/util/ident_string.rs
@@ -1,4 +1,5 @@
 use std::fmt;
+use std::hash::{Hash, Hasher};
 
 use proc_macro2::{Span, TokenStream};
 use quote::ToTokens;
@@ -9,7 +10,7 @@ use {FromMeta, Result};
 /// A wrapper for an `Ident` which also keeps the value as a string.
 ///
 /// This struct can be used to perform string comparisons and operations.
-#[derive(Clone, Hash, PartialOrd, Ord)]
+#[derive(Clone, PartialOrd, Ord)]
 pub struct IdentString {
     ident: Ident,
     string: String,
@@ -104,6 +105,12 @@ impl<'a> PartialEq<&'a str> for IdentString {
     }
 }
 
+impl Hash for IdentString {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.ident.hash(state);
+    }
+}
+
 impl ToTokens for IdentString {
     fn to_tokens(&self, tokens: &mut TokenStream) {
         self.ident.to_tokens(tokens);
diff --git a/third_party/rust/darling_core/src/util/mod.rs b/third_party/rust/darling_core/src/util/mod.rs
index f3f58d8293b7..046b87f690a2 100644
--- a/third_party/rust/darling_core/src/util/mod.rs
+++ b/third_party/rust/darling_core/src/util/mod.rs
@@ -10,11 +10,13 @@ mod ident_string;
 mod ignored;
 mod over_ride;
 mod with_original;
+mod spanned_value;
 
 pub use self::ident_list::IdentList;
 pub use self::ident_string::IdentString;
 pub use self::ignored::Ignored;
 pub use self::over_ride::Override;
+pub use self::spanned_value::SpannedValue;
 pub use self::with_original::WithOriginal;
 
 /// Marker type equivalent to `Option<()>` for use in attribute parsing.
diff --git a/third_party/rust/darling_core/src/util/spanned_value.rs b/third_party/rust/darling_core/src/util/spanned_value.rs
new file mode 100644
index 000000000000..1ea3dfc703bc
--- /dev/null
+++ b/third_party/rust/darling_core/src/util/spanned_value.rs
@@ -0,0 +1,104 @@
+use proc_macro2::Span;
+use std::ops::{Deref, DerefMut};
+use syn;
+use syn::spanned::Spanned;
+use {
+    FromDeriveInput, FromField, FromGenericParam, FromGenerics, FromMeta, FromTypeParam,
+    FromVariant, Result,
+};
+
+/// A value and an associated position in source code. The main use case for this is
+/// to preserve position information to emit warnings from proc macros. You can use
+/// a `SpannedValue<T>` as a field in any struct that implements or derives any of
+/// `darling`'s core traits.
+///
+/// To access the underlying value, use the struct's `Deref` implementation.
+///
+/// # Defaulting
+/// This type is meant to be used in conjunction with attribute-extracted options,
+/// but the user may not always explicitly set those options in their source code.
+/// In this case, using `Default::default()` will create an instance which points
+/// to `Span::call_site()`.
+#[derive(Debug, Clone)]
+pub struct SpannedValue<T> {
+    value: T,
+    span: Span,
+}
+
+impl<T> SpannedValue<T> {
+    pub fn new(value: T, span: Span) -> Self {
+        SpannedValue { value, span }
+    }
+
+    /// Get the source code location referenced by this struct.
+    pub fn span(&self) -> Span {
+        self.span
+    }
+}
+
+impl<T: Default> Default for SpannedValue<T> {
+    fn default() -> Self {
+        SpannedValue::new(Default::default(), Span::call_site())
+    }
+}
+
+impl<T> Deref for SpannedValue<T> {
+    type Target = T;
+
+    fn deref(&self) -> &T {
+        &self.value
+    }
+}
+
+impl<T> DerefMut for SpannedValue<T> {
+    fn deref_mut(&mut self) -> &mut T {
+        &mut self.value
+    }
+}
+
+impl<T> AsRef<T> for SpannedValue<T> {
+    fn as_ref(&self) -> &T {
+        &self.value
+    }
+}
+
+macro_rules! spanned {
+    ($trayt:ident, $method:ident, $syn:path) => {
+        impl<T: $trayt> $trayt for SpannedValue<T> {
+            fn $method(value: &$syn) -> Result<Self> {
+                Ok(SpannedValue::new(
+                    $trayt::$method(value).map_err(|e| e.with_span(value))?,
+                    value.span(),
+                ))
+            }
+        }
+    };
+}
+
+spanned!(FromGenericParam, from_generic_param, syn::GenericParam);
+spanned!(FromGenerics, from_generics, syn::Generics);
+spanned!(FromTypeParam, from_type_param, syn::TypeParam);
+spanned!(FromMeta, from_meta, syn::Meta);
+spanned!(FromDeriveInput, from_derive_input, syn::DeriveInput);
+spanned!(FromField, from_field, syn::Field);
+spanned!(FromVariant, from_variant, syn::Variant);
+
+impl<T: Spanned> From<T> for SpannedValue<T> {
+    fn from(value: T) -> Self {
+        let span = value.span();
+        SpannedValue::new(value, span)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use proc_macro2::Span;
+
+    /// Make sure that `SpannedValue` can be seamlessly used as its underlying type.
+    #[test]
+    fn deref() {
+        let test = SpannedValue::new("hello", Span::call_site());
+        assert_eq!("hello", test.trim());
+    }
+}
diff --git a/third_party/rust/darling_macro/.cargo-checksum.json b/third_party/rust/darling_macro/.cargo-checksum.json
index e4da6bc2ec58..11a242ff795e 100644
--- a/third_party/rust/darling_macro/.cargo-checksum.json
+++ b/third_party/rust/darling_macro/.cargo-checksum.json
@@ -1 +1 @@
-{"files":{"Cargo.toml":"a062c325e8c632ab4da20f1f5918efb2b8ebdcaa45c7cc23fad00d546fa8fc46","src/lib.rs":"8343bf4500faeaf72e0cafb9e2c378be176bfe41529ba8f0d5e315336de422bf"},"package":"99c4eff4bcbeaf6a22578012ff79c95910338668278d1901e528bd34a22f575d"}
\ No newline at end of file
+{"files":{"Cargo.toml":"7f87d565ab1cb6661d23c51bca2b37b15f0f97456cdace142b54ef39f1f17d0a","LICENSE":"8ea93490d74a5a1b1af3ff71d786271b3f1e5f0bea79ac16e02ec533cef040d6","src/lib.rs":"88141a58dc13b9001a83ca7559b6213ab44641510b6d642a3280c244ad735cec"},"package":"244e8987bd4e174385240cde20a3657f607fb0797563c28255c353b5819a07b1"}
\ No newline at end of file
diff --git a/third_party/rust/darling_macro/Cargo.toml b/third_party/rust/darling_macro/Cargo.toml
index b86e2197d229..d45b80a85527 100644
--- a/third_party/rust/darling_macro/Cargo.toml
+++ b/third_party/rust/darling_macro/Cargo.toml
@@ -12,7 +12,7 @@
 
 [package]
 name = "darling_macro"
-version = "0.8.1"
+version = "0.8.6"
 authors = ["Ted Driggs <ted.driggs@outlook.com>"]
 description = "Internal support for a proc-macro library for reading attributes into structs when\nimplementing custom derives. Use https://crates.io/crates/darling in your code.\n"
 license = "MIT"
@@ -21,10 +21,10 @@ repository = "https://github.com/TedDriggs/darling"
 [lib]
 proc-macro = true
 [dependencies.darling_core]
-version = "=0.8.1"
+version = "=0.8.6"
 
 [dependencies.quote]
 version = "0.6"
 
 [dependencies.syn]
-version = "0.15"
+version = "0.15.26"
diff --git a/third_party/rust/darling_macro/LICENSE b/third_party/rust/darling_macro/LICENSE
new file mode 100644
index 000000000000..0b48eadc9d03
--- /dev/null
+++ b/third_party/rust/darling_macro/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Ted Driggs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/third_party/rust/darling_macro/src/lib.rs b/third_party/rust/darling_macro/src/lib.rs
index 0553ef97377c..629526c553a1 100644
--- a/third_party/rust/darling_macro/src/lib.rs
+++ b/third_party/rust/darling_macro/src/lib.rs
@@ -1,72 +1,41 @@
 extern crate proc_macro;
 #[macro_use]
-extern crate quote;
-#[macro_use]
 extern crate syn;
 
 extern crate darling_core;
 
 use proc_macro::TokenStream;
 
-use darling_core::{codegen, options};
+use darling_core::{derive, Error};
 
 #[proc_macro_derive(FromMeta, attributes(darling))]
 pub fn derive_from_meta(input: TokenStream) -> TokenStream {
-    let ast = parse_macro_input!(input as syn::DeriveInput);
-
-    let container = options::FromMetaOptions::new(&ast).unwrap();
-    let trait_impl = codegen::FromMetaImpl::from(&container);
-    let result = quote!(#trait_impl);
-
-    result.into()
+    derive::from_meta(&parse_macro_input!(input)).into()
 }
 
 #[proc_macro_derive(FromMetaItem, attributes(darling))]
 pub fn derive_from_meta_item(_input: TokenStream) -> TokenStream {
-    panic!("darling::FromMetaItem has been replaced by darling::FromMeta");
+    Error::custom("darling::FromMetaItem has been replaced by darling::FromMeta")
+        .write_errors()
+        .into()
 }
 
-
 #[proc_macro_derive(FromDeriveInput, attributes(darling))]
 pub fn derive_from_input(input: TokenStream) -> TokenStream {
-    let ast = parse_macro_input!(input as syn::DeriveInput);
-
-    let container = options::FdiOptions::new(&ast).unwrap();
-    let trait_impl = codegen::FromDeriveInputImpl::from(&container);
-    let result = quote!(#trait_impl);
-
-    result.into()
+    derive::from_derive_input(&parse_macro_input!(input)).into()
 }
 
 #[proc_macro_derive(FromField, attributes(darling))]
 pub fn derive_field(input: TokenStream) -> TokenStream {
-    let ast = parse_macro_input!(input as syn::DeriveInput);
-
-    let fdic = options::FromFieldOptions::new(&ast).unwrap();
-    let trait_impl = codegen::FromFieldImpl::from(&fdic);
-    let result = quote!(#trait_impl);
-
-    result.into()
+    derive::from_field(&parse_macro_input!(input)).into()
 }
 
 #[proc_macro_derive(FromTypeParam, attributes(darling))]
 pub fn derive_type_param(input: TokenStream) -> TokenStream {
-    let ast = parse_macro_input!(input as syn::DeriveInput);
-
-    let fdic = options::FromTypeParamOptions::new(&ast).unwrap();
-    let trait_impl = codegen::FromTypeParamImpl::from(&fdic);
-    let result = quote!(#trait_impl);
-
-    result.into()
+    derive::from_type_param(&parse_macro_input!(input)).into()
 }
 
 #[proc_macro_derive(FromVariant, attributes(darling))]
 pub fn derive_variant(input: TokenStream) -> TokenStream {
-    let ast = parse_macro_input!(input as syn::DeriveInput);
-
-    let fdic = options::FromVariantOptions::new(&ast).unwrap();
-    let trait_impl = codegen::FromVariantImpl::from(&fdic);
-    let result = quote!(#trait_impl);
-
-    result.into()
+    derive::from_variant(&parse_macro_input!(input)).into()
 }
diff --git a/third_party/rust/proc-macro2/.cargo-checksum.json b/third_party/rust/proc-macro2/.cargo-checksum.json
index f87951f773e9..f7d080fba00f 100644
--- a/third_party/rust/proc-macro2/.cargo-checksum.json
+++ b/third_party/rust/proc-macro2/.cargo-checksum.json
@@ -1 +1 @@
-{"files":{"Cargo.toml":"f020c87cba7dd2260861239307b2cb93e16c2bed6e2ef6c9178642b1dfcc43a3","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"378f5840b258e2779c39418f3f2d7b2ba96f1c7917dd6be0713f88305dbda397","README.md":"538fd635d385b6a90ef4cc1e361aad717162a139e932a6192212cad8407aa8e1","build.rs":"7698abdd3087e0f3308916c37ade3349b6b000165186b80913013af18d36ecb6","src/lib.rs":"c5c276236d828189a5151c890a66f2b7d1c02beca98f08f2d9c01166df441eb2","src/stable.rs":"a1f29e850e5fc4c602ee1204847124e266087175695d77ec448016db910acb6b","src/strnom.rs":"807c377bdb49b8b1c67d013089b8ff33fe93ffd3fa36b6440dbb1d6fe8cd9c17","src/unstable.rs":"0b7f86862d8254104330d14837ea6ec89e7b3bf2ffe910b73629269f2bc282de","tests/marker.rs":"0227d07bbc7f2e2ad34662a6acb65668b7dc2f79141c4faa672703a04e27bea0","tests/test.rs":"427821bab498926aa56bfcea7d28c36fb24a7d63d7f59d3e7e097bcfc77fe95b"},"package":"77619697826f31a02ae974457af0b29b723e5619e113e9397b8b82c6bd253f09"}
\ No newline at end of file
+{"files":{"Cargo.toml":"b523856472549844b4bf20eca0473d955a7e5eeb95c70eddd31a05ac455427bb","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"378f5840b258e2779c39418f3f2d7b2ba96f1c7917dd6be0713f88305dbda397","README.md":"89857eaaa305afe540abcf56fabae0194dfb4e7906a8098b7206acb23ed11ce8","build.rs":"36fa668f3bf309f243d0e977e8428446cc424303139c1f63410b3c2e30445aec","src/fallback.rs":"e4d1bcb1e92383a2285e6c947dd74b0e34144904948db68127faea627f5dd6ff","src/lib.rs":"896a1d212e30902ff051313808007406ca4471c27880a6ef19508f0ebb8333ee","src/strnom.rs":"60f5380106dbe568cca7abd09877e133c874fbee95d502e4830425c4613a640d","src/wrapper.rs":"0d7fe28ab2b7ee02b8eb8c5a636da364c60f6704b23e7db0a1ddd57c742f54b1","tests/marker.rs":"0227d07bbc7f2e2ad34662a6acb65668b7dc2f79141c4faa672703a04e27bea0","tests/test.rs":"166d35835355bdaa85bcf69de4dfb56ccddd8acf2e1a8cbc506782632b151674"},"package":"4d317f9caece796be1980837fd5cb3dfec5613ebdb04ad0956deea83ce168915"}
\ No newline at end of file
diff --git a/third_party/rust/proc-macro2/Cargo.toml b/third_party/rust/proc-macro2/Cargo.toml
index 778fdb802163..6b11c1e27469 100644
--- a/third_party/rust/proc-macro2/Cargo.toml
+++ b/third_party/rust/proc-macro2/Cargo.toml
@@ -12,7 +12,7 @@
 
 [package]
 name = "proc-macro2"
-version = "0.4.24"
+version = "0.4.27"
 authors = ["Alex Crichton <alex@alexcrichton.com>"]
 build = "build.rs"
 description = "A stable implementation of the upcoming new `proc_macro` API. Comes with an\noption, off by default, to also reimplement itself in terms of the upstream\nunstable API.\n"
@@ -32,7 +32,8 @@ version = "0.6"
 
 [features]
 default = ["proc-macro"]
-nightly = ["proc-macro"]
+nightly = []
 proc-macro = []
+span-locations = []
 [badges.travis-ci]
 repository = "alexcrichton/proc-macro2"
diff --git a/third_party/rust/proc-macro2/README.md b/third_party/rust/proc-macro2/README.md
index f11c4dca65ae..d887d2378604 100644
--- a/third_party/rust/proc-macro2/README.md
+++ b/third_party/rust/proc-macro2/README.md
@@ -1,60 +1,76 @@
 # proc-macro2
 
-[![Build Status](https://api.travis-ci.org/alexcrichton/proc-macro2.svg?branch=master)](https://travis-ci.org/alexcrichton/proc-macro2)
+[![Build Status](https://api.travis-ci.com/alexcrichton/proc-macro2.svg?branch=master)](https://travis-ci.com/alexcrichton/proc-macro2)
 [![Latest Version](https://img.shields.io/crates/v/proc-macro2.svg)](https://crates.io/crates/proc-macro2)
 [![Rust Documentation](https://img.shields.io/badge/api-rustdoc-blue.svg)](https://docs.rs/proc-macro2)
 
-A small shim over the `proc_macro` crate in the compiler intended to multiplex
-the stable interface as of 1.15.0 and the interface as of 1.30.0.
+A wrapper around the procedural macro API of the compiler's `proc_macro` crate.
+This library serves three purposes:
 
-New features added in Rust 1.30.0 include:
+- **Bring proc-macro-like functionality to other contexts like build.rs and
+  main.rs.** Types from `proc_macro` are entirely specific to procedural macros
+  and cannot ever exist in code outside of a procedural macro. Meanwhile
+  `proc_macro2` types may exist anywhere including non-macro code. By developing
+  foundational libraries like [syn] and [quote] against `proc_macro2` rather
+  than `proc_macro`, the procedural macro ecosystem becomes easily applicable to
+  many other use cases and we avoid reimplementing non-macro equivalents of
+  those libraries.
 
-* Span information on tokens
-* No need to go in/out through strings
-* Structured input/output
+- **Make procedural macros unit testable.** As a consequence of being specific
+  to procedural macros, nothing that uses `proc_macro` can be executed from a
+  unit test. In order for helper libraries or components of a macro to be
+  testable in isolation, they must be implemented using `proc_macro2`.
 
-Libraries ported to `proc_macro2` can retain support for older compilers while
-continuing to get all the nice benefits of using a 1.30.0+ compiler.
+- **Provide the latest and greatest APIs across all compiler versions.**
+  Procedural macros were first introduced to Rust in 1.15.0 with an extremely
+  minimal interface. Since then, many improvements have landed to make macros
+  more flexible and easier to write. This library tracks the procedural macro
+  API of the most recent stable compiler but employs a polyfill to provide that
+  API consistently across any compiler since 1.15.0.
+
+[syn]: https://github.com/dtolnay/syn
+[quote]: https://github.com/dtolnay/quote
 
 ## Usage
 
-This crate compiles on all 1.15.0+ stable compilers and usage looks like:
-
 ```toml
 [dependencies]
 proc-macro2 = "0.4"
 ```
 
-followed by
+The skeleton of a typical procedural macro typically looks like this:
 
 ```rust
 extern crate proc_macro;
-extern crate proc_macro2;
 
 #[proc_macro_derive(MyDerive)]
 pub fn my_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
-    let input: proc_macro2::TokenStream = input.into();
+    let input = proc_macro2::TokenStream::from(input);
 
     let output: proc_macro2::TokenStream = {
         /* transform input */
     };
 
-    output.into()
+    proc_macro::TokenStream::from(output)
 }
 ```
 
-The 1.30.0 compiler is automatically detected and its interfaces are used when
-available.
+If parsing with [Syn], you'll use [`parse_macro_input!`] instead to propagate
+parse errors correctly back to the compiler when parsing fails.
 
-## Unstable Features
+[`parse_macro_input!`]: https://docs.rs/syn/0.15/syn/macro.parse_macro_input.html
 
-`proc-macro2` supports exporting some methods from `proc_macro` which are
-currently highly unstable, and are not stabilized in the first pass of
-`proc_macro` stabilizations. These features are not exported by default. Minor
-versions of `proc-macro2` may make breaking changes to them at any time.
+## Unstable features
 
-To enable these features, the `procmacro2_semver_exempt` config flag must be
-passed to rustc.
+The default feature set of proc-macro2 tracks the most recent stable compiler
+API. Functionality in `proc_macro` that is not yet stable is not exposed by
+proc-macro2 by default.
+
+To opt into the additional APIs available in the most recent nightly compiler,
+the `procmacro2_semver_exempt` config flag must be passed to rustc. As usual, we
+will polyfill those nightly-only APIs all the way back to Rust 1.15.0. As these
+are unstable APIs that track the nightly compiler, minor versions of proc-macro2
+may make breaking changes to them at any time.
 
 ```
 RUSTFLAGS='--cfg procmacro2_semver_exempt' cargo build
@@ -64,6 +80,8 @@ Note that this must not only be done for your crate, but for any crate that
 depends on your crate. This infectious nature is intentional, as it serves as a
 reminder that you are outside of the normal semver guarantees.
 
+Semver exempt methods are marked as such in the proc-macro2 documentation.
+
 # License
 
 This project is licensed under either of
diff --git a/third_party/rust/proc-macro2/build.rs b/third_party/rust/proc-macro2/build.rs
index cd6df2379e6f..6c0112153c9c 100644
--- a/third_party/rust/proc-macro2/build.rs
+++ b/third_party/rust/proc-macro2/build.rs
@@ -1,3 +1,43 @@
+// rustc-cfg emitted by the build script:
+//
+// "u128"
+//     Include u128 and i128 constructors for proc_macro2::Literal. Enabled on
+//     any compiler 1.26+.
+//
+// "use_proc_macro"
+//     Link to extern crate proc_macro. Available on any compiler and any target
+//     except wasm32. Requires "proc-macro" Cargo cfg to be enabled (default is
+//     enabled). On wasm32 we never link to proc_macro even if "proc-macro" cfg
+//     is enabled.
+//
+// "wrap_proc_macro"
+//     Wrap types from libproc_macro rather than polyfilling the whole API.
+//     Enabled on rustc 1.29+ as long as procmacro2_semver_exempt is not set,
+//     because we can't emulate the unstable API without emulating everything
+//     else. Also enabled unconditionally on nightly, in which case the
+//     procmacro2_semver_exempt surface area is implemented by using the
+//     nightly-only proc_macro API.
+//
+// "slow_extend"
+//     Fallback when `impl Extend for TokenStream` is not available. These impls
+//     were added one version later than the rest of the proc_macro token API.
+//     Enabled on rustc 1.29 only.
+//
+// "nightly"
+//     Enable the Span::unwrap method. This is to support proc_macro_span and
+//     proc_macro_diagnostic use on the nightly channel without requiring the
+//     semver exemption opt-in. Enabled when building with nightly.
+//
+// "super_unstable"
+//     Implement the semver exempt API in terms of the nightly-only proc_macro
+//     API. Enabled when using procmacro2_semver_exempt on a nightly compiler.
+//
+// "span_locations"
+//     Provide methods Span::start and Span::end which give the line/column
+//     location of a token. Enabled by procmacro2_semver_exempt or the
+//     "span-locations" Cargo cfg. This is behind a cfg because tracking
+//     location inside spans is a performance hit.
+
 use std::env;
 use std::process::Command;
 use std::str;
@@ -7,34 +47,47 @@ fn main() {
 
     let target = env::var("TARGET").unwrap();
 
-    let minor = match rustc_minor_version() {
-        Some(n) => n,
+    let version = match rustc_version() {
+        Some(version) => version,
         None => return,
     };
 
-    if minor >= 26 {
+    if version.minor >= 26 {
         println!("cargo:rustc-cfg=u128");
     }
 
+    let semver_exempt = cfg!(procmacro2_semver_exempt);
+    if semver_exempt {
+        // https://github.com/alexcrichton/proc-macro2/issues/147
+        println!("cargo:rustc-cfg=procmacro2_semver_exempt");
+    }
+
+    if semver_exempt || cfg!(feature = "span-locations") {
+        println!("cargo:rustc-cfg=span_locations");
+    }
+
     if !enable_use_proc_macro(&target) {
         return;
     }
+
     println!("cargo:rustc-cfg=use_proc_macro");
 
     // Rust 1.29 stabilized the necessary APIs in the `proc_macro` crate
-    if (minor >= 29 && !cfg!(procmacro2_semver_exempt)) || cfg!(feature = "nightly") {
+    if version.nightly || version.minor >= 29 && !semver_exempt {
         println!("cargo:rustc-cfg=wrap_proc_macro");
-
-        if cfg!(procmacro2_semver_exempt) {
-            println!("cargo:rustc-cfg=super_unstable");
-            // https://github.com/alexcrichton/proc-macro2/issues/147
-            println!("cargo:rustc-cfg=procmacro2_semver_exempt");
-        }
     }
 
-    if minor == 29 {
+    if version.minor == 29 {
         println!("cargo:rustc-cfg=slow_extend");
     }
+
+    if version.nightly {
+        println!("cargo:rustc-cfg=nightly");
+    }
+
+    if semver_exempt && version.nightly {
+        println!("cargo:rustc-cfg=super_unstable");
+    }
 }
 
 fn enable_use_proc_macro(target: &str) -> bool {
@@ -47,7 +100,12 @@ fn enable_use_proc_macro(target: &str) -> bool {
     cfg!(feature = "proc-macro")
 }
 
-fn rustc_minor_version() -> Option<u32> {
+struct RustcVersion {
+    minor: u32,
+    nightly: bool,
+}
+
+fn rustc_version() -> Option<RustcVersion> {
     macro_rules! otry {
         ($e:expr) => {
             match $e {
@@ -56,12 +114,20 @@ fn rustc_minor_version() -> Option<u32> {
             }
         };
     }
+
     let rustc = otry!(env::var_os("RUSTC"));
     let output = otry!(Command::new(rustc).arg("--version").output().ok());
     let version = otry!(str::from_utf8(&output.stdout).ok());
+    let nightly = version.contains("nightly");
     let mut pieces = version.split('.');
     if pieces.next() != Some("rustc 1") {
         return None;
     }
-    otry!(pieces.next()).parse().ok()
+    let minor = otry!(pieces.next());
+    let minor = otry!(minor.parse().ok());
+
+    Some(RustcVersion {
+        minor: minor,
+        nightly: nightly,
+    })
 }
diff --git a/third_party/rust/proc-macro2/src/stable.rs b/third_party/rust/proc-macro2/src/fallback.rs
similarity index 96%
rename from third_party/rust/proc-macro2/src/stable.rs
rename to third_party/rust/proc-macro2/src/fallback.rs
index baeed69af6c8..928c7472c452 100644
--- a/third_party/rust/proc-macro2/src/stable.rs
+++ b/third_party/rust/proc-macro2/src/fallback.rs
@@ -1,6 +1,4 @@
-#![cfg_attr(not(procmacro2_semver_exempt), allow(dead_code))]
-
-#[cfg(procmacro2_semver_exempt)]
+#[cfg(span_locations)]
 use std::cell::RefCell;
 #[cfg(procmacro2_semver_exempt)]
 use std::cmp;
@@ -35,7 +33,7 @@ impl TokenStream {
     }
 }
 
-#[cfg(procmacro2_semver_exempt)]
+#[cfg(span_locations)]
 fn get_cursor(src: &str) -> Cursor {
     // Create a dummy file & add it to the codemap
     CODEMAP.with(|cm| {
@@ -49,7 +47,7 @@ fn get_cursor(src: &str) -> Cursor {
     })
 }
 
-#[cfg(not(procmacro2_semver_exempt))]
+#[cfg(not(span_locations))]
 fn get_cursor(src: &str) -> Cursor {
     Cursor { rest: src }
 }
@@ -225,27 +223,41 @@ pub struct LineColumn {
     pub column: usize,
 }
 
-#[cfg(procmacro2_semver_exempt)]
+#[cfg(span_locations)]
 thread_local! {
     static CODEMAP: RefCell<Codemap> = RefCell::new(Codemap {
         // NOTE: We start with a single dummy file which all call_site() and
         // def_site() spans reference.
-        files: vec![FileInfo {
-            name: "<unspecified>".to_owned(),
-            span: Span { lo: 0, hi: 0 },
-            lines: vec![0],
+        files: vec![{
+            #[cfg(procmacro2_semver_exempt)]
+            {
+                FileInfo {
+                    name: "<unspecified>".to_owned(),
+                    span: Span { lo: 0, hi: 0 },
+                    lines: vec![0],
+                }
+            }
+
+            #[cfg(not(procmacro2_semver_exempt))]
+            {
+                FileInfo {
+                    span: Span { lo: 0, hi: 0 },
+                    lines: vec![0],
+                }
+            }
         }],
     });
 }
 
-#[cfg(procmacro2_semver_exempt)]
+#[cfg(span_locations)]
 struct FileInfo {
+    #[cfg(procmacro2_semver_exempt)]
     name: String,
     span: Span,
     lines: Vec<usize>,
 }
 
-#[cfg(procmacro2_semver_exempt)]
+#[cfg(span_locations)]
 impl FileInfo {
     fn offset_line_column(&self, offset: usize) -> LineColumn {
         assert!(self.span_within(Span {
@@ -271,7 +283,7 @@ impl FileInfo {
 }
 
 /// Computesthe offsets of each line in the given source string.
-#[cfg(procmacro2_semver_exempt)]
+#[cfg(span_locations)]
 fn lines_offsets(s: &str) -> Vec<usize> {
     let mut lines = vec![0];
     let mut prev = 0;
@@ -282,12 +294,12 @@ fn lines_offsets(s: &str) -> Vec<usize> {
     lines
 }
 
-#[cfg(procmacro2_semver_exempt)]
+#[cfg(span_locations)]
 struct Codemap {
     files: Vec<FileInfo>,
 }
 
-#[cfg(procmacro2_semver_exempt)]
+#[cfg(span_locations)]
 impl Codemap {
     fn next_start_pos(&self) -> u32 {
         // Add 1 so there's always space between files.
@@ -306,12 +318,20 @@ impl Codemap {
             hi: lo + (src.len() as u32),
         };
 
+        #[cfg(procmacro2_semver_exempt)]
         self.files.push(FileInfo {
             name: name.to_owned(),
             span: span,
             lines: lines,
         });
 
+        #[cfg(not(procmacro2_semver_exempt))]
+        self.files.push(FileInfo {
+            span: span,
+            lines: lines,
+        });
+        let _ = name;
+
         span
     }
 
@@ -327,27 +347,29 @@ impl Codemap {
 
 #[derive(Clone, Copy, PartialEq, Eq)]
 pub struct Span {
-    #[cfg(procmacro2_semver_exempt)]
+    #[cfg(span_locations)]
     lo: u32,
-    #[cfg(procmacro2_semver_exempt)]
+    #[cfg(span_locations)]
     hi: u32,
 }
 
 impl Span {
-    #[cfg(not(procmacro2_semver_exempt))]
+    #[cfg(not(span_locations))]
     pub fn call_site() -> Span {
         Span {}
     }
 
-    #[cfg(procmacro2_semver_exempt)]
+    #[cfg(span_locations)]
     pub fn call_site() -> Span {
         Span { lo: 0, hi: 0 }
     }
 
+    #[cfg(procmacro2_semver_exempt)]
     pub fn def_site() -> Span {
         Span::call_site()
     }
 
+    #[cfg(procmacro2_semver_exempt)]
     pub fn resolved_at(&self, _other: Span) -> Span {
         // Stable spans consist only of line/column information, so
         // `resolved_at` and `located_at` only select which span the
@@ -355,6 +377,7 @@ impl Span {
         *self
     }
 
+    #[cfg(procmacro2_semver_exempt)]
     pub fn located_at(&self, other: Span) -> Span {
         other
     }
@@ -370,7 +393,7 @@ impl Span {
         })
     }
 
-    #[cfg(procmacro2_semver_exempt)]
+    #[cfg(span_locations)]
     pub fn start(&self) -> LineColumn {
         CODEMAP.with(|cm| {
             let cm = cm.borrow();
@@ -379,7 +402,7 @@ impl Span {
         })
     }
 
-    #[cfg(procmacro2_semver_exempt)]
+    #[cfg(span_locations)]
     pub fn end(&self) -> LineColumn {
         CODEMAP.with(|cm| {
             let cm = cm.borrow();
@@ -414,6 +437,12 @@ impl fmt::Debug for Span {
     }
 }
 
+pub fn debug_span_field_if_nontrivial(debug: &mut fmt::DebugStruct, span: Span) {
+    if cfg!(procmacro2_semver_exempt) {
+        debug.field("span", &span);
+    }
+}
+
 #[derive(Clone)]
 pub struct Group {
     delimiter: Delimiter,
@@ -442,10 +471,12 @@ impl Group {
         self.span
     }
 
+    #[cfg(procmacro2_semver_exempt)]
     pub fn span_open(&self) -> Span {
         self.span
     }
 
+    #[cfg(procmacro2_semver_exempt)]
     pub fn span_close(&self) -> Span {
         self.span
     }
@@ -782,16 +813,16 @@ fn token_stream(mut input: Cursor) -> PResult<TokenStream> {
     Ok((input, TokenStream { inner: trees }))
 }
 
-#[cfg(not(procmacro2_semver_exempt))]
+#[cfg(not(span_locations))]
 fn spanned<'a, T>(
     input: Cursor<'a>,
     f: fn(Cursor<'a>) -> PResult<'a, T>,
 ) -> PResult<'a, (T, ::Span)> {
     let (a, b) = f(skip_whitespace(input))?;
-    Ok((a, ((b, ::Span::_new_stable(Span {})))))
+    Ok((a, ((b, ::Span::_new_stable(Span::call_site())))))
 }
 
-#[cfg(procmacro2_semver_exempt)]
+#[cfg(span_locations)]
 fn spanned<'a, T>(
     input: Cursor<'a>,
     f: fn(Cursor<'a>) -> PResult<'a, T>,
diff --git a/third_party/rust/proc-macro2/src/lib.rs b/third_party/rust/proc-macro2/src/lib.rs
index db51272275ab..25dd705c2e4c 100644
--- a/third_party/rust/proc-macro2/src/lib.rs
+++ b/third_party/rust/proc-macro2/src/lib.rs
@@ -1,35 +1,72 @@
-//! A "shim crate" intended to multiplex the [`proc_macro`] API on to stable
-//! Rust.
+//! A wrapper around the procedural macro API of the compiler's [`proc_macro`]
+//! crate. This library serves three purposes:
 //!
-//! Procedural macros in Rust operate over the upstream
-//! [`proc_macro::TokenStream`][ts] type. This type currently is quite
-//! conservative and exposed no internal implementation details. Nightly
-//! compilers, however, contain a much richer interface. This richer interface
-//! allows fine-grained inspection of the token stream which avoids
-//! stringification/re-lexing and also preserves span information.
+//! [`proc_macro`]: https://doc.rust-lang.org/proc_macro/
 //!
-//! The upcoming APIs added to [`proc_macro`] upstream are the foundation for
-//! productive procedural macros in the ecosystem. To help prepare the ecosystem
-//! for using them this crate serves to both compile on stable and nightly and
-//! mirrors the API-to-be. The intention is that procedural macros which switch
-//! to use this crate will be trivially able to switch to the upstream
-//! `proc_macro` crate once its API stabilizes.
+//! - **Bring proc-macro-like functionality to other contexts like build.rs and
+//!   main.rs.** Types from `proc_macro` are entirely specific to procedural
+//!   macros and cannot ever exist in code outside of a procedural macro.
+//!   Meanwhile `proc_macro2` types may exist anywhere including non-macro code.
+//!   By developing foundational libraries like [syn] and [quote] against
+//!   `proc_macro2` rather than `proc_macro`, the procedural macro ecosystem
+//!   becomes easily applicable to many other use cases and we avoid
+//!   reimplementing non-macro equivalents of those libraries.
 //!
-//! In the meantime this crate also has a `nightly` Cargo feature which
-//! enables it to reimplement itself with the unstable API of [`proc_macro`].
-//! This'll allow immediate usage of the beneficial upstream API, particularly
-//! around preserving span information.
+//! - **Make procedural macros unit testable.** As a consequence of being
+//!   specific to procedural macros, nothing that uses `proc_macro` can be
+//!   executed from a unit test. In order for helper libraries or components of
+//!   a macro to be testable in isolation, they must be implemented using
+//!   `proc_macro2`.
 //!
-//! # Unstable Features
+//! - **Provide the latest and greatest APIs across all compiler versions.**
+//!   Procedural macros were first introduced to Rust in 1.15.0 with an
+//!   extremely minimal interface. Since then, many improvements have landed to
+//!   make macros more flexible and easier to write. This library tracks the
+//!   procedural macro API of the most recent stable compiler but employs a
+//!   polyfill to provide that API consistently across any compiler since
+//!   1.15.0.
 //!
-//! `proc-macro2` supports exporting some methods from `proc_macro` which are
-//! currently highly unstable, and may not be stabilized in the first pass of
-//! `proc_macro` stabilizations. These features are not exported by default.
-//! Minor versions of `proc-macro2` may make breaking changes to them at any
-//! time.
+//! [syn]: https://github.com/dtolnay/syn
+//! [quote]: https://github.com/dtolnay/quote
 //!
-//! To enable these features, the `procmacro2_semver_exempt` config flag must be
-//! passed to rustc.
+//! # Usage
+//!
+//! The skeleton of a typical procedural macro typically looks like this:
+//!
+//! ```edition2018
+//! extern crate proc_macro;
+//!
+//! # const IGNORE: &str = stringify! {
+//! #[proc_macro_derive(MyDerive)]
+//! # };
+//! pub fn my_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+//!     let input = proc_macro2::TokenStream::from(input);
+//!
+//!     let output: proc_macro2::TokenStream = {
+//!         /* transform input */
+//!         # input
+//!     };
+//!
+//!     proc_macro::TokenStream::from(output)
+//! }
+//! ```
+//!
+//! If parsing with [Syn], you'll use [`parse_macro_input!`] instead to
+//! propagate parse errors correctly back to the compiler when parsing fails.
+//!
+//! [`parse_macro_input!`]: https://docs.rs/syn/0.15/syn/macro.parse_macro_input.html
+//!
+//! # Unstable features
+//!
+//! The default feature set of proc-macro2 tracks the most recent stable
+//! compiler API. Functionality in `proc_macro` that is not yet stable is not
+//! exposed by proc-macro2 by default.
+//!
+//! To opt into the additional APIs available in the most recent nightly
+//! compiler, the `procmacro2_semver_exempt` config flag must be passed to
+//! rustc. As usual, we will polyfill those nightly-only APIs all the way back
+//! to Rust 1.15.0. As these are unstable APIs that track the nightly compiler,
+//! minor versions of proc-macro2 may make breaking changes to them at any time.
 //!
 //! ```sh
 //! RUSTFLAGS='--cfg procmacro2_semver_exempt' cargo build
@@ -39,15 +76,12 @@
 //! depends on your crate. This infectious nature is intentional, as it serves
 //! as a reminder that you are outside of the normal semver guarantees.
 //!
-//! [`proc_macro`]: https://doc.rust-lang.org/proc_macro/
-//! [ts]: https://doc.rust-lang.org/proc_macro/struct.TokenStream.html
+//! Semver exempt methods are marked as such in the proc-macro2 documentation.
 
 // Proc-macro2 types in rustdoc of other crates get linked to here.
-#![doc(html_root_url = "https://docs.rs/proc-macro2/0.4.24")]
-#![cfg_attr(
-    super_unstable,
-    feature(proc_macro_raw_ident, proc_macro_span, proc_macro_def_site)
-)]
+#![doc(html_root_url = "https://docs.rs/proc-macro2/0.4.27")]
+#![cfg_attr(nightly, feature(proc_macro_span))]
+#![cfg_attr(super_unstable, feature(proc_macro_raw_ident, proc_macro_def_site))]
 
 #[cfg(use_proc_macro)]
 extern crate proc_macro;
@@ -65,11 +99,11 @@ use std::str::FromStr;
 
 #[macro_use]
 mod strnom;
-mod stable;
+mod fallback;
 
 #[cfg(not(wrap_proc_macro))]
-use stable as imp;
-#[path = "unstable.rs"]
+use fallback as imp;
+#[path = "wrapper.rs"]
 #[cfg(wrap_proc_macro)]
 mod imp;
 
@@ -100,7 +134,7 @@ impl TokenStream {
         }
     }
 
-    fn _new_stable(inner: stable::TokenStream) -> TokenStream {
+    fn _new_stable(inner: fallback::TokenStream) -> TokenStream {
         TokenStream {
             inner: inner.into(),
             _marker: marker::PhantomData,
@@ -266,7 +300,7 @@ impl fmt::Debug for SourceFile {
 /// A line-column pair representing the start or end of a `Span`.
 ///
 /// This type is semver exempt and not exposed by default.
-#[cfg(procmacro2_semver_exempt)]
+#[cfg(span_locations)]
 pub struct LineColumn {
     /// The 1-indexed line in the source file on which the span starts or ends
     /// (inclusive).
@@ -291,7 +325,7 @@ impl Span {
         }
     }
 
-    fn _new_stable(inner: stable::Span) -> Span {
+    fn _new_stable(inner: fallback::Span) -> Span {
         Span {
             inner: inner.into(),
             _marker: marker::PhantomData,
@@ -333,11 +367,26 @@ impl Span {
         Span::_new(self.inner.located_at(other.inner))
     }
 
-    /// This method is only available when the `"nightly"` feature is enabled.
+    /// Convert `proc_macro2::Span` to `proc_macro::Span`.
+    ///
+    /// This method is available when building with a nightly compiler, or when
+    /// building with rustc 1.29+ *without* semver exempt features.
+    ///
+    /// # Panics
+    ///
+    /// Panics if called from outside of a procedural macro. Unlike
+    /// `proc_macro2::Span`, the `proc_macro::Span` type can only exist within
+    /// the context of a procedural macro invocation.
+    #[cfg(wrap_proc_macro)]
+    pub fn unwrap(self) -> proc_macro::Span {
+        self.inner.unwrap()
+    }
+
+    // Soft deprecated. Please use Span::unwrap.
+    #[cfg(wrap_proc_macro)]
     #[doc(hidden)]
-    #[cfg(any(feature = "nightly", super_unstable))]
     pub fn unstable(self) -> proc_macro::Span {
-        self.inner.unstable()
+        self.unwrap()
     }
 
     /// The original source file into which this span points.
@@ -350,8 +399,8 @@ impl Span {
 
     /// Get the starting line/column in the source file for this span.
     ///
-    /// This method is semver exempt and not exposed by default.
-    #[cfg(procmacro2_semver_exempt)]
+    /// This method requires the `"span-locations"` feature to be enabled.
+    #[cfg(span_locations)]
     pub fn start(&self) -> LineColumn {
         let imp::LineColumn { line, column } = self.inner.start();
         LineColumn {
@@ -362,8 +411,8 @@ impl Span {
 
     /// Get the ending line/column in the source file for this span.
     ///
-    /// This method is semver exempt and not exposed by default.
-    #[cfg(procmacro2_semver_exempt)]
+    /// This method requires the `"span-locations"` feature to be enabled.
+    #[cfg(span_locations)]
     pub fn end(&self) -> LineColumn {
         let imp::LineColumn { line, column } = self.inner.end();
         LineColumn {
@@ -487,8 +536,7 @@ impl fmt::Debug for TokenTree {
             TokenTree::Ident(ref t) => {
                 let mut debug = f.debug_struct("Ident");
                 debug.field("sym", &format_args!("{}", t));
-                #[cfg(any(feature = "nightly", procmacro2_semver_exempt))]
-                debug.field("span", &t.span());
+                imp::debug_span_field_if_nontrivial(&mut debug, t.span().inner);
                 debug.finish()
             }
             TokenTree::Punct(ref t) => t.fmt(f),
@@ -527,12 +575,10 @@ pub enum Delimiter {
 
 impl Group {
     fn _new(inner: imp::Group) -> Self {
-        Group {
-            inner: inner,
-        }
+        Group { inner: inner }
     }
 
-    fn _new_stable(inner: stable::Group) -> Self {
+    fn _new_stable(inner: fallback::Group) -> Self {
         Group {
             inner: inner.into(),
         }
@@ -699,8 +745,7 @@ impl fmt::Debug for Punct {
         let mut debug = fmt.debug_struct("Punct");
         debug.field("op", &self.op);
         debug.field("spacing", &self.spacing);
-        #[cfg(procmacro2_semver_exempt)]
-        debug.field("span", &self.span);
+        imp::debug_span_field_if_nontrivial(&mut debug, self.span.inner);
         debug.finish()
     }
 }
@@ -727,9 +772,7 @@ impl fmt::Debug for Punct {
 /// A span must be provided explicitly which governs the name resolution
 /// behavior of the resulting identifier.
 ///
-/// ```rust
-/// extern crate proc_macro2;
-///
+/// ```edition2018
 /// use proc_macro2::{Ident, Span};
 ///
 /// fn main() {
@@ -741,13 +784,9 @@ impl fmt::Debug for Punct {
 ///
 /// An ident can be interpolated into a token stream using the `quote!` macro.
 ///
-/// ```rust
-/// #[macro_use]
-/// extern crate quote;
-///
-/// extern crate proc_macro2;
-///
+/// ```edition2018
 /// use proc_macro2::{Ident, Span};
+/// use quote::quote;
 ///
 /// fn main() {
 ///     let ident = Ident::new("demo", Span::call_site());
@@ -764,9 +803,7 @@ impl fmt::Debug for Punct {
 /// A string representation of the ident is available through the `to_string()`
 /// method.
 ///
-/// ```rust
-/// # extern crate proc_macro2;
-/// #
+/// ```edition2018
 /// # use proc_macro2::{Ident, Span};
 /// #
 /// # let ident = Ident::new("another_identifier", Span::call_site());
@@ -954,7 +991,7 @@ impl Literal {
         }
     }
 
-    fn _new_stable(inner: stable::Literal) -> Literal {
+    fn _new_stable(inner: fallback::Literal) -> Literal {
         Literal {
             inner: inner.into(),
             _marker: marker::PhantomData,
diff --git a/third_party/rust/proc-macro2/src/strnom.rs b/third_party/rust/proc-macro2/src/strnom.rs
index 099dab9228c2..96789d569147 100644
--- a/third_party/rust/proc-macro2/src/strnom.rs
+++ b/third_party/rust/proc-macro2/src/strnom.rs
@@ -4,23 +4,23 @@ use std::str::{Bytes, CharIndices, Chars};
 
 use unicode_xid::UnicodeXID;
 
-use stable::LexError;
+use fallback::LexError;
 
 #[derive(Copy, Clone, Eq, PartialEq)]
 pub struct Cursor<'a> {
     pub rest: &'a str,
-    #[cfg(procmacro2_semver_exempt)]
+    #[cfg(span_locations)]
     pub off: u32,
 }
 
 impl<'a> Cursor<'a> {
-    #[cfg(not(procmacro2_semver_exempt))]
+    #[cfg(not(span_locations))]
     pub fn advance(&self, amt: usize) -> Cursor<'a> {
         Cursor {
             rest: &self.rest[amt..],
         }
     }
-    #[cfg(procmacro2_semver_exempt)]
+    #[cfg(span_locations)]
     pub fn advance(&self, amt: usize) -> Cursor<'a> {
         Cursor {
             rest: &self.rest[amt..],
diff --git a/third_party/rust/proc-macro2/src/unstable.rs b/third_party/rust/proc-macro2/src/wrapper.rs
similarity index 58%
rename from third_party/rust/proc-macro2/src/unstable.rs
rename to third_party/rust/proc-macro2/src/wrapper.rs
index c4cf11a8da5f..c45dff89d76c 100644
--- a/third_party/rust/proc-macro2/src/unstable.rs
+++ b/third_party/rust/proc-macro2/src/wrapper.rs
@@ -1,5 +1,3 @@
-#![cfg_attr(not(super_unstable), allow(dead_code))]
-
 use std::fmt;
 use std::iter;
 use std::panic::{self, PanicInfo};
@@ -7,20 +5,20 @@ use std::panic::{self, PanicInfo};
 use std::path::PathBuf;
 use std::str::FromStr;
 
+use fallback;
 use proc_macro;
-use stable;
 
 use {Delimiter, Punct, Spacing, TokenTree};
 
 #[derive(Clone)]
 pub enum TokenStream {
-    Nightly(proc_macro::TokenStream),
-    Stable(stable::TokenStream),
+    Compiler(proc_macro::TokenStream),
+    Fallback(fallback::TokenStream),
 }
 
 pub enum LexError {
-    Nightly(proc_macro::LexError),
-    Stable(stable::LexError),
+    Compiler(proc_macro::LexError),
+    Fallback(fallback::LexError),
 }
 
 fn nightly_works() -> bool {
@@ -87,30 +85,30 @@ fn mismatch() -> ! {
 impl TokenStream {
     pub fn new() -> TokenStream {
         if nightly_works() {
-            TokenStream::Nightly(proc_macro::TokenStream::new())
+            TokenStream::Compiler(proc_macro::TokenStream::new())
         } else {
-            TokenStream::Stable(stable::TokenStream::new())
+            TokenStream::Fallback(fallback::TokenStream::new())
         }
     }
 
     pub fn is_empty(&self) -> bool {
         match self {
-            TokenStream::Nightly(tts) => tts.is_empty(),
-            TokenStream::Stable(tts) => tts.is_empty(),
+            TokenStream::Compiler(tts) => tts.is_empty(),
+            TokenStream::Fallback(tts) => tts.is_empty(),
         }
     }
 
     fn unwrap_nightly(self) -> proc_macro::TokenStream {
         match self {
-            TokenStream::Nightly(s) => s,
-            TokenStream::Stable(_) => mismatch(),
+            TokenStream::Compiler(s) => s,
+            TokenStream::Fallback(_) => mismatch(),
         }
     }
 
-    fn unwrap_stable(self) -> stable::TokenStream {
+    fn unwrap_stable(self) -> fallback::TokenStream {
         match self {
-            TokenStream::Nightly(_) => mismatch(),
-            TokenStream::Stable(s) => s,
+            TokenStream::Compiler(_) => mismatch(),
+            TokenStream::Fallback(s) => s,
         }
     }
 }
@@ -120,9 +118,9 @@ impl FromStr for TokenStream {
 
     fn from_str(src: &str) -> Result<TokenStream, LexError> {
         if nightly_works() {
-            Ok(TokenStream::Nightly(src.parse()?))
+            Ok(TokenStream::Compiler(src.parse()?))
         } else {
-            Ok(TokenStream::Stable(src.parse()?))
+            Ok(TokenStream::Fallback(src.parse()?))
         }
     }
 }
@@ -130,37 +128,37 @@ impl FromStr for TokenStream {
 impl fmt::Display for TokenStream {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            TokenStream::Nightly(tts) => tts.fmt(f),
-            TokenStream::Stable(tts) => tts.fmt(f),
+            TokenStream::Compiler(tts) => tts.fmt(f),
+            TokenStream::Fallback(tts) => tts.fmt(f),
         }
     }
 }
 
 impl From<proc_macro::TokenStream> for TokenStream {
     fn from(inner: proc_macro::TokenStream) -> TokenStream {
-        TokenStream::Nightly(inner)
+        TokenStream::Compiler(inner)
     }
 }
 
 impl From<TokenStream> for proc_macro::TokenStream {
     fn from(inner: TokenStream) -> proc_macro::TokenStream {
         match inner {
-            TokenStream::Nightly(inner) => inner,
-            TokenStream::Stable(inner) => inner.to_string().parse().unwrap(),
+            TokenStream::Compiler(inner) => inner,
+            TokenStream::Fallback(inner) => inner.to_string().parse().unwrap(),
         }
     }
 }
 
-impl From<stable::TokenStream> for TokenStream {
-    fn from(inner: stable::TokenStream) -> TokenStream {
-        TokenStream::Stable(inner)
+impl From<fallback::TokenStream> for TokenStream {
+    fn from(inner: fallback::TokenStream) -> TokenStream {
+        TokenStream::Fallback(inner)
     }
 }
 
 impl From<TokenTree> for TokenStream {
     fn from(token: TokenTree) -> TokenStream {
         if !nightly_works() {
-            return TokenStream::Stable(token.into());
+            return TokenStream::Fallback(token.into());
         }
         let tt: proc_macro::TokenTree = match token {
             TokenTree::Group(tt) => tt.inner.unwrap_nightly().into(),
@@ -176,7 +174,7 @@ impl From<TokenTree> for TokenStream {
             TokenTree::Ident(tt) => tt.inner.unwrap_nightly().into(),
             TokenTree::Literal(tt) => tt.inner.unwrap_nightly().into(),
         };
-        TokenStream::Nightly(tt.into())
+        TokenStream::Compiler(tt.into())
     }
 }
 
@@ -187,12 +185,12 @@ impl iter::FromIterator<TokenTree> for TokenStream {
                 .into_iter()
                 .map(TokenStream::from)
                 .flat_map(|t| match t {
-                    TokenStream::Nightly(s) => s,
-                    TokenStream::Stable(_) => mismatch(),
+                    TokenStream::Compiler(s) => s,
+                    TokenStream::Fallback(_) => mismatch(),
                 });
-            TokenStream::Nightly(trees.collect())
+            TokenStream::Compiler(trees.collect())
         } else {
-            TokenStream::Stable(trees.into_iter().collect())
+            TokenStream::Fallback(trees.into_iter().collect())
         }
     }
 }
@@ -202,36 +200,31 @@ impl iter::FromIterator<TokenStream> for TokenStream {
         let mut streams = streams.into_iter();
         match streams.next() {
             #[cfg(slow_extend)]
-            Some(TokenStream::Nightly(first)) => {
-                let stream = iter::once(first).chain(streams.map(|s| {
-                    match s {
-                        TokenStream::Nightly(s) => s,
-                        TokenStream::Stable(_) => mismatch(),
-                    }
-                })).collect();
-                TokenStream::Nightly(stream)
+            Some(TokenStream::Compiler(first)) => {
+                let stream = iter::once(first)
+                    .chain(streams.map(|s| match s {
+                        TokenStream::Compiler(s) => s,
+                        TokenStream::Fallback(_) => mismatch(),
+                    }))
+                    .collect();
+                TokenStream::Compiler(stream)
             }
             #[cfg(not(slow_extend))]
-            Some(TokenStream::Nightly(mut first)) => {
-                first.extend(streams.map(|s| {
-                    match s {
-                        TokenStream::Nightly(s) => s,
-                        TokenStream::Stable(_) => mismatch(),
-                    }
+            Some(TokenStream::Compiler(mut first)) => {
+                first.extend(streams.map(|s| match s {
+                    TokenStream::Compiler(s) => s,
+                    TokenStream::Fallback(_) => mismatch(),
                 }));
-                TokenStream::Nightly(first)
+                TokenStream::Compiler(first)
             }
-            Some(TokenStream::Stable(mut first)) => {
-                first.extend(streams.map(|s| {
-                    match s {
-                        TokenStream::Stable(s) => s,
-                        TokenStream::Nightly(_) => mismatch(),
-                    }
+            Some(TokenStream::Fallback(mut first)) => {
+                first.extend(streams.map(|s| match s {
+                    TokenStream::Fallback(s) => s,
+                    TokenStream::Compiler(_) => mismatch(),
                 }));
-                TokenStream::Stable(first)
+                TokenStream::Fallback(first)
             }
             None => TokenStream::new(),
-
         }
     }
 }
@@ -239,7 +232,7 @@ impl iter::FromIterator<TokenStream> for TokenStream {
 impl Extend<TokenTree> for TokenStream {
     fn extend<I: IntoIterator<Item = TokenTree>>(&mut self, streams: I) {
         match self {
-            TokenStream::Nightly(tts) => {
+            TokenStream::Compiler(tts) => {
                 #[cfg(not(slow_extend))]
                 {
                     tts.extend(
@@ -250,21 +243,19 @@ impl Extend<TokenTree> for TokenStream {
                 }
                 #[cfg(slow_extend)]
                 {
-                    *tts = tts
-                        .clone()
-                        .into_iter()
-                        .chain(
-                            streams
-                                .into_iter()
-                                .map(TokenStream::from)
-                                .flat_map(|t| match t {
-                                    TokenStream::Nightly(tts) => tts.into_iter(),
+                    *tts =
+                        tts.clone()
+                            .into_iter()
+                            .chain(streams.into_iter().map(TokenStream::from).flat_map(
+                                |t| match t {
+                                    TokenStream::Compiler(tts) => tts.into_iter(),
                                     _ => mismatch(),
-                                }),
-                        ).collect();
+                                },
+                            ))
+                            .collect();
                 }
             }
-            TokenStream::Stable(tts) => tts.extend(streams),
+            TokenStream::Fallback(tts) => tts.extend(streams),
         }
     }
 }
@@ -272,7 +263,7 @@ impl Extend<TokenTree> for TokenStream {
 impl Extend<TokenStream> for TokenStream {
     fn extend<I: IntoIterator<Item = TokenStream>>(&mut self, streams: I) {
         match self {
-            TokenStream::Nightly(tts) => {
+            TokenStream::Compiler(tts) => {
                 #[cfg(not(slow_extend))]
                 {
                     tts.extend(streams.into_iter().map(|stream| stream.unwrap_nightly()));
@@ -282,17 +273,14 @@ impl Extend<TokenStream> for TokenStream {
                     *tts = tts
                         .clone()
                         .into_iter()
-                        .chain(
-                            streams
-                                .into_iter()
-                                .flat_map(|t| match t {
-                                    TokenStream::Nightly(tts) => tts.into_iter(),
-                                    _ => mismatch(),
-                                }),
-                        ).collect();
+                        .chain(streams.into_iter().flat_map(|t| match t {
+                            TokenStream::Compiler(tts) => tts.into_iter(),
+                            _ => mismatch(),
+                        }))
+                        .collect();
                 }
             }
-            TokenStream::Stable(tts) => {
+            TokenStream::Fallback(tts) => {
                 tts.extend(streams.into_iter().map(|stream| stream.unwrap_stable()))
             }
         }
@@ -302,36 +290,36 @@ impl Extend<TokenStream> for TokenStream {
 impl fmt::Debug for TokenStream {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            TokenStream::Nightly(tts) => tts.fmt(f),
-            TokenStream::Stable(tts) => tts.fmt(f),
+            TokenStream::Compiler(tts) => tts.fmt(f),
+            TokenStream::Fallback(tts) => tts.fmt(f),
         }
     }
 }
 
 impl From<proc_macro::LexError> for LexError {
     fn from(e: proc_macro::LexError) -> LexError {
-        LexError::Nightly(e)
+        LexError::Compiler(e)
     }
 }
 
-impl From<stable::LexError> for LexError {
-    fn from(e: stable::LexError) -> LexError {
-        LexError::Stable(e)
+impl From<fallback::LexError> for LexError {
+    fn from(e: fallback::LexError) -> LexError {
+        LexError::Fallback(e)
     }
 }
 
 impl fmt::Debug for LexError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            LexError::Nightly(e) => e.fmt(f),
-            LexError::Stable(e) => e.fmt(f),
+            LexError::Compiler(e) => e.fmt(f),
+            LexError::Fallback(e) => e.fmt(f),
         }
     }
 }
 
 pub enum TokenTreeIter {
-    Nightly(proc_macro::token_stream::IntoIter),
-    Stable(stable::TokenTreeIter),
+    Compiler(proc_macro::token_stream::IntoIter),
+    Fallback(fallback::TokenTreeIter),
 }
 
 impl IntoIterator for TokenStream {
@@ -340,8 +328,8 @@ impl IntoIterator for TokenStream {
 
     fn into_iter(self) -> TokenTreeIter {
         match self {
-            TokenStream::Nightly(tts) => TokenTreeIter::Nightly(tts.into_iter()),
-            TokenStream::Stable(tts) => TokenTreeIter::Stable(tts.into_iter()),
+            TokenStream::Compiler(tts) => TokenTreeIter::Compiler(tts.into_iter()),
+            TokenStream::Fallback(tts) => TokenTreeIter::Fallback(tts.into_iter()),
         }
     }
 }
@@ -351,29 +339,29 @@ impl Iterator for TokenTreeIter {
 
     fn next(&mut self) -> Option<TokenTree> {
         let token = match self {
-            TokenTreeIter::Nightly(iter) => iter.next()?,
-            TokenTreeIter::Stable(iter) => return iter.next(),
+            TokenTreeIter::Compiler(iter) => iter.next()?,
+            TokenTreeIter::Fallback(iter) => return iter.next(),
         };
         Some(match token {
-            proc_macro::TokenTree::Group(tt) => ::Group::_new(Group::Nightly(tt)).into(),
+            proc_macro::TokenTree::Group(tt) => ::Group::_new(Group::Compiler(tt)).into(),
             proc_macro::TokenTree::Punct(tt) => {
                 let spacing = match tt.spacing() {
                     proc_macro::Spacing::Joint => Spacing::Joint,
                     proc_macro::Spacing::Alone => Spacing::Alone,
                 };
                 let mut o = Punct::new(tt.as_char(), spacing);
-                o.set_span(::Span::_new(Span::Nightly(tt.span())));
+                o.set_span(::Span::_new(Span::Compiler(tt.span())));
                 o.into()
             }
-            proc_macro::TokenTree::Ident(s) => ::Ident::_new(Ident::Nightly(s)).into(),
-            proc_macro::TokenTree::Literal(l) => ::Literal::_new(Literal::Nightly(l)).into(),
+            proc_macro::TokenTree::Ident(s) => ::Ident::_new(Ident::Compiler(s)).into(),
+            proc_macro::TokenTree::Literal(l) => ::Literal::_new(Literal::Compiler(l)).into(),
         })
     }
 
     fn size_hint(&self) -> (usize, Option<usize>) {
         match self {
-            TokenTreeIter::Nightly(tts) => tts.size_hint(),
-            TokenTreeIter::Stable(tts) => tts.size_hint(),
+            TokenTreeIter::Compiler(tts) => tts.size_hint(),
+            TokenTreeIter::Fallback(tts) => tts.size_hint(),
         }
     }
 }
@@ -387,28 +375,28 @@ impl fmt::Debug for TokenTreeIter {
 #[derive(Clone, PartialEq, Eq)]
 #[cfg(super_unstable)]
 pub enum SourceFile {
-    Nightly(proc_macro::SourceFile),
-    Stable(stable::SourceFile),
+    Compiler(proc_macro::SourceFile),
+    Fallback(fallback::SourceFile),
 }
 
 #[cfg(super_unstable)]
 impl SourceFile {
     fn nightly(sf: proc_macro::SourceFile) -> Self {
-        SourceFile::Nightly(sf)
+        SourceFile::Compiler(sf)
     }
 
     /// Get the path to this source file as a string.
     pub fn path(&self) -> PathBuf {
         match self {
-            SourceFile::Nightly(a) => a.path(),
-            SourceFile::Stable(a) => a.path(),
+            SourceFile::Compiler(a) => a.path(),
+            SourceFile::Fallback(a) => a.path(),
         }
     }
 
     pub fn is_real(&self) -> bool {
         match self {
-            SourceFile::Nightly(a) => a.is_real(),
-            SourceFile::Stable(a) => a.is_real(),
+            SourceFile::Compiler(a) => a.is_real(),
+            SourceFile::Fallback(a) => a.is_real(),
         }
     }
 }
@@ -417,12 +405,13 @@ impl SourceFile {
 impl fmt::Debug for SourceFile {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            SourceFile::Nightly(a) => a.fmt(f),
-            SourceFile::Stable(a) => a.fmt(f),
+            SourceFile::Compiler(a) => a.fmt(f),
+            SourceFile::Fallback(a) => a.fmt(f),
         }
     }
 }
 
+#[cfg(any(super_unstable, feature = "span-locations"))]
 pub struct LineColumn {
     pub line: usize,
     pub column: usize,
@@ -430,33 +419,33 @@ pub struct LineColumn {
 
 #[derive(Copy, Clone)]
 pub enum Span {
-    Nightly(proc_macro::Span),
-    Stable(stable::Span),
+    Compiler(proc_macro::Span),
+    Fallback(fallback::Span),
 }
 
 impl Span {
     pub fn call_site() -> Span {
         if nightly_works() {
-            Span::Nightly(proc_macro::Span::call_site())
+            Span::Compiler(proc_macro::Span::call_site())
         } else {
-            Span::Stable(stable::Span::call_site())
+            Span::Fallback(fallback::Span::call_site())
         }
     }
 
     #[cfg(super_unstable)]
     pub fn def_site() -> Span {
         if nightly_works() {
-            Span::Nightly(proc_macro::Span::def_site())
+            Span::Compiler(proc_macro::Span::def_site())
         } else {
-            Span::Stable(stable::Span::def_site())
+            Span::Fallback(fallback::Span::def_site())
         }
     }
 
     #[cfg(super_unstable)]
     pub fn resolved_at(&self, other: Span) -> Span {
         match (self, other) {
-            (Span::Nightly(a), Span::Nightly(b)) => Span::Nightly(a.resolved_at(b)),
-            (Span::Stable(a), Span::Stable(b)) => Span::Stable(a.resolved_at(b)),
+            (Span::Compiler(a), Span::Compiler(b)) => Span::Compiler(a.resolved_at(b)),
+            (Span::Fallback(a), Span::Fallback(b)) => Span::Fallback(a.resolved_at(b)),
             _ => mismatch(),
         }
     }
@@ -464,50 +453,56 @@ impl Span {
     #[cfg(super_unstable)]
     pub fn located_at(&self, other: Span) -> Span {
         match (self, other) {
-            (Span::Nightly(a), Span::Nightly(b)) => Span::Nightly(a.located_at(b)),
-            (Span::Stable(a), Span::Stable(b)) => Span::Stable(a.located_at(b)),
+            (Span::Compiler(a), Span::Compiler(b)) => Span::Compiler(a.located_at(b)),
+            (Span::Fallback(a), Span::Fallback(b)) => Span::Fallback(a.located_at(b)),
             _ => mismatch(),
         }
     }
 
-    pub fn unstable(self) -> proc_macro::Span {
+    pub fn unwrap(self) -> proc_macro::Span {
         match self {
-            Span::Nightly(s) => s,
-            Span::Stable(_) => mismatch(),
+            Span::Compiler(s) => s,
+            Span::Fallback(_) => panic!("proc_macro::Span is only available in procedural macros"),
         }
     }
 
     #[cfg(super_unstable)]
     pub fn source_file(&self) -> SourceFile {
         match self {
-            Span::Nightly(s) => SourceFile::nightly(s.source_file()),
-            Span::Stable(s) => SourceFile::Stable(s.source_file()),
+            Span::Compiler(s) => SourceFile::nightly(s.source_file()),
+            Span::Fallback(s) => SourceFile::Fallback(s.source_file()),
         }
     }
 
-    #[cfg(super_unstable)]
+    #[cfg(any(super_unstable, feature = "span-locations"))]
     pub fn start(&self) -> LineColumn {
         match self {
-            Span::Nightly(s) => {
+            #[cfg(nightly)]
+            Span::Compiler(s) => {
                 let proc_macro::LineColumn { line, column } = s.start();
                 LineColumn { line, column }
             }
-            Span::Stable(s) => {
-                let stable::LineColumn { line, column } = s.start();
+            #[cfg(not(nightly))]
+            Span::Compiler(_) => LineColumn { line: 0, column: 0 },
+            Span::Fallback(s) => {
+                let fallback::LineColumn { line, column } = s.start();
                 LineColumn { line, column }
             }
         }
     }
 
-    #[cfg(super_unstable)]
+    #[cfg(any(super_unstable, feature = "span-locations"))]
     pub fn end(&self) -> LineColumn {
         match self {
-            Span::Nightly(s) => {
+            #[cfg(nightly)]
+            Span::Compiler(s) => {
                 let proc_macro::LineColumn { line, column } = s.end();
                 LineColumn { line, column }
             }
-            Span::Stable(s) => {
-                let stable::LineColumn { line, column } = s.end();
+            #[cfg(not(nightly))]
+            Span::Compiler(_) => LineColumn { line: 0, column: 0 },
+            Span::Fallback(s) => {
+                let fallback::LineColumn { line, column } = s.end();
                 LineColumn { line, column }
             }
         }
@@ -516,8 +511,8 @@ impl Span {
     #[cfg(super_unstable)]
     pub fn join(&self, other: Span) -> Option<Span> {
         let ret = match (self, other) {
-            (Span::Nightly(a), Span::Nightly(b)) => Span::Nightly(a.join(b)?),
-            (Span::Stable(a), Span::Stable(b)) => Span::Stable(a.join(b)?),
+            (Span::Compiler(a), Span::Compiler(b)) => Span::Compiler(a.join(b)?),
+            (Span::Fallback(a), Span::Fallback(b)) => Span::Fallback(a.join(b)?),
             _ => return None,
         };
         Some(ret)
@@ -526,134 +521,143 @@ impl Span {
     #[cfg(super_unstable)]
     pub fn eq(&self, other: &Span) -> bool {
         match (self, other) {
-            (Span::Nightly(a), Span::Nightly(b)) => a.eq(b),
-            (Span::Stable(a), Span::Stable(b)) => a.eq(b),
+            (Span::Compiler(a), Span::Compiler(b)) => a.eq(b),
+            (Span::Fallback(a), Span::Fallback(b)) => a.eq(b),
             _ => false,
         }
     }
 
     fn unwrap_nightly(self) -> proc_macro::Span {
         match self {
-            Span::Nightly(s) => s,
-            Span::Stable(_) => mismatch(),
+            Span::Compiler(s) => s,
+            Span::Fallback(_) => mismatch(),
         }
     }
 }
 
 impl From<proc_macro::Span> for ::Span {
     fn from(proc_span: proc_macro::Span) -> ::Span {
-        ::Span::_new(Span::Nightly(proc_span))
+        ::Span::_new(Span::Compiler(proc_span))
     }
 }
 
-impl From<stable::Span> for Span {
-    fn from(inner: stable::Span) -> Span {
-        Span::Stable(inner)
+impl From<fallback::Span> for Span {
+    fn from(inner: fallback::Span) -> Span {
+        Span::Fallback(inner)
     }
 }
 
 impl fmt::Debug for Span {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            Span::Nightly(s) => s.fmt(f),
-            Span::Stable(s) => s.fmt(f),
+            Span::Compiler(s) => s.fmt(f),
+            Span::Fallback(s) => s.fmt(f),
         }
     }
 }
 
+pub fn debug_span_field_if_nontrivial(debug: &mut fmt::DebugStruct, span: Span) {
+    match span {
+        Span::Compiler(s) => {
+            debug.field("span", &s);
+        }
+        Span::Fallback(s) => fallback::debug_span_field_if_nontrivial(debug, s),
+    }
+}
+
 #[derive(Clone)]
 pub enum Group {
-    Nightly(proc_macro::Group),
-    Stable(stable::Group),
+    Compiler(proc_macro::Group),
+    Fallback(fallback::Group),
 }
 
 impl Group {
     pub fn new(delimiter: Delimiter, stream: TokenStream) -> Group {
         match stream {
-            TokenStream::Nightly(stream) => {
+            TokenStream::Compiler(stream) => {
                 let delimiter = match delimiter {
                     Delimiter::Parenthesis => proc_macro::Delimiter::Parenthesis,
                     Delimiter::Bracket => proc_macro::Delimiter::Bracket,
                     Delimiter::Brace => proc_macro::Delimiter::Brace,
                     Delimiter::None => proc_macro::Delimiter::None,
                 };
-                Group::Nightly(proc_macro::Group::new(delimiter, stream))
+                Group::Compiler(proc_macro::Group::new(delimiter, stream))
             }
-            TokenStream::Stable(stream) => {
-                Group::Stable(stable::Group::new(delimiter, stream))
+            TokenStream::Fallback(stream) => {
+                Group::Fallback(fallback::Group::new(delimiter, stream))
             }
         }
     }
 
     pub fn delimiter(&self) -> Delimiter {
         match self {
-            Group::Nightly(g) => match g.delimiter() {
+            Group::Compiler(g) => match g.delimiter() {
                 proc_macro::Delimiter::Parenthesis => Delimiter::Parenthesis,
                 proc_macro::Delimiter::Bracket => Delimiter::Bracket,
                 proc_macro::Delimiter::Brace => Delimiter::Brace,
                 proc_macro::Delimiter::None => Delimiter::None,
-            }
-            Group::Stable(g) => g.delimiter(),
+            },
+            Group::Fallback(g) => g.delimiter(),
         }
     }
 
     pub fn stream(&self) -> TokenStream {
         match self {
-            Group::Nightly(g) => TokenStream::Nightly(g.stream()),
-            Group::Stable(g) => TokenStream::Stable(g.stream()),
+            Group::Compiler(g) => TokenStream::Compiler(g.stream()),
+            Group::Fallback(g) => TokenStream::Fallback(g.stream()),
         }
     }
 
     pub fn span(&self) -> Span {
         match self {
-            Group::Nightly(g) => Span::Nightly(g.span()),
-            Group::Stable(g) => Span::Stable(g.span()),
+            Group::Compiler(g) => Span::Compiler(g.span()),
+            Group::Fallback(g) => Span::Fallback(g.span()),
         }
     }
 
     #[cfg(super_unstable)]
     pub fn span_open(&self) -> Span {
         match self {
-            Group::Nightly(g) => Span::Nightly(g.span_open()),
-            Group::Stable(g) => Span::Stable(g.span_open()),
+            Group::Compiler(g) => Span::Compiler(g.span_open()),
+            Group::Fallback(g) => Span::Fallback(g.span_open()),
         }
     }
 
     #[cfg(super_unstable)]
     pub fn span_close(&self) -> Span {
         match self {
-            Group::Nightly(g) => Span::Nightly(g.span_close()),
-            Group::Stable(g) => Span::Stable(g.span_close()),
+            Group::Compiler(g) => Span::Compiler(g.span_close()),
+            Group::Fallback(g) => Span::Fallback(g.span_close()),
         }
     }
 
     pub fn set_span(&mut self, span: Span) {
         match (self, span) {
-            (Group::Nightly(g), Span::Nightly(s)) => g.set_span(s),
-            (Group::Stable(g), Span::Stable(s)) => g.set_span(s),
+            (Group::Compiler(g), Span::Compiler(s)) => g.set_span(s),
+            (Group::Fallback(g), Span::Fallback(s)) => g.set_span(s),
             _ => mismatch(),
         }
     }
 
     fn unwrap_nightly(self) -> proc_macro::Group {
         match self {
-            Group::Nightly(g) => g,
-            Group::Stable(_) => mismatch(),
+            Group::Compiler(g) => g,
+            Group::Fallback(_) => mismatch(),
         }
     }
 }
 
-impl From<stable::Group> for Group {
-    fn from(g: stable::Group) -> Self {
-        Group::Stable(g)
+impl From<fallback::Group> for Group {
+    fn from(g: fallback::Group) -> Self {
+        Group::Fallback(g)
     }
 }
 
 impl fmt::Display for Group {
     fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            Group::Nightly(group) => group.fmt(formatter),
-            Group::Stable(group) => group.fmt(formatter),
+            Group::Compiler(group) => group.fmt(formatter),
+            Group::Fallback(group) => group.fmt(formatter),
         }
     }
 }
@@ -661,29 +665,29 @@ impl fmt::Display for Group {
 impl fmt::Debug for Group {
     fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            Group::Nightly(group) => group.fmt(formatter),
-            Group::Stable(group) => group.fmt(formatter),
+            Group::Compiler(group) => group.fmt(formatter),
+            Group::Fallback(group) => group.fmt(formatter),
         }
     }
 }
 
 #[derive(Clone)]
 pub enum Ident {
-    Nightly(proc_macro::Ident),
-    Stable(stable::Ident),
+    Compiler(proc_macro::Ident),
+    Fallback(fallback::Ident),
 }
 
 impl Ident {
     pub fn new(string: &str, span: Span) -> Ident {
         match span {
-            Span::Nightly(s) => Ident::Nightly(proc_macro::Ident::new(string, s)),
-            Span::Stable(s) => Ident::Stable(stable::Ident::new(string, s)),
+            Span::Compiler(s) => Ident::Compiler(proc_macro::Ident::new(string, s)),
+            Span::Fallback(s) => Ident::Fallback(fallback::Ident::new(string, s)),
         }
     }
 
     pub fn new_raw(string: &str, span: Span) -> Ident {
         match span {
-            Span::Nightly(s) => {
+            Span::Compiler(s) => {
                 let p: proc_macro::TokenStream = string.parse().unwrap();
                 let ident = match p.into_iter().next() {
                     Some(proc_macro::TokenTree::Ident(mut i)) => {
@@ -692,31 +696,31 @@ impl Ident {
                     }
                     _ => panic!(),
                 };
-                Ident::Nightly(ident)
+                Ident::Compiler(ident)
             }
-            Span::Stable(s) => Ident::Stable(stable::Ident::new_raw(string, s)),
+            Span::Fallback(s) => Ident::Fallback(fallback::Ident::new_raw(string, s)),
         }
     }
 
     pub fn span(&self) -> Span {
         match self {
-            Ident::Nightly(t) => Span::Nightly(t.span()),
-            Ident::Stable(t) => Span::Stable(t.span()),
+            Ident::Compiler(t) => Span::Compiler(t.span()),
+            Ident::Fallback(t) => Span::Fallback(t.span()),
         }
     }
 
     pub fn set_span(&mut self, span: Span) {
         match (self, span) {
-            (Ident::Nightly(t), Span::Nightly(s)) => t.set_span(s),
-            (Ident::Stable(t), Span::Stable(s)) => t.set_span(s),
+            (Ident::Compiler(t), Span::Compiler(s)) => t.set_span(s),
+            (Ident::Fallback(t), Span::Fallback(s)) => t.set_span(s),
             _ => mismatch(),
         }
     }
 
     fn unwrap_nightly(self) -> proc_macro::Ident {
         match self {
-            Ident::Nightly(s) => s,
-            Ident::Stable(_) => mismatch(),
+            Ident::Compiler(s) => s,
+            Ident::Fallback(_) => mismatch(),
         }
     }
 }
@@ -724,8 +728,8 @@ impl Ident {
 impl PartialEq for Ident {
     fn eq(&self, other: &Ident) -> bool {
         match (self, other) {
-            (Ident::Nightly(t), Ident::Nightly(o)) => t.to_string() == o.to_string(),
-            (Ident::Stable(t), Ident::Stable(o)) => t == o,
+            (Ident::Compiler(t), Ident::Compiler(o)) => t.to_string() == o.to_string(),
+            (Ident::Fallback(t), Ident::Fallback(o)) => t == o,
             _ => mismatch(),
         }
     }
@@ -738,8 +742,8 @@ where
     fn eq(&self, other: &T) -> bool {
         let other = other.as_ref();
         match self {
-            Ident::Nightly(t) => t.to_string() == other,
-            Ident::Stable(t) => t == other,
+            Ident::Compiler(t) => t.to_string() == other,
+            Ident::Fallback(t) => t == other,
         }
     }
 }
@@ -747,8 +751,8 @@ where
 impl fmt::Display for Ident {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            Ident::Nightly(t) => t.fmt(f),
-            Ident::Stable(t) => t.fmt(f),
+            Ident::Compiler(t) => t.fmt(f),
+            Ident::Fallback(t) => t.fmt(f),
         }
     }
 }
@@ -756,25 +760,25 @@ impl fmt::Display for Ident {
 impl fmt::Debug for Ident {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            Ident::Nightly(t) => t.fmt(f),
-            Ident::Stable(t) => t.fmt(f),
+            Ident::Compiler(t) => t.fmt(f),
+            Ident::Fallback(t) => t.fmt(f),
         }
     }
 }
 
 #[derive(Clone)]
 pub enum Literal {
-    Nightly(proc_macro::Literal),
-    Stable(stable::Literal),
+    Compiler(proc_macro::Literal),
+    Fallback(fallback::Literal),
 }
 
 macro_rules! suffixed_numbers {
     ($($name:ident => $kind:ident,)*) => ($(
         pub fn $name(n: $kind) -> Literal {
             if nightly_works() {
-                Literal::Nightly(proc_macro::Literal::$name(n))
+                Literal::Compiler(proc_macro::Literal::$name(n))
             } else {
-                Literal::Stable(stable::Literal::$name(n))
+                Literal::Fallback(fallback::Literal::$name(n))
             }
         }
     )*)
@@ -784,9 +788,9 @@ macro_rules! unsuffixed_integers {
     ($($name:ident => $kind:ident,)*) => ($(
         pub fn $name(n: $kind) -> Literal {
             if nightly_works() {
-                Literal::Nightly(proc_macro::Literal::$name(n))
+                Literal::Compiler(proc_macro::Literal::$name(n))
             } else {
-                Literal::Stable(stable::Literal::$name(n))
+                Literal::Fallback(fallback::Literal::$name(n))
             }
         }
     )*)
@@ -836,78 +840,78 @@ impl Literal {
 
     pub fn f32_unsuffixed(f: f32) -> Literal {
         if nightly_works() {
-            Literal::Nightly(proc_macro::Literal::f32_unsuffixed(f))
+            Literal::Compiler(proc_macro::Literal::f32_unsuffixed(f))
         } else {
-            Literal::Stable(stable::Literal::f32_unsuffixed(f))
+            Literal::Fallback(fallback::Literal::f32_unsuffixed(f))
         }
     }
 
     pub fn f64_unsuffixed(f: f64) -> Literal {
         if nightly_works() {
-            Literal::Nightly(proc_macro::Literal::f64_unsuffixed(f))
+            Literal::Compiler(proc_macro::Literal::f64_unsuffixed(f))
         } else {
-            Literal::Stable(stable::Literal::f64_unsuffixed(f))
+            Literal::Fallback(fallback::Literal::f64_unsuffixed(f))
         }
     }
 
     pub fn string(t: &str) -> Literal {
         if nightly_works() {
-            Literal::Nightly(proc_macro::Literal::string(t))
+            Literal::Compiler(proc_macro::Literal::string(t))
         } else {
-            Literal::Stable(stable::Literal::string(t))
+            Literal::Fallback(fallback::Literal::string(t))
         }
     }
 
     pub fn character(t: char) -> Literal {
         if nightly_works() {
-            Literal::Nightly(proc_macro::Literal::character(t))
+            Literal::Compiler(proc_macro::Literal::character(t))
         } else {
-            Literal::Stable(stable::Literal::character(t))
+            Literal::Fallback(fallback::Literal::character(t))
         }
     }
 
     pub fn byte_string(bytes: &[u8]) -> Literal {
         if nightly_works() {
-            Literal::Nightly(proc_macro::Literal::byte_string(bytes))
+            Literal::Compiler(proc_macro::Literal::byte_string(bytes))
         } else {
-            Literal::Stable(stable::Literal::byte_string(bytes))
+            Literal::Fallback(fallback::Literal::byte_string(bytes))
         }
     }
 
     pub fn span(&self) -> Span {
         match self {
-            Literal::Nightly(lit) => Span::Nightly(lit.span()),
-            Literal::Stable(lit) => Span::Stable(lit.span()),
+            Literal::Compiler(lit) => Span::Compiler(lit.span()),
+            Literal::Fallback(lit) => Span::Fallback(lit.span()),
         }
     }
 
     pub fn set_span(&mut self, span: Span) {
         match (self, span) {
-            (Literal::Nightly(lit), Span::Nightly(s)) => lit.set_span(s),
-            (Literal::Stable(lit), Span::Stable(s)) => lit.set_span(s),
+            (Literal::Compiler(lit), Span::Compiler(s)) => lit.set_span(s),
+            (Literal::Fallback(lit), Span::Fallback(s)) => lit.set_span(s),
             _ => mismatch(),
         }
     }
 
     fn unwrap_nightly(self) -> proc_macro::Literal {
         match self {
-            Literal::Nightly(s) => s,
-            Literal::Stable(_) => mismatch(),
+            Literal::Compiler(s) => s,
+            Literal::Fallback(_) => mismatch(),
         }
     }
 }
 
-impl From<stable::Literal> for Literal {
-    fn from(s: stable::Literal) -> Literal {
-        Literal::Stable(s)
+impl From<fallback::Literal> for Literal {
+    fn from(s: fallback::Literal) -> Literal {
+        Literal::Fallback(s)
     }
 }
 
 impl fmt::Display for Literal {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            Literal::Nightly(t) => t.fmt(f),
-            Literal::Stable(t) => t.fmt(f),
+            Literal::Compiler(t) => t.fmt(f),
+            Literal::Fallback(t) => t.fmt(f),
         }
     }
 }
@@ -915,8 +919,8 @@ impl fmt::Display for Literal {
 impl fmt::Debug for Literal {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            Literal::Nightly(t) => t.fmt(f),
-            Literal::Stable(t) => t.fmt(f),
+            Literal::Compiler(t) => t.fmt(f),
+            Literal::Fallback(t) => t.fmt(f),
         }
     }
 }
diff --git a/third_party/rust/proc-macro2/tests/test.rs b/third_party/rust/proc-macro2/tests/test.rs
index 9d37cf37d26d..055ebfdc504c 100644
--- a/third_party/rust/proc-macro2/tests/test.rs
+++ b/third_party/rust/proc-macro2/tests/test.rs
@@ -137,7 +137,7 @@ fn fail() {
     fail("r#_");
 }
 
-#[cfg(procmacro2_semver_exempt)]
+#[cfg(span_locations)]
 #[test]
 fn span_test() {
     use proc_macro2::TokenTree;
@@ -193,7 +193,7 @@ testing 123
 }
 
 #[cfg(procmacro2_semver_exempt)]
-#[cfg(not(feature = "nightly"))]
+#[cfg(not(nightly))]
 #[test]
 fn default_span() {
     let start = Span::call_site().start();
@@ -329,7 +329,6 @@ fn test_debug_ident() {
 }
 
 #[test]
-#[cfg(not(feature = "nightly"))]
 fn test_debug_tokenstream() {
     let tts = TokenStream::from_str("[a + 1]").unwrap();
 
diff --git a/third_party/rust/quote/.cargo-checksum.json b/third_party/rust/quote/.cargo-checksum.json
index f1a67ee8111c..d9a2d15006fc 100644
--- a/third_party/rust/quote/.cargo-checksum.json
+++ b/third_party/rust/quote/.cargo-checksum.json
@@ -1 +1 @@
-{"files":{"Cargo.toml":"44cf9d3a28be1b21f4247572b6ca4d38dc3fd42fa84c4a4e0e5632aa27bee083","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"c9a75f18b9ab2927829a208fc6aa2cf4e63b8420887ba29cdb265d6619ae82d5","README.md":"b43ef9b9c61628f8de7036271e61322cba23d878d056748e571f4f6cf9fba1b1","src/ext.rs":"a2def0b0f24c822b3f936a781c347e5f6fdc75120f85874c94f5e7eb708168c2","src/lib.rs":"f1ba768690c57252e8135ee474a20bdd513fd0bd0664e9e9b697800163f39d08","src/to_tokens.rs":"86c419a72017846ef33a0acc53caee7312c750c90b3f1d3b58e33f20efcb94f4","tests/conditional/integer128.rs":"d83e21a91efbaa801a82ae499111bdda2d31edaa620e78c0199eba42d69c9ee6","tests/test.rs":"810013d7fd77b738abd0ace90ce2f2f3e219c757652eabab29bc1c0ce4a73b24"},"package":"53fa22a1994bd0f9372d7a816207d8a2677ad0325b073f5c5332760f0fb62b5c"}
\ No newline at end of file
+{"files":{"Cargo.toml":"68f4dc89836a05a2347086addab1849567ef8073c552ec0dfca8f96fd20550f9","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"c9a75f18b9ab2927829a208fc6aa2cf4e63b8420887ba29cdb265d6619ae82d5","README.md":"d9392d4c7af3bf9714f0a95801d64de46ffd4558cdfeea0eb85b414e555abb72","src/ext.rs":"03919239a20f8393288783a21bf6fdee12e405d13d162c9faa6f8f5ce54b003b","src/lib.rs":"5345b4d2e6f923724cec35c62d7397e6f04d5503d2d813bff7bbaa7ffc39a9cf","src/to_tokens.rs":"0dcd15cba2aa83abeb47b9a1babce7a29643b5efa2fe620b070cb37bb21a84f1","tests/conditional/integer128.rs":"d83e21a91efbaa801a82ae499111bdda2d31edaa620e78c0199eba42d69c9ee6","tests/test.rs":"810013d7fd77b738abd0ace90ce2f2f3e219c757652eabab29bc1c0ce4a73b24"},"package":"cdd8e04bd9c52e0342b406469d494fcb033be4bdbe5c606016defbb1681411e1"}
\ No newline at end of file
diff --git a/third_party/rust/quote/Cargo.toml b/third_party/rust/quote/Cargo.toml
index c2c73ac9ea80..820c3a98f990 100644
--- a/third_party/rust/quote/Cargo.toml
+++ b/third_party/rust/quote/Cargo.toml
@@ -12,7 +12,7 @@
 
 [package]
 name = "quote"
-version = "0.6.10"
+version = "0.6.11"
 authors = ["David Tolnay <dtolnay@gmail.com>"]
 include = ["Cargo.toml", "src/**/*.rs", "tests/**/*.rs", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]
 description = "Quasi-quoting macro quote!(...)"
diff --git a/third_party/rust/quote/README.md b/third_party/rust/quote/README.md
index 00232cd38b0e..759916ace2f2 100644
--- a/third_party/rust/quote/README.md
+++ b/third_party/rust/quote/README.md
@@ -38,18 +38,11 @@ first support for procedural macros in Rust 1.15.0.*
 quote = "0.6"
 ```
 
-```rust
-#[macro_use]
-extern crate quote;
-```
-
 ## Syntax
 
 The quote crate provides a [`quote!`] macro within which you can write Rust code
 that gets packaged into a [`TokenStream`] and can be treated as data. You should
-think of `TokenStream` as representing a fragment of Rust source code. This type
-can be returned directly back to the compiler by a procedural macro to get
-compiled into the caller's crate.
+think of `TokenStream` as representing a fragment of Rust source code.
 
 [`TokenStream`]: https://docs.rs/proc-macro2/0.4/proc_macro2/struct.TokenStream.html
 
@@ -64,7 +57,7 @@ most Rust primitive types as well as most of the syntax tree types from [`syn`].
 let tokens = quote! {
     struct SerializeWith #generics #where_clause {
         value: &'a #field_ty,
-        phantom: ::std::marker::PhantomData<#item_ty>,
+        phantom: core::marker::PhantomData<#item_ty>,
     }
 
     impl #generics serde::Serialize for SerializeWith #generics #where_clause {
@@ -78,7 +71,7 @@ let tokens = quote! {
 
     SerializeWith {
         value: #value,
-        phantom: ::std::marker::PhantomData::<#item_ty>,
+        phantom: core::marker::PhantomData::<#item_ty>,
     }
 };
 ```
@@ -100,6 +93,107 @@ Note that there is a difference between `#(#var ,)*` and `#(#var),*`—the latte
 does not produce a trailing comma. This matches the behavior of delimiters in
 `macro_rules!`.
 
+## Returning tokens to the compiler
+
+The `quote!` macro evaluates to an expression of type
+`proc_macro2::TokenStream`. Meanwhile Rust procedural macros are expected to
+return the type `proc_macro::TokenStream`.
+
+The difference between the two types is that `proc_macro` types are entirely
+specific to procedural macros and cannot ever exist in code outside of a
+procedural macro, while `proc_macro2` types may exist anywhere including tests
+and non-macro code like main.rs and build.rs. This is why even the procedural
+macro ecosystem is largely built around `proc_macro2`, because that ensures the
+libraries are unit testable and accessible in non-macro contexts.
+
+There is a [`From`]-conversion in both directions so returning the output of
+`quote!` from a procedural macro usually looks like `tokens.into()` or
+`proc_macro::TokenStream::from(tokens)`.
+
+[`From`]: https://doc.rust-lang.org/std/convert/trait.From.html
+
+## Examples
+
+### Combining quoted fragments
+
+Usually you don't end up constructing an entire final `TokenStream` in one
+piece. Different parts may come from different helper functions. The tokens
+produced by `quote!` themselves implement `ToTokens` and so can be interpolated
+into later `quote!` invocations to build up a final result.
+
+```rust
+let type_definition = quote! {...};
+let methods = quote! {...};
+
+let tokens = quote! {
+    #type_definition
+    #methods
+};
+```
+
+### Constructing identifiers
+
+Suppose we have an identifier `ident` which came from somewhere in a macro
+input and we need to modify it in some way for the macro output. Let's consider
+prepending the identifier with an underscore.
+
+Simply interpolating the identifier next to an underscore will not have the
+behavior of concatenating them. The underscore and the identifier will continue
+to be two separate tokens as if you had written `_ x`.
+
+```rust
+// incorrect
+quote! {
+    let mut _#ident = 0;
+}
+```
+
+The solution is to perform token-level manipulations using the APIs provided by
+Syn and proc-macro2.
+
+```rust
+let concatenated = format!("_{}", ident);
+let varname = syn::Ident::new(&concatenated, ident.span());
+quote! {
+    let mut #varname = 0;
+}
+```
+
+### Making method calls
+
+Let's say our macro requires some type specified in the macro input to have a
+constructor called `new`. We have the type in a variable called `field_type` of
+type `syn::Type` and want to invoke the constructor.
+
+```rust
+// incorrect
+quote! {
+    let value = #field_type::new();
+}
+```
+
+This works only sometimes. If `field_type` is `String`, the expanded code
+contains `String::new()` which is fine. But if `field_type` is something like
+`Vec<i32>` then the expanded code is `Vec<i32>::new()` which is invalid syntax.
+Ordinarily in handwritten Rust we would write `Vec::<i32>::new()` but for macros
+often the following is more convenient.
+
+```rust
+quote! {
+    let value = <#field_type>::new();
+}
+```
+
+This expands to `<Vec<i32>>::new()` which behaves correctly.
+
+A similar pattern is appropriate for trait methods.
+
+```rust
+quote! {
+    let value = <#field_type as core::default::Default>::default();
+}
+```
+
 ## Hygiene
 
 Any interpolated tokens preserve the `Span` information provided by their
diff --git a/third_party/rust/quote/src/ext.rs b/third_party/rust/quote/src/ext.rs
index 614e1e1b2d35..7ebbe30a1b71 100644
--- a/third_party/rust/quote/src/ext.rs
+++ b/third_party/rust/quote/src/ext.rs
@@ -8,47 +8,19 @@ use proc_macro2::{TokenStream, TokenTree};
 ///
 /// This trait is sealed and cannot be implemented outside of the `quote` crate.
 pub trait TokenStreamExt: private::Sealed {
-    fn append<U>(&mut self, token: U)
-    where
-        U: Into<TokenTree>;
-
-    fn append_all<T, I>(&mut self, iter: I)
-    where
-        T: ToTokens,
-        I: IntoIterator<Item = T>;
-
-    fn append_separated<T, I, U>(&mut self, iter: I, op: U)
-    where
-        T: ToTokens,
-        I: IntoIterator<Item = T>,
-        U: ToTokens;
-
-    fn append_terminated<T, I, U>(&mut self, iter: I, term: U)
-    where
-        T: ToTokens,
-        I: IntoIterator<Item = T>,
-        U: ToTokens;
-}
-
-impl TokenStreamExt for TokenStream {
     /// For use by `ToTokens` implementations.
     ///
     /// Appends the token specified to this list of tokens.
     fn append<U>(&mut self, token: U)
     where
-        U: Into<TokenTree>,
-    {
-        self.extend(iter::once(token.into()));
-    }
+        U: Into<TokenTree>;
 
     /// For use by `ToTokens` implementations.
     ///
-    /// ```
-    /// # #[macro_use] extern crate quote;
-    /// # extern crate proc_macro2;
-    /// # use quote::{TokenStreamExt, ToTokens};
+    /// ```edition2018
+    /// # use quote::{quote, TokenStreamExt, ToTokens};
     /// # use proc_macro2::TokenStream;
-    /// # fn main() {
+    /// #
     /// struct X;
     ///
     /// impl ToTokens for X {
@@ -59,8 +31,41 @@ impl TokenStreamExt for TokenStream {
     ///
     /// let tokens = quote!(#X);
     /// assert_eq!(tokens.to_string(), "true false");
-    /// # }
     /// ```
+    fn append_all<T, I>(&mut self, iter: I)
+    where
+        T: ToTokens,
+        I: IntoIterator<Item = T>;
+
+    /// For use by `ToTokens` implementations.
+    ///
+    /// Appends all of the items in the iterator `I`, separated by the tokens
+    /// `U`.
+    fn append_separated<T, I, U>(&mut self, iter: I, op: U)
+    where
+        T: ToTokens,
+        I: IntoIterator<Item = T>,
+        U: ToTokens;
+
+    /// For use by `ToTokens` implementations.
+    ///
+    /// Appends all tokens in the iterator `I`, appending `U` after each
+    /// element, including after the last element of the iterator.
+    fn append_terminated<T, I, U>(&mut self, iter: I, term: U)
+    where
+        T: ToTokens,
+        I: IntoIterator<Item = T>,
+        U: ToTokens;
+}
+
+impl TokenStreamExt for TokenStream {
+    fn append<U>(&mut self, token: U)
+    where
+        U: Into<TokenTree>,
+    {
+        self.extend(iter::once(token.into()));
+    }
+
     fn append_all<T, I>(&mut self, iter: I)
     where
         T: ToTokens,
@@ -71,10 +76,6 @@ impl TokenStreamExt for TokenStream {
         }
     }
 
-    /// For use by `ToTokens` implementations.
-    ///
-    /// Appends all of the items in the iterator `I`, separated by the tokens
-    /// `U`.
     fn append_separated<T, I, U>(&mut self, iter: I, op: U)
     where
         T: ToTokens,
@@ -89,10 +90,6 @@ impl TokenStreamExt for TokenStream {
         }
     }
 
-    /// For use by `ToTokens` implementations.
-    ///
-    /// Appends all tokens in the iterator `I`, appending `U` after each
-    /// element, including after the last element of the iterator.
     fn append_terminated<T, I, U>(&mut self, iter: I, term: U)
     where
         T: ToTokens,
diff --git a/third_party/rust/quote/src/lib.rs b/third_party/rust/quote/src/lib.rs
index 8f0203b8e081..4fd7edee480b 100644
--- a/third_party/rust/quote/src/lib.rs
+++ b/third_party/rust/quote/src/lib.rs
@@ -29,13 +29,6 @@
 //! quote = "0.6"
 //! ```
 //!
-//! ```
-//! #[macro_use]
-//! extern crate quote;
-//! #
-//! # fn main() {}
-//! ```
-//!
 //! # Example
 //!
 //! The following quasi-quoted block of code is something you might find in [a]
@@ -48,22 +41,20 @@
 //! [a]: https://serde.rs/
 //! [`quote_spanned!`]: macro.quote_spanned.html
 //!
-//! ```
-//! # #[macro_use]
-//! # extern crate quote;
+//! ```edition2018
+//! # use quote::quote;
 //! #
-//! # fn main() {
-//! #     let generics = "";
-//! #     let where_clause = "";
-//! #     let field_ty = "";
-//! #     let item_ty = "";
-//! #     let path = "";
-//! #     let value = "";
+//! # let generics = "";
+//! # let where_clause = "";
+//! # let field_ty = "";
+//! # let item_ty = "";
+//! # let path = "";
+//! # let value = "";
 //! #
 //! let tokens = quote! {
 //!     struct SerializeWith #generics #where_clause {
 //!         value: &'a #field_ty,
-//!         phantom: ::std::marker::PhantomData<#item_ty>,
+//!         phantom: core::marker::PhantomData<#item_ty>,
 //!     }
 //!
 //!     impl #generics serde::Serialize for SerializeWith #generics #where_clause {
@@ -77,14 +68,12 @@
 //!
 //!     SerializeWith {
 //!         value: #value,
-//!         phantom: ::std::marker::PhantomData::<#item_ty>,
+//!         phantom: core::marker::PhantomData::<#item_ty>,
 //!     }
 //! };
-//! #
-//! # }
 //! ```
 //!
-//! ## Recursion limit
+//! # Recursion limit
 //!
 //! The `quote!` macro relies on deep recursion so some large invocations may
 //! fail with "recursion limit reached" when you compile. If it fails, bump up
@@ -92,7 +81,7 @@
 //! An even higher limit may be necessary for especially large invocations.
 
 // Quote types in rustdoc of other crates get linked to here.
-#![doc(html_root_url = "https://docs.rs/quote/0.6.10")]
+#![doc(html_root_url = "https://docs.rs/quote/0.6.11")]
 
 #[cfg(all(
     not(all(target_arch = "wasm32", target_os = "unknown")),
@@ -277,17 +266,43 @@ pub mod __rt {
 ///
 /// [`quote_spanned!`]: macro.quote_spanned.html
 ///
-/// # Example
+/// # Return type
 ///
-/// ```
+/// The macro evaluates to an expression of type `proc_macro2::TokenStream`.
+/// Meanwhile Rust procedural macros are expected to return the type
+/// `proc_macro::TokenStream`.
+///
+/// The difference between the two types is that `proc_macro` types are entirely
+/// specific to procedural macros and cannot ever exist in code outside of a
+/// procedural macro, while `proc_macro2` types may exist anywhere including
+/// tests and non-macro code like main.rs and build.rs. This is why even the
+/// procedural macro ecosystem is largely built around `proc_macro2`, because
+/// that ensures the libraries are unit testable and accessible in non-macro
+/// contexts.
+///
+/// There is a [`From`]-conversion in both directions so returning the output of
+/// `quote!` from a procedural macro usually looks like `tokens.into()` or
+/// `proc_macro::TokenStream::from(tokens)`.
+///
+/// [`From`]: https://doc.rust-lang.org/std/convert/trait.From.html
+///
+/// # Examples
+///
+/// ## Procedural macro
+///
+/// The structure of a basic procedural macro is as follows. Refer to the [Syn]
+/// crate for further useful guidance on using `quote!` as part of a procedural
+/// macro.
+///
+/// [Syn]: https://github.com/dtolnay/syn
+///
+/// ```edition2018
 /// # #[cfg(any())]
 /// extern crate proc_macro;
-/// # extern crate proc_macro2 as proc_macro;
-///
-/// #[macro_use]
-/// extern crate quote;
+/// # use proc_macro2 as proc_macro;
 ///
 /// use proc_macro::TokenStream;
+/// use quote::quote;
 ///
 /// # const IGNORE_TOKENS: &'static str = stringify! {
 /// #[proc_macro_derive(HeapSize)]
@@ -304,7 +319,7 @@ pub mod __rt {
 ///
 ///     let expanded = quote! {
 ///         // The generated impl.
-///         impl ::heapsize::HeapSize for #name {
+///         impl heapsize::HeapSize for #name {
 ///             fn heap_size_of_children(&self) -> usize {
 ///                 #expr
 ///             }
@@ -312,10 +327,117 @@ pub mod __rt {
 ///     };
 ///
 ///     // Hand the output tokens back to the compiler.
-///     expanded.into()
+///     TokenStream::from(expanded)
 /// }
+/// ```
+///
+/// ## Combining quoted fragments
+///
+/// Usually you don't end up constructing an entire final `TokenStream` in one
+/// piece. Different parts may come from different helper functions. The tokens
+/// produced by `quote!` themselves implement `ToTokens` and so can be
+/// interpolated into later `quote!` invocations to build up a final result.
+///
+/// ```edition2018
+/// # use quote::quote;
 /// #
-/// # fn main() {}
+/// let type_definition = quote! {...};
+/// let methods = quote! {...};
+///
+/// let tokens = quote! {
+///     #type_definition
+///     #methods
+/// };
+/// ```
+///
+/// ## Constructing identifiers
+///
+/// Suppose we have an identifier `ident` which came from somewhere in a macro
+/// input and we need to modify it in some way for the macro output. Let's
+/// consider prepending the identifier with an underscore.
+///
+/// Simply interpolating the identifier next to an underscore will not have the
+/// behavior of concatenating them. The underscore and the identifier will
+/// continue to be two separate tokens as if you had written `_ x`.
+///
+/// ```edition2018
+/// # use proc_macro2::{self as syn, Span};
+/// # use quote::quote;
+/// #
+/// # let ident = syn::Ident::new("i", Span::call_site());
+/// #
+/// // incorrect
+/// quote! {
+///     let mut _#ident = 0;
+/// }
+/// # ;
+/// ```
+///
+/// The solution is to perform token-level manipulations using the APIs provided
+/// by Syn and proc-macro2.
+///
+/// ```edition2018
+/// # use proc_macro2::{self as syn, Span};
+/// # use quote::quote;
+/// #
+/// # let ident = syn::Ident::new("i", Span::call_site());
+/// #
+/// let concatenated = format!("_{}", ident);
+/// let varname = syn::Ident::new(&concatenated, ident.span());
+/// quote! {
+///     let mut #varname = 0;
+/// }
+/// # ;
+/// ```
+///
+/// ## Making method calls
+///
+/// Let's say our macro requires some type specified in the macro input to have
+/// a constructor called `new`. We have the type in a variable called
+/// `field_type` of type `syn::Type` and want to invoke the constructor.
+///
+/// ```edition2018
+/// # use quote::quote;
+/// #
+/// # let field_type = quote!(...);
+/// #
+/// // incorrect
+/// quote! {
+///     let value = #field_type::new();
+/// }
+/// # ;
+/// ```
+///
+/// This works only sometimes. If `field_type` is `String`, the expanded code
+/// contains `String::new()` which is fine. But if `field_type` is something
+/// like `Vec<i32>` then the expanded code is `Vec<i32>::new()` which is invalid
+/// syntax. Ordinarily in handwritten Rust we would write `Vec::<i32>::new()`
+/// but for macros often the following is more convenient.
+///
+/// ```edition2018
+/// # use quote::quote;
+/// #
+/// # let field_type = quote!(...);
+/// #
+/// quote! {
+///     let value = <#field_type>::new();
+/// }
+/// # ;
+/// ```
+///
+/// This expands to `<Vec<i32>>::new()` which behaves correctly.
+///
+/// A similar pattern is appropriate for trait methods.
+///
+/// ```edition2018
+/// # use quote::quote;
+/// #
+/// # let field_type = quote!(...);
+/// #
+/// quote! {
+///     let value = <#field_type as core::default::Default>::default();
+/// }
+/// # ;
 /// ```
 #[macro_export(local_inner_macros)]
 macro_rules! quote {
@@ -333,14 +455,10 @@ macro_rules! quote {
 ///
 /// [`Span`]: https://docs.rs/proc-macro2/0.4/proc_macro2/struct.Span.html
 ///
-/// ```
-/// # #[macro_use]
-/// # extern crate quote;
-/// # extern crate proc_macro2;
-/// #
+/// ```edition2018
 /// # use proc_macro2::Span;
+/// # use quote::quote_spanned;
 /// #
-/// # fn main() {
 /// # const IGNORE_TOKENS: &'static str = stringify! {
 /// let span = /* ... */;
 /// # };
@@ -354,7 +472,6 @@ macro_rules! quote {
 /// let tokens = quote_spanned! {span=>
 ///     Box::into_raw(Box::new(#init))
 /// };
-/// # }
 /// ```
 ///
 /// The lack of space before the `=>` should look jarring to Rust programmers
@@ -377,12 +494,8 @@ macro_rules! quote {
 ///
 /// [`Sync`]: https://doc.rust-lang.org/std/marker/trait.Sync.html
 ///
-/// ```
-/// # #[macro_use]
-/// # extern crate quote;
-/// # extern crate proc_macro2;
-/// #
-/// # use quote::{TokenStreamExt, ToTokens};
+/// ```edition2018
+/// # use quote::{quote_spanned, TokenStreamExt, ToTokens};
 /// # use proc_macro2::{Span, TokenStream};
 /// #
 /// # struct Type;
@@ -397,7 +510,6 @@ macro_rules! quote {
 /// #     fn to_tokens(&self, _tokens: &mut TokenStream) {}
 /// # }
 /// #
-/// # fn main() {
 /// # let ty = Type;
 /// # let call_site = Span::call_site();
 /// #
@@ -405,7 +517,6 @@ macro_rules! quote {
 /// let assert_sync = quote_spanned! {ty_span=>
 ///     struct _AssertSync where #ty: Sync;
 /// };
-/// # }
 /// ```
 ///
 /// If the assertion fails, the user will see an error like the following. The
diff --git a/third_party/rust/quote/src/to_tokens.rs b/third_party/rust/quote/src/to_tokens.rs
index 4a9c8f11ec71..d80fb4b67d0b 100644
--- a/third_party/rust/quote/src/to_tokens.rs
+++ b/third_party/rust/quote/src/to_tokens.rs
@@ -21,12 +21,9 @@ pub trait ToTokens {
     /// Example implementation for a struct representing Rust paths like
     /// `std::cmp::PartialEq`:
     ///
-    /// ```
-    /// extern crate quote;
-    /// use quote::{TokenStreamExt, ToTokens};
-    ///
-    /// extern crate proc_macro2;
+    /// ```edition2018
     /// use proc_macro2::{TokenTree, Spacing, Span, Punct, TokenStream};
+    /// use quote::{TokenStreamExt, ToTokens};
     ///
     /// pub struct Path {
     ///     pub global: bool,
@@ -53,8 +50,6 @@ pub trait ToTokens {
     /// #         unimplemented!()
     /// #     }
     /// # }
-    /// #
-    /// # fn main() {}
     /// ```
     fn to_tokens(&self, tokens: &mut TokenStream);
 
diff --git a/third_party/rust/syn/.cargo-checksum.json b/third_party/rust/syn/.cargo-checksum.json
index 509ada56d2bd..2aa729af5734 100644
--- a/third_party/rust/syn/.cargo-checksum.json
+++ b/third_party/rust/syn/.cargo-checksum.json
@@ -1 +1 @@
-{"files":{"Cargo.toml":"fdac1ee690fa3d33b906be9d09a8551741db11ddba7f755cb75c8d74fd2d918b","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3","README.md":"3f3d105c0f1bae3bdb5ed3cc32a8e5a02f3de6f62a9f17f5ba03af3f813d0881","src/attr.rs":"9210a8dc5fea0ee3004b14a9e2923142932c53986b56685d62d9aa115fe093b0","src/buffer.rs":"fac77febe022ab4982078c73ca502f9d698a402b3eca0f8e9c7a2796af01e5f4","src/data.rs":"54ee54c3c650bc5e200d4bea947d6e89093a39f2444cd43e8861f5852975e0bc","src/derive.rs":"eb041b47a73bace73c2872cd9a8e190de7e2b3b57cd57213770f088ec19ab3c6","src/error.rs":"0bcf09b0892c6d5f5f31f7f758866ded1e47463833cad60694329348ac1fb44a","src/export.rs":"1f7e017dac9426e91c796445e733c390c408c808ba9c21cb7df7799b67352fde","src/expr.rs":"3fe98f69af9be770d4d549d869d35136f3dea66452e4cb4b9e387982e3b7aea2","src/ext.rs":"1881179e634681cdd472ecac502192b5a5a7759056d1c49497706749fdab1bdf","src/file.rs":"abb9f5e71a8a6b52649c15da21d3f99e25a727d87c2f87d2744ac3970c1d683f","src/gen/fold.rs":"7f7ab907e3c17b503a72707e2f8d9fc29d9139269d810ea9b6511af9de7d3080","src/gen/visit.rs":"0a4543ac9f82d8ab7ccf02c55e8325ff9b859e36ea08d3e187a4836f470eef1c","src/gen/visit_mut.rs":"66441522f544056cd464740e8ba614688a5f417857c649550eeba2b589ef6096","src/gen_helper.rs":"644b1d31987919c0239891d8f90c09f3bf541a71fb85e744438e4814cc6dff89","src/generics.rs":"6ee5bba532b95f7de7c6bbe8caadabc6a71c45e7f8d7636d823075ff27f28937","src/group.rs":"03487f75d0abd302f06e50eb09d14ab83fb60c67e1f2602be53ca3f28a833b90","src/ident.rs":"61534c48949ebfa03e948874ef64174e1c8111c3b953edd58f79748fe9e00507","src/item.rs":"6799adb332bedaa68c3801055e71a5665cc7b9c4ba53960f6b91487408e7e10c","src/keyword.rs":"7dde0b4a0d70527921be16f50f8d88e4b5ad7e5fd70e9badd2bb351fd796dfb8","src/lib.rs":"254744712dae7c30ce7f97ce4685fc6256cf125e7872397d3dd9e32632273262","src/lifetime.rs":"7912a4c77ee805e912fb28c7f434836ea82540263d549877cd5edfbe32d1bf95","src/lit.rs":"b6aef4f2787201edbeb85529fc0c333bd8083d697a08f28c812b6b2f765939f5","src/lookahead.rs":"5b3c55ae8c1b1d0ed813c296dc6fa586379a99e7792a3cb0d634ae6ca74f54b5","src/mac.rs":"a91623ed9c1de7b18ef752db79a242002e95156497a52a1790a75069915d22ee","src/macros.rs":"2f91e07a1aec4b385986c0a0f66274e8de1c1aa81f95d398a5cd364b3c451bb4","src/op.rs":"01edb1e07b6d60b266797ca4b30788b0a511452228e04073a11f0b61f106a0e7","src/parse.rs":"d907b9822943bafbcb1e005f09a145e46c162e7702fce703b57f9b7ccbdf85a2","src/parse_macro_input.rs":"8df7b4c1b361171f3fefb0490dec570ad29c024c04e35184b296725f97f2002c","src/parse_quote.rs":"d5e613fbba06900d882f2aaa042f10c1bee1b1dffaa1d9ee9a73d1e504a08fad","src/path.rs":"d6a319db75e4b34783912aed0ddfad92cdec05798d8d378f2f23231437cab3e1","src/print.rs":"7ebb68123898f2ebbae12abf028747c05bea7b08f1e96b17164f1dcebdab7355","src/punctuated.rs":"5ad6885e602cb1c79b49f11e1c739bdb7c33ecfa1ca9c709d711b0778ae48085","src/span.rs":"748c51c6feb223c26d3b1701f5bb98aee823666c775c98106cfa24fe29d8cec1","src/spanned.rs":"83b4ab1e2138ac9340eaa8234ad1d9f7468b450ddf3a852e574cac18e4f766b8","src/synom.rs":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","src/thread.rs":"798dd0a6cca7807f1d55c1f79cec967314a75c4e8e2cfdb5644499c22618b307","src/token.rs":"8fa7ffb89da61d5187ab0ff40de7b3b1135ace6cf770c8d84fce8371854698a9","src/tt.rs":"b3d99cbd68cd50749f26f4afa138e6366d327099ed566b30c315ccb58fa26ded","src/ty.rs":"4ac9d1b84f9bf269516348e1b923b1c8e3f7562b98ec7ef66174c31fffb8dce5"},"package":"734ecc29cd36e8123850d9bf21dfd62ef8300aaa8f879aabaa899721808be37c"}
\ No newline at end of file
+{"files":{"Cargo.toml":"ebf2c860a726b1210648f946b92b56a54414f2a009043d8affefdb1a0e4bd234","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3","README.md":"3f3d105c0f1bae3bdb5ed3cc32a8e5a02f3de6f62a9f17f5ba03af3f813d0881","build.rs":"9f3b0dc6ae4c0065c3cf001a40a2ff9c5a86cac5edf66fa0e80d0bcd37c0d4fc","src/attr.rs":"9210a8dc5fea0ee3004b14a9e2923142932c53986b56685d62d9aa115fe093b0","src/buffer.rs":"fac77febe022ab4982078c73ca502f9d698a402b3eca0f8e9c7a2796af01e5f4","src/data.rs":"54ee54c3c650bc5e200d4bea947d6e89093a39f2444cd43e8861f5852975e0bc","src/derive.rs":"eb041b47a73bace73c2872cd9a8e190de7e2b3b57cd57213770f088ec19ab3c6","src/error.rs":"0bcf09b0892c6d5f5f31f7f758866ded1e47463833cad60694329348ac1fb44a","src/export.rs":"1f7e017dac9426e91c796445e733c390c408c808ba9c21cb7df7799b67352fde","src/expr.rs":"c9000092a57412dcbef401cd51195b816ebfae96736deeebcece5bdc73471cdc","src/ext.rs":"1881179e634681cdd472ecac502192b5a5a7759056d1c49497706749fdab1bdf","src/file.rs":"abb9f5e71a8a6b52649c15da21d3f99e25a727d87c2f87d2744ac3970c1d683f","src/gen/fold.rs":"5507dde16c41e4f11b8903938a5f442fff9f94468afccbf0a37a4fa14f2eddde","src/gen/visit.rs":"4c8f499d1fd988b9c9ff820ef76c0c93b1e5ee91e6a94e0892298f5e6f424893","src/gen/visit_mut.rs":"d1f905b2b5afd685ace07532b6cbc67175e2d104508c7ed86ed4e9d1567c7c7b","src/gen_helper.rs":"644b1d31987919c0239891d8f90c09f3bf541a71fb85e744438e4814cc6dff89","src/generics.rs":"6ee5bba532b95f7de7c6bbe8caadabc6a71c45e7f8d7636d823075ff27f28937","src/group.rs":"03487f75d0abd302f06e50eb09d14ab83fb60c67e1f2602be53ca3f28a833b90","src/ident.rs":"bd7884de0031d942c556f929905532dd8799f8ca2450e65b8e4e8dfa78cf4fee","src/item.rs":"92b5ceca78590d9236dbdd008b97d817d051a16b10cb4dac8614199a09bda03e","src/keyword.rs":"aaca18ec0226f454ed5eecf8d99ef01afb8dd2457c9cae4f91b262accc0c0c41","src/lib.rs":"d36df1838b3454cd63a4ca214044c2be9281a33b533581f5da622bc66e2446d2","src/lifetime.rs":"7912a4c77ee805e912fb28c7f434836ea82540263d549877cd5edfbe32d1bf95","src/lit.rs":"bc034e4443a32f2066b41f62e05946143f60397fbbd05016c0020c4818e0a0f8","src/lookahead.rs":"5b3c55ae8c1b1d0ed813c296dc6fa586379a99e7792a3cb0d634ae6ca74f54b5","src/mac.rs":"a91623ed9c1de7b18ef752db79a242002e95156497a52a1790a75069915d22ee","src/macros.rs":"2f91e07a1aec4b385986c0a0f66274e8de1c1aa81f95d398a5cd364b3c451bb4","src/op.rs":"01edb1e07b6d60b266797ca4b30788b0a511452228e04073a11f0b61f106a0e7","src/parse.rs":"d907b9822943bafbcb1e005f09a145e46c162e7702fce703b57f9b7ccbdf85a2","src/parse_macro_input.rs":"8df7b4c1b361171f3fefb0490dec570ad29c024c04e35184b296725f97f2002c","src/parse_quote.rs":"d5e613fbba06900d882f2aaa042f10c1bee1b1dffaa1d9ee9a73d1e504a08fad","src/path.rs":"18b5c17b5acb7814a63517bbc473e1120895b4f7ff8f856279f31493663cc7fa","src/print.rs":"7ebb68123898f2ebbae12abf028747c05bea7b08f1e96b17164f1dcebdab7355","src/punctuated.rs":"3abae461aa47b71f00ede80e42691da5617a21c6f4864c40b2f984bb34a9a277","src/span.rs":"748c51c6feb223c26d3b1701f5bb98aee823666c775c98106cfa24fe29d8cec1","src/spanned.rs":"83b4ab1e2138ac9340eaa8234ad1d9f7468b450ddf3a852e574cac18e4f766b8","src/thread.rs":"ac3f4aa972b0dee5b9ae5202c5cd6bef46823fc91ff83787a3fe1bdfb8f79135","src/token.rs":"20868cd459ac8eea83e8891cf0b5d7c9dc179b0ff76953d5d0a2a29f17c0c7af","src/tt.rs":"b3d99cbd68cd50749f26f4afa138e6366d327099ed566b30c315ccb58fa26ded","src/ty.rs":"4ac9d1b84f9bf269516348e1b923b1c8e3f7562b98ec7ef66174c31fffb8dce5"},"package":"66c8865bf5a7cbb662d8b011950060b3c8743dca141b054bf7195b20d314d8e2"}
\ No newline at end of file
diff --git a/third_party/rust/syn/Cargo.toml b/third_party/rust/syn/Cargo.toml
index e3248e172143..3e73e38fe3c3 100644
--- a/third_party/rust/syn/Cargo.toml
+++ b/third_party/rust/syn/Cargo.toml
@@ -3,7 +3,7 @@
 # When uploading crates to the registry Cargo will automatically
 # "normalize" Cargo.toml files for maximal compatibility
 # with all versions of Cargo and also rewrite `path` dependencies
-# to registry (e.g. crates.io) dependencies
+# to registry (e.g., crates.io) dependencies
 #
 # If you believe there's an error in this file please file an
 # issue against the rust-lang/cargo repository. If you're
@@ -12,9 +12,9 @@
 
 [package]
 name = "syn"
-version = "0.15.24"
+version = "0.15.30"
 authors = ["David Tolnay <dtolnay@gmail.com>"]
-include = ["/Cargo.toml", "/src/**/*.rs", "/README.md", "/LICENSE-APACHE", "/LICENSE-MIT"]
+include = ["/build.rs", "/Cargo.toml", "/LICENSE-APACHE", "/LICENSE-MIT", "/README.md", "/src/**/*.rs"]
 description = "Parser for Rust source code"
 documentation = "https://docs.rs/syn"
 readme = "README.md"
@@ -29,11 +29,6 @@ all-features = true
 
 [lib]
 name = "syn"
-
-[[example]]
-name = "dump-syntax"
-path = "examples/dump-syntax/main.rs"
-required-features = ["full", "parsing", "extra-traits"]
 [dependencies.proc-macro2]
 version = "0.4.4"
 default-features = false
@@ -45,6 +40,12 @@ default-features = false
 
 [dependencies.unicode-xid]
 version = "0.1"
+[dev-dependencies.colored]
+version = "1.7"
+
+[dev-dependencies.insta]
+version = "0.7"
+
 [dev-dependencies.rayon]
 version = "1.0"
 
diff --git a/third_party/rust/syn/build.rs b/third_party/rust/syn/build.rs
new file mode 100644
index 000000000000..644bf75ffeea
--- /dev/null
+++ b/third_party/rust/syn/build.rs
@@ -0,0 +1,68 @@
+use std::env;
+use std::process::Command;
+use std::str::{self, FromStr};
+
+// The rustc-cfg strings below are *not* public API. Please let us know by
+// opening a GitHub issue if your build environment requires some way to enable
+// these cfgs other than by executing our build script.
+fn main() {
+    let compiler = match rustc_version() {
+        Some(compiler) => compiler,
+        None => return,
+    };
+
+    if compiler.minor >= 19 {
+        println!("cargo:rustc-cfg=syn_can_use_thread_id");
+    }
+
+    // Macro modularization allows re-exporting the `quote!` macro in 1.30+.
+    if compiler.minor >= 30 {
+        println!("cargo:rustc-cfg=syn_can_call_macro_by_path");
+    }
+
+    if !compiler.nightly {
+        println!("cargo:rustc-cfg=syn_disable_nightly_tests");
+    }
+}
+
+struct Compiler {
+    minor: u32,
+    nightly: bool,
+}
+
+fn rustc_version() -> Option<Compiler> {
+    let rustc = match env::var_os("RUSTC") {
+        Some(rustc) => rustc,
+        None => return None,
+    };
+
+    let output = match Command::new(rustc).arg("--version").output() {
+        Ok(output) => output,
+        Err(_) => return None,
+    };
+
+    let version = match str::from_utf8(&output.stdout) {
+        Ok(version) => version,
+        Err(_) => return None,
+    };
+
+    let mut pieces = version.split('.');
+    if pieces.next() != Some("rustc 1") {
+        return None;
+    }
+
+    let next = match pieces.next() {
+        Some(next) => next,
+        None => return None,
+    };
+
+    let minor = match u32::from_str(next) {
+        Ok(minor) => minor,
+        Err(_) => return None,
+    };
+
+    Some(Compiler {
+        minor: minor,
+        nightly: version.contains("nightly"),
+    })
+}
diff --git a/third_party/rust/syn/src/expr.rs b/third_party/rust/syn/src/expr.rs
index fe067cb4691a..44241971bcc4 100644
--- a/third_party/rust/syn/src/expr.rs
+++ b/third_party/rust/syn/src/expr.rs
@@ -799,8 +799,8 @@ ast_enum_of_structs! {
         /// A path pattern like `Color::Red`, optionally qualified with a
         /// self-type.
         ///
-        /// Unquailfied path patterns can legally refer to variants, structs,
-        /// constants or associated constants. Quailfied path patterns like
+        /// Unqualified path patterns can legally refer to variants, structs,
+        /// constants or associated constants. Qualified path patterns like
         /// `<A>::B::C` and `<A as Trait>::B::C` can only legally refer to
         /// associated constants.
         ///
@@ -1508,7 +1508,7 @@ pub mod parsing {
         } else if input.peek(Token![loop]) {
             input.call(expr_loop).map(Expr::Loop)
         } else if input.peek(Token![match]) {
-            input.call(expr_match).map(Expr::Match)
+            input.parse().map(Expr::Match)
         } else if input.peek(Token![yield]) {
             input.call(expr_yield).map(Expr::Yield)
         } else if input.peek(Token![unsafe]) {
@@ -1703,7 +1703,7 @@ pub mod parsing {
         } else if input.peek(Token![loop]) {
             Expr::Loop(input.call(expr_loop)?)
         } else if input.peek(Token![match]) {
-            Expr::Match(input.call(expr_match)?)
+            Expr::Match(input.parse()?)
         } else if input.peek(Token![try]) && input.peek2(token::Brace) {
             Expr::TryBlock(input.call(expr_try_block)?)
         } else if input.peek(Token![unsafe]) {
@@ -1775,6 +1775,7 @@ pub mod parsing {
             let_token: input.parse()?,
             pats: {
                 let mut pats = Punctuated::new();
+                input.parse::<Option<Token![|]>>()?;
                 let value: Pat = input.parse()?;
                 pats.push_value(value);
                 while input.peek(Token![|]) && !input.peek(Token![||]) && !input.peek(Token![|=]) {
@@ -1876,26 +1877,28 @@ pub mod parsing {
     }
 
     #[cfg(feature = "full")]
-    fn expr_match(input: ParseStream) -> Result<ExprMatch> {
-        let match_token: Token![match] = input.parse()?;
-        let expr = expr_no_struct(input)?;
+    impl Parse for ExprMatch {
+        fn parse(input: ParseStream) -> Result<Self> {
+            let match_token: Token![match] = input.parse()?;
+            let expr = expr_no_struct(input)?;
 
-        let content;
-        let brace_token = braced!(content in input);
-        let inner_attrs = content.call(Attribute::parse_inner)?;
+            let content;
+            let brace_token = braced!(content in input);
+            let inner_attrs = content.call(Attribute::parse_inner)?;
 
-        let mut arms = Vec::new();
-        while !content.is_empty() {
-            arms.push(content.call(Arm::parse)?);
+            let mut arms = Vec::new();
+            while !content.is_empty() {
+                arms.push(content.call(Arm::parse)?);
+            }
+
+            Ok(ExprMatch {
+                attrs: inner_attrs,
+                match_token: match_token,
+                expr: Box::new(expr),
+                brace_token: brace_token,
+                arms: arms,
+            })
         }
-
-        Ok(ExprMatch {
-            attrs: inner_attrs,
-            match_token: match_token,
-            expr: Box::new(expr),
-            brace_token: brace_token,
-            arms: arms,
-        })
     }
 
     #[cfg(feature = "full")]
diff --git a/third_party/rust/syn/src/gen/fold.rs b/third_party/rust/syn/src/gen/fold.rs
index 3eb18753e9bf..c8a0d6912df8 100644
--- a/third_party/rust/syn/src/gen/fold.rs
+++ b/third_party/rust/syn/src/gen/fold.rs
@@ -19,19 +19,19 @@ macro_rules! full {
         unreachable!()
     };
 }
-#[doc = r" Syntax tree traversal to transform the nodes of an owned syntax tree."]
-#[doc = r""]
-#[doc = r" See the [module documentation] for details."]
-#[doc = r""]
-#[doc = r" [module documentation]: index.html"]
-#[doc = r""]
-#[doc = r#" *This trait is available if Syn is built with the `"fold"` feature.*"#]
+/// Syntax tree traversal to transform the nodes of an owned syntax tree.
+///
+/// See the [module documentation] for details.
+///
+/// [module documentation]: index.html
+///
+/// *This trait is available if Syn is built with the `"fold"` feature.*
 pub trait Fold {
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_abi(&mut self, i: Abi) -> Abi {
         fold_abi(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_angle_bracketed_generic_arguments(
         &mut self,
         i: AngleBracketedGenericArguments,
@@ -50,49 +50,47 @@ pub trait Fold {
     fn fold_arg_self_ref(&mut self, i: ArgSelfRef) -> ArgSelfRef {
         fold_arg_self_ref(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn fold_arm(&mut self, i: Arm) -> Arm {
         fold_arm(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_attr_style(&mut self, i: AttrStyle) -> AttrStyle {
         fold_attr_style(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_attribute(&mut self, i: Attribute) -> Attribute {
         fold_attribute(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_bare_fn_arg(&mut self, i: BareFnArg) -> BareFnArg {
         fold_bare_fn_arg(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_bare_fn_arg_name(&mut self, i: BareFnArgName) -> BareFnArgName {
         fold_bare_fn_arg_name(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_bin_op(&mut self, i: BinOp) -> BinOp {
         fold_bin_op(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_binding(&mut self, i: Binding) -> Binding {
         fold_binding(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn fold_block(&mut self, i: Block) -> Block {
         fold_block(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_bound_lifetimes(&mut self, i: BoundLifetimes) -> BoundLifetimes {
         fold_bound_lifetimes(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_const_param(&mut self, i: ConstParam) -> ConstParam {
         fold_const_param(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_constraint(&mut self, i: Constraint) -> Constraint {
         fold_constraint(self, i)
     }
@@ -116,223 +114,191 @@ pub trait Fold {
     fn fold_derive_input(&mut self, i: DeriveInput) -> DeriveInput {
         fold_derive_input(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_expr(&mut self, i: Expr) -> Expr {
         fold_expr(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn fold_expr_array(&mut self, i: ExprArray) -> ExprArray {
         fold_expr_array(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn fold_expr_assign(&mut self, i: ExprAssign) -> ExprAssign {
         fold_expr_assign(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn fold_expr_assign_op(&mut self, i: ExprAssignOp) -> ExprAssignOp {
         fold_expr_assign_op(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn fold_expr_async(&mut self, i: ExprAsync) -> ExprAsync {
         fold_expr_async(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_expr_binary(&mut self, i: ExprBinary) -> ExprBinary {
         fold_expr_binary(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn fold_expr_block(&mut self, i: ExprBlock) -> ExprBlock {
         fold_expr_block(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn fold_expr_box(&mut self, i: ExprBox) -> ExprBox {
         fold_expr_box(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn fold_expr_break(&mut self, i: ExprBreak) -> ExprBreak {
         fold_expr_break(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_expr_call(&mut self, i: ExprCall) -> ExprCall {
         fold_expr_call(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_expr_cast(&mut self, i: ExprCast) -> ExprCast {
         fold_expr_cast(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn fold_expr_closure(&mut self, i: ExprClosure) -> ExprClosure {
         fold_expr_closure(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn fold_expr_continue(&mut self, i: ExprContinue) -> ExprContinue {
         fold_expr_continue(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_expr_field(&mut self, i: ExprField) -> ExprField {
         fold_expr_field(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn fold_expr_for_loop(&mut self, i: ExprForLoop) -> ExprForLoop {
         fold_expr_for_loop(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn fold_expr_group(&mut self, i: ExprGroup) -> ExprGroup {
         fold_expr_group(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn fold_expr_if(&mut self, i: ExprIf) -> ExprIf {
         fold_expr_if(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn fold_expr_in_place(&mut self, i: ExprInPlace) -> ExprInPlace {
         fold_expr_in_place(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_expr_index(&mut self, i: ExprIndex) -> ExprIndex {
         fold_expr_index(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn fold_expr_let(&mut self, i: ExprLet) -> ExprLet {
         fold_expr_let(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_expr_lit(&mut self, i: ExprLit) -> ExprLit {
         fold_expr_lit(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn fold_expr_loop(&mut self, i: ExprLoop) -> ExprLoop {
         fold_expr_loop(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn fold_expr_macro(&mut self, i: ExprMacro) -> ExprMacro {
         fold_expr_macro(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn fold_expr_match(&mut self, i: ExprMatch) -> ExprMatch {
         fold_expr_match(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn fold_expr_method_call(&mut self, i: ExprMethodCall) -> ExprMethodCall {
         fold_expr_method_call(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_expr_paren(&mut self, i: ExprParen) -> ExprParen {
         fold_expr_paren(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_expr_path(&mut self, i: ExprPath) -> ExprPath {
         fold_expr_path(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn fold_expr_range(&mut self, i: ExprRange) -> ExprRange {
         fold_expr_range(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn fold_expr_reference(&mut self, i: ExprReference) -> ExprReference {
         fold_expr_reference(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn fold_expr_repeat(&mut self, i: ExprRepeat) -> ExprRepeat {
         fold_expr_repeat(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn fold_expr_return(&mut self, i: ExprReturn) -> ExprReturn {
         fold_expr_return(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn fold_expr_struct(&mut self, i: ExprStruct) -> ExprStruct {
         fold_expr_struct(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn fold_expr_try(&mut self, i: ExprTry) -> ExprTry {
         fold_expr_try(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn fold_expr_try_block(&mut self, i: ExprTryBlock) -> ExprTryBlock {
         fold_expr_try_block(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn fold_expr_tuple(&mut self, i: ExprTuple) -> ExprTuple {
         fold_expr_tuple(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn fold_expr_type(&mut self, i: ExprType) -> ExprType {
         fold_expr_type(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_expr_unary(&mut self, i: ExprUnary) -> ExprUnary {
         fold_expr_unary(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn fold_expr_unsafe(&mut self, i: ExprUnsafe) -> ExprUnsafe {
         fold_expr_unsafe(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_expr_verbatim(&mut self, i: ExprVerbatim) -> ExprVerbatim {
         fold_expr_verbatim(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn fold_expr_while(&mut self, i: ExprWhile) -> ExprWhile {
         fold_expr_while(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn fold_expr_yield(&mut self, i: ExprYield) -> ExprYield {
         fold_expr_yield(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_field(&mut self, i: Field) -> Field {
         fold_field(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn fold_field_pat(&mut self, i: FieldPat) -> FieldPat {
         fold_field_pat(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn fold_field_value(&mut self, i: FieldValue) -> FieldValue {
         fold_field_value(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_fields(&mut self, i: Fields) -> Fields {
         fold_fields(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_fields_named(&mut self, i: FieldsNamed) -> FieldsNamed {
         fold_fields_named(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_fields_unnamed(&mut self, i: FieldsUnnamed) -> FieldsUnnamed {
         fold_fields_unnamed(self, i)
     }
@@ -372,26 +338,22 @@ pub trait Fold {
     fn fold_foreign_item_verbatim(&mut self, i: ForeignItemVerbatim) -> ForeignItemVerbatim {
         fold_foreign_item_verbatim(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_generic_argument(&mut self, i: GenericArgument) -> GenericArgument {
         fold_generic_argument(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn fold_generic_method_argument(&mut self, i: GenericMethodArgument) -> GenericMethodArgument {
         fold_generic_method_argument(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_generic_param(&mut self, i: GenericParam) -> GenericParam {
         fold_generic_param(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_generics(&mut self, i: Generics) -> Generics {
         fold_generics(self, i)
     }
-    fn fold_ident(&mut self, i: Ident) -> Ident {
-        fold_ident(self, i)
-    }
     #[cfg(feature = "full")]
     fn fold_impl_item(&mut self, i: ImplItem) -> ImplItem {
         fold_impl_item(self, i)
@@ -420,7 +382,7 @@ pub trait Fold {
     fn fold_impl_item_verbatim(&mut self, i: ImplItemVerbatim) -> ImplItemVerbatim {
         fold_impl_item_verbatim(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_index(&mut self, i: Index) -> Index {
         fold_index(self, i)
     }
@@ -500,7 +462,6 @@ pub trait Fold {
     fn fold_item_verbatim(&mut self, i: ItemVerbatim) -> ItemVerbatim {
         fold_item_verbatim(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn fold_label(&mut self, i: Label) -> Label {
         fold_label(self, i)
@@ -508,72 +469,71 @@ pub trait Fold {
     fn fold_lifetime(&mut self, i: Lifetime) -> Lifetime {
         fold_lifetime(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_lifetime_def(&mut self, i: LifetimeDef) -> LifetimeDef {
         fold_lifetime_def(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_lit(&mut self, i: Lit) -> Lit {
         fold_lit(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_lit_bool(&mut self, i: LitBool) -> LitBool {
         fold_lit_bool(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_lit_byte(&mut self, i: LitByte) -> LitByte {
         fold_lit_byte(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_lit_byte_str(&mut self, i: LitByteStr) -> LitByteStr {
         fold_lit_byte_str(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_lit_char(&mut self, i: LitChar) -> LitChar {
         fold_lit_char(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_lit_float(&mut self, i: LitFloat) -> LitFloat {
         fold_lit_float(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_lit_int(&mut self, i: LitInt) -> LitInt {
         fold_lit_int(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_lit_str(&mut self, i: LitStr) -> LitStr {
         fold_lit_str(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_lit_verbatim(&mut self, i: LitVerbatim) -> LitVerbatim {
         fold_lit_verbatim(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn fold_local(&mut self, i: Local) -> Local {
         fold_local(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_macro(&mut self, i: Macro) -> Macro {
         fold_macro(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_macro_delimiter(&mut self, i: MacroDelimiter) -> MacroDelimiter {
         fold_macro_delimiter(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_member(&mut self, i: Member) -> Member {
         fold_member(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_meta(&mut self, i: Meta) -> Meta {
         fold_meta(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_meta_list(&mut self, i: MetaList) -> MetaList {
         fold_meta_list(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_meta_name_value(&mut self, i: MetaNameValue) -> MetaNameValue {
         fold_meta_name_value(self, i)
     }
@@ -581,142 +541,122 @@ pub trait Fold {
     fn fold_method_sig(&mut self, i: MethodSig) -> MethodSig {
         fold_method_sig(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn fold_method_turbofish(&mut self, i: MethodTurbofish) -> MethodTurbofish {
         fold_method_turbofish(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_nested_meta(&mut self, i: NestedMeta) -> NestedMeta {
         fold_nested_meta(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_parenthesized_generic_arguments(
         &mut self,
         i: ParenthesizedGenericArguments,
     ) -> ParenthesizedGenericArguments {
         fold_parenthesized_generic_arguments(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn fold_pat(&mut self, i: Pat) -> Pat {
         fold_pat(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn fold_pat_box(&mut self, i: PatBox) -> PatBox {
         fold_pat_box(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn fold_pat_ident(&mut self, i: PatIdent) -> PatIdent {
         fold_pat_ident(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn fold_pat_lit(&mut self, i: PatLit) -> PatLit {
         fold_pat_lit(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn fold_pat_macro(&mut self, i: PatMacro) -> PatMacro {
         fold_pat_macro(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn fold_pat_path(&mut self, i: PatPath) -> PatPath {
         fold_pat_path(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn fold_pat_range(&mut self, i: PatRange) -> PatRange {
         fold_pat_range(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn fold_pat_ref(&mut self, i: PatRef) -> PatRef {
         fold_pat_ref(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn fold_pat_slice(&mut self, i: PatSlice) -> PatSlice {
         fold_pat_slice(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn fold_pat_struct(&mut self, i: PatStruct) -> PatStruct {
         fold_pat_struct(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn fold_pat_tuple(&mut self, i: PatTuple) -> PatTuple {
         fold_pat_tuple(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn fold_pat_tuple_struct(&mut self, i: PatTupleStruct) -> PatTupleStruct {
         fold_pat_tuple_struct(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn fold_pat_verbatim(&mut self, i: PatVerbatim) -> PatVerbatim {
         fold_pat_verbatim(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn fold_pat_wild(&mut self, i: PatWild) -> PatWild {
         fold_pat_wild(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_path(&mut self, i: Path) -> Path {
         fold_path(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_path_arguments(&mut self, i: PathArguments) -> PathArguments {
         fold_path_arguments(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_path_segment(&mut self, i: PathSegment) -> PathSegment {
         fold_path_segment(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_predicate_eq(&mut self, i: PredicateEq) -> PredicateEq {
         fold_predicate_eq(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_predicate_lifetime(&mut self, i: PredicateLifetime) -> PredicateLifetime {
         fold_predicate_lifetime(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_predicate_type(&mut self, i: PredicateType) -> PredicateType {
         fold_predicate_type(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_qself(&mut self, i: QSelf) -> QSelf {
         fold_qself(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn fold_range_limits(&mut self, i: RangeLimits) -> RangeLimits {
         fold_range_limits(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_return_type(&mut self, i: ReturnType) -> ReturnType {
         fold_return_type(self, i)
     }
-    fn fold_span(&mut self, i: Span) -> Span {
-        fold_span(self, i)
-    }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn fold_stmt(&mut self, i: Stmt) -> Stmt {
         fold_stmt(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_trait_bound(&mut self, i: TraitBound) -> TraitBound {
         fold_trait_bound(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_trait_bound_modifier(&mut self, i: TraitBoundModifier) -> TraitBoundModifier {
         fold_trait_bound_modifier(self, i)
     }
@@ -744,79 +684,79 @@ pub trait Fold {
     fn fold_trait_item_verbatim(&mut self, i: TraitItemVerbatim) -> TraitItemVerbatim {
         fold_trait_item_verbatim(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_type(&mut self, i: Type) -> Type {
         fold_type(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_type_array(&mut self, i: TypeArray) -> TypeArray {
         fold_type_array(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_type_bare_fn(&mut self, i: TypeBareFn) -> TypeBareFn {
         fold_type_bare_fn(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_type_group(&mut self, i: TypeGroup) -> TypeGroup {
         fold_type_group(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_type_impl_trait(&mut self, i: TypeImplTrait) -> TypeImplTrait {
         fold_type_impl_trait(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_type_infer(&mut self, i: TypeInfer) -> TypeInfer {
         fold_type_infer(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_type_macro(&mut self, i: TypeMacro) -> TypeMacro {
         fold_type_macro(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_type_never(&mut self, i: TypeNever) -> TypeNever {
         fold_type_never(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_type_param(&mut self, i: TypeParam) -> TypeParam {
         fold_type_param(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_type_param_bound(&mut self, i: TypeParamBound) -> TypeParamBound {
         fold_type_param_bound(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_type_paren(&mut self, i: TypeParen) -> TypeParen {
         fold_type_paren(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_type_path(&mut self, i: TypePath) -> TypePath {
         fold_type_path(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_type_ptr(&mut self, i: TypePtr) -> TypePtr {
         fold_type_ptr(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_type_reference(&mut self, i: TypeReference) -> TypeReference {
         fold_type_reference(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_type_slice(&mut self, i: TypeSlice) -> TypeSlice {
         fold_type_slice(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_type_trait_object(&mut self, i: TypeTraitObject) -> TypeTraitObject {
         fold_type_trait_object(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_type_tuple(&mut self, i: TypeTuple) -> TypeTuple {
         fold_type_tuple(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_type_verbatim(&mut self, i: TypeVerbatim) -> TypeVerbatim {
         fold_type_verbatim(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_un_op(&mut self, i: UnOp) -> UnOp {
         fold_un_op(self, i)
     }
@@ -844,34 +784,40 @@ pub trait Fold {
     fn fold_use_tree(&mut self, i: UseTree) -> UseTree {
         fold_use_tree(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_variant(&mut self, i: Variant) -> Variant {
         fold_variant(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_vis_crate(&mut self, i: VisCrate) -> VisCrate {
         fold_vis_crate(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_vis_public(&mut self, i: VisPublic) -> VisPublic {
         fold_vis_public(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_vis_restricted(&mut self, i: VisRestricted) -> VisRestricted {
         fold_vis_restricted(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_visibility(&mut self, i: Visibility) -> Visibility {
         fold_visibility(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_where_clause(&mut self, i: WhereClause) -> WhereClause {
         fold_where_clause(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn fold_where_predicate(&mut self, i: WherePredicate) -> WherePredicate {
         fold_where_predicate(self, i)
     }
+    fn fold_span(&mut self, i: Span) -> Span {
+        fold_span(self, i)
+    }
+    fn fold_ident(&mut self, i: Ident) -> Ident {
+        fold_ident(self, i)
+    }
 }
 #[cfg(any(feature = "full", feature = "derive"))]
 macro_rules! fold_span_only {
@@ -895,14 +841,14 @@ fold_span_only!(fold_lit_float: LitFloat);
 fold_span_only!(fold_lit_int: LitInt);
 #[cfg(any(feature = "full", feature = "derive"))]
 fold_span_only!(fold_lit_str: LitStr);
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_abi<V: Fold + ?Sized>(_visitor: &mut V, _i: Abi) -> Abi {
     Abi {
         extern_token: Token![extern](tokens_helper(_visitor, &_i.extern_token.span)),
         name: (_i.name).map(|it| _visitor.fold_lit_str(it)),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_angle_bracketed_generic_arguments<V: Fold + ?Sized>(
     _visitor: &mut V,
     _i: AngleBracketedGenericArguments,
@@ -926,7 +872,7 @@ pub fn fold_arg_captured<V: Fold + ?Sized>(_visitor: &mut V, _i: ArgCaptured) ->
 #[cfg(feature = "full")]
 pub fn fold_arg_self<V: Fold + ?Sized>(_visitor: &mut V, _i: ArgSelf) -> ArgSelf {
     ArgSelf {
-        mutability: (_i.mutability).map(|it| Token ! [ mut ](tokens_helper(_visitor, &it.span))),
+        mutability: (_i.mutability).map(|it| Token![mut](tokens_helper(_visitor, &it.span))),
         self_token: Token![self](tokens_helper(_visitor, &_i.self_token.span)),
     }
 }
@@ -935,11 +881,10 @@ pub fn fold_arg_self_ref<V: Fold + ?Sized>(_visitor: &mut V, _i: ArgSelfRef) ->
     ArgSelfRef {
         and_token: Token ! [ & ](tokens_helper(_visitor, &_i.and_token.spans)),
         lifetime: (_i.lifetime).map(|it| _visitor.fold_lifetime(it)),
-        mutability: (_i.mutability).map(|it| Token ! [ mut ](tokens_helper(_visitor, &it.span))),
+        mutability: (_i.mutability).map(|it| Token![mut](tokens_helper(_visitor, &it.span))),
         self_token: Token![self](tokens_helper(_visitor, &_i.self_token.span)),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn fold_arm<V: Fold + ?Sized>(_visitor: &mut V, _i: Arm) -> Arm {
     Arm {
@@ -948,7 +893,7 @@ pub fn fold_arm<V: Fold + ?Sized>(_visitor: &mut V, _i: Arm) -> Arm {
         pats: FoldHelper::lift(_i.pats, |it| _visitor.fold_pat(it)),
         guard: (_i.guard).map(|it| {
             (
-                Token ! [ if ](tokens_helper(_visitor, &(it).0.span)),
+                Token![if](tokens_helper(_visitor, &(it).0.span)),
                 Box::new(_visitor.fold_expr(*(it).1)),
             )
         }),
@@ -957,7 +902,7 @@ pub fn fold_arm<V: Fold + ?Sized>(_visitor: &mut V, _i: Arm) -> Arm {
         comma: (_i.comma).map(|it| Token ! [ , ](tokens_helper(_visitor, &it.spans))),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_attr_style<V: Fold + ?Sized>(_visitor: &mut V, _i: AttrStyle) -> AttrStyle {
     match _i {
         AttrStyle::Outer => AttrStyle::Outer,
@@ -966,7 +911,7 @@ pub fn fold_attr_style<V: Fold + ?Sized>(_visitor: &mut V, _i: AttrStyle) -> Att
         }
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_attribute<V: Fold + ?Sized>(_visitor: &mut V, _i: Attribute) -> Attribute {
     Attribute {
         pound_token: Token ! [ # ](tokens_helper(_visitor, &_i.pound_token.spans)),
@@ -976,7 +921,7 @@ pub fn fold_attribute<V: Fold + ?Sized>(_visitor: &mut V, _i: Attribute) -> Attr
         tts: _i.tts,
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_bare_fn_arg<V: Fold + ?Sized>(_visitor: &mut V, _i: BareFnArg) -> BareFnArg {
     BareFnArg {
         name: (_i.name).map(|it| {
@@ -988,7 +933,7 @@ pub fn fold_bare_fn_arg<V: Fold + ?Sized>(_visitor: &mut V, _i: BareFnArg) -> Ba
         ty: _visitor.fold_type(_i.ty),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_bare_fn_arg_name<V: Fold + ?Sized>(
     _visitor: &mut V,
     _i: BareFnArgName,
@@ -1000,7 +945,7 @@ pub fn fold_bare_fn_arg_name<V: Fold + ?Sized>(
         }
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_bin_op<V: Fold + ?Sized>(_visitor: &mut V, _i: BinOp) -> BinOp {
     match _i {
         BinOp::Add(_binding_0) => {
@@ -1089,7 +1034,7 @@ pub fn fold_bin_op<V: Fold + ?Sized>(_visitor: &mut V, _i: BinOp) -> BinOp {
         }
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_binding<V: Fold + ?Sized>(_visitor: &mut V, _i: Binding) -> Binding {
     Binding {
         ident: _visitor.fold_ident(_i.ident),
@@ -1097,7 +1042,6 @@ pub fn fold_binding<V: Fold + ?Sized>(_visitor: &mut V, _i: Binding) -> Binding
         ty: _visitor.fold_type(_i.ty),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn fold_block<V: Fold + ?Sized>(_visitor: &mut V, _i: Block) -> Block {
     Block {
@@ -1105,23 +1049,23 @@ pub fn fold_block<V: Fold + ?Sized>(_visitor: &mut V, _i: Block) -> Block {
         stmts: FoldHelper::lift(_i.stmts, |it| _visitor.fold_stmt(it)),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_bound_lifetimes<V: Fold + ?Sized>(
     _visitor: &mut V,
     _i: BoundLifetimes,
 ) -> BoundLifetimes {
     BoundLifetimes {
-        for_token: Token ! [ for ](tokens_helper(_visitor, &_i.for_token.span)),
+        for_token: Token![for](tokens_helper(_visitor, &_i.for_token.span)),
         lt_token: Token ! [ < ](tokens_helper(_visitor, &_i.lt_token.spans)),
         lifetimes: FoldHelper::lift(_i.lifetimes, |it| _visitor.fold_lifetime_def(it)),
         gt_token: Token ! [ > ](tokens_helper(_visitor, &_i.gt_token.spans)),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_const_param<V: Fold + ?Sized>(_visitor: &mut V, _i: ConstParam) -> ConstParam {
     ConstParam {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
-        const_token: Token ! [ const ](tokens_helper(_visitor, &_i.const_token.span)),
+        const_token: Token![const](tokens_helper(_visitor, &_i.const_token.span)),
         ident: _visitor.fold_ident(_i.ident),
         colon_token: Token ! [ : ](tokens_helper(_visitor, &_i.colon_token.spans)),
         ty: _visitor.fold_type(_i.ty),
@@ -1129,7 +1073,7 @@ pub fn fold_const_param<V: Fold + ?Sized>(_visitor: &mut V, _i: ConstParam) -> C
         default: (_i.default).map(|it| _visitor.fold_expr(it)),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_constraint<V: Fold + ?Sized>(_visitor: &mut V, _i: Constraint) -> Constraint {
     Constraint {
         ident: _visitor.fold_ident(_i.ident),
@@ -1148,7 +1092,7 @@ pub fn fold_data<V: Fold + ?Sized>(_visitor: &mut V, _i: Data) -> Data {
 #[cfg(feature = "derive")]
 pub fn fold_data_enum<V: Fold + ?Sized>(_visitor: &mut V, _i: DataEnum) -> DataEnum {
     DataEnum {
-        enum_token: Token ! [ enum ](tokens_helper(_visitor, &_i.enum_token.span)),
+        enum_token: Token![enum](tokens_helper(_visitor, &_i.enum_token.span)),
         brace_token: Brace(tokens_helper(_visitor, &_i.brace_token.span)),
         variants: FoldHelper::lift(_i.variants, |it| _visitor.fold_variant(it)),
     }
@@ -1156,7 +1100,7 @@ pub fn fold_data_enum<V: Fold + ?Sized>(_visitor: &mut V, _i: DataEnum) -> DataE
 #[cfg(feature = "derive")]
 pub fn fold_data_struct<V: Fold + ?Sized>(_visitor: &mut V, _i: DataStruct) -> DataStruct {
     DataStruct {
-        struct_token: Token ! [ struct ](tokens_helper(_visitor, &_i.struct_token.span)),
+        struct_token: Token![struct](tokens_helper(_visitor, &_i.struct_token.span)),
         fields: _visitor.fold_fields(_i.fields),
         semi_token: (_i.semi_token).map(|it| Token ! [ ; ](tokens_helper(_visitor, &it.spans))),
     }
@@ -1178,7 +1122,7 @@ pub fn fold_derive_input<V: Fold + ?Sized>(_visitor: &mut V, _i: DeriveInput) ->
         data: _visitor.fold_data(_i.data),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_expr<V: Fold + ?Sized>(_visitor: &mut V, _i: Expr) -> Expr {
     match _i {
         Expr::Box(_binding_0) => Expr::Box(full!(_visitor.fold_expr_box(_binding_0))),
@@ -1234,7 +1178,6 @@ pub fn fold_expr<V: Fold + ?Sized>(_visitor: &mut V, _i: Expr) -> Expr {
     }
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn fold_expr_array<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprArray) -> ExprArray {
     ExprArray {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
@@ -1243,7 +1186,6 @@ pub fn fold_expr_array<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprArray) -> Exp
     }
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn fold_expr_assign<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprAssign) -> ExprAssign {
     ExprAssign {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
@@ -1253,7 +1195,6 @@ pub fn fold_expr_assign<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprAssign) -> E
     }
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn fold_expr_assign_op<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprAssignOp) -> ExprAssignOp {
     ExprAssignOp {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
@@ -1263,16 +1204,15 @@ pub fn fold_expr_assign_op<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprAssignOp)
     }
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn fold_expr_async<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprAsync) -> ExprAsync {
     ExprAsync {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
         async_token: Token![async](tokens_helper(_visitor, &_i.async_token.span)),
-        capture: (_i.capture).map(|it| Token ! [ move ](tokens_helper(_visitor, &it.span))),
+        capture: (_i.capture).map(|it| Token![move](tokens_helper(_visitor, &it.span))),
         block: _visitor.fold_block(_i.block),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_expr_binary<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprBinary) -> ExprBinary {
     ExprBinary {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
@@ -1282,7 +1222,6 @@ pub fn fold_expr_binary<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprBinary) -> E
     }
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn fold_expr_block<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprBlock) -> ExprBlock {
     ExprBlock {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
@@ -1291,16 +1230,14 @@ pub fn fold_expr_block<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprBlock) -> Exp
     }
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn fold_expr_box<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprBox) -> ExprBox {
     ExprBox {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
-        box_token: Token ! [ box ](tokens_helper(_visitor, &_i.box_token.span)),
+        box_token: Token![box](tokens_helper(_visitor, &_i.box_token.span)),
         expr: Box::new(_visitor.fold_expr(*_i.expr)),
     }
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn fold_expr_break<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprBreak) -> ExprBreak {
     ExprBreak {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
@@ -1309,7 +1246,7 @@ pub fn fold_expr_break<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprBreak) -> Exp
         expr: (_i.expr).map(|it| Box::new(_visitor.fold_expr(*it))),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_expr_call<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprCall) -> ExprCall {
     ExprCall {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
@@ -1318,23 +1255,22 @@ pub fn fold_expr_call<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprCall) -> ExprC
         args: FoldHelper::lift(_i.args, |it| _visitor.fold_expr(it)),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_expr_cast<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprCast) -> ExprCast {
     ExprCast {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
         expr: Box::new(_visitor.fold_expr(*_i.expr)),
-        as_token: Token ! [ as ](tokens_helper(_visitor, &_i.as_token.span)),
+        as_token: Token![as](tokens_helper(_visitor, &_i.as_token.span)),
         ty: Box::new(_visitor.fold_type(*_i.ty)),
     }
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn fold_expr_closure<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprClosure) -> ExprClosure {
     ExprClosure {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
         asyncness: (_i.asyncness).map(|it| Token![async](tokens_helper(_visitor, &it.span))),
-        movability: (_i.movability).map(|it| Token ! [ static ](tokens_helper(_visitor, &it.span))),
-        capture: (_i.capture).map(|it| Token ! [ move ](tokens_helper(_visitor, &it.span))),
+        movability: (_i.movability).map(|it| Token![static](tokens_helper(_visitor, &it.span))),
+        capture: (_i.capture).map(|it| Token![move](tokens_helper(_visitor, &it.span))),
         or1_token: Token ! [ | ](tokens_helper(_visitor, &_i.or1_token.spans)),
         inputs: FoldHelper::lift(_i.inputs, |it| _visitor.fold_fn_arg(it)),
         or2_token: Token ! [ | ](tokens_helper(_visitor, &_i.or2_token.spans)),
@@ -1343,7 +1279,6 @@ pub fn fold_expr_closure<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprClosure) ->
     }
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn fold_expr_continue<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprContinue) -> ExprContinue {
     ExprContinue {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
@@ -1351,7 +1286,7 @@ pub fn fold_expr_continue<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprContinue)
         label: (_i.label).map(|it| _visitor.fold_lifetime(it)),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_expr_field<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprField) -> ExprField {
     ExprField {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
@@ -1361,20 +1296,18 @@ pub fn fold_expr_field<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprField) -> Exp
     }
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn fold_expr_for_loop<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprForLoop) -> ExprForLoop {
     ExprForLoop {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
         label: (_i.label).map(|it| _visitor.fold_label(it)),
-        for_token: Token ! [ for ](tokens_helper(_visitor, &_i.for_token.span)),
+        for_token: Token![for](tokens_helper(_visitor, &_i.for_token.span)),
         pat: Box::new(_visitor.fold_pat(*_i.pat)),
-        in_token: Token ! [ in ](tokens_helper(_visitor, &_i.in_token.span)),
+        in_token: Token![in](tokens_helper(_visitor, &_i.in_token.span)),
         expr: Box::new(_visitor.fold_expr(*_i.expr)),
         body: _visitor.fold_block(_i.body),
     }
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn fold_expr_group<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprGroup) -> ExprGroup {
     ExprGroup {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
@@ -1383,23 +1316,21 @@ pub fn fold_expr_group<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprGroup) -> Exp
     }
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn fold_expr_if<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprIf) -> ExprIf {
     ExprIf {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
-        if_token: Token ! [ if ](tokens_helper(_visitor, &_i.if_token.span)),
+        if_token: Token![if](tokens_helper(_visitor, &_i.if_token.span)),
         cond: Box::new(_visitor.fold_expr(*_i.cond)),
         then_branch: _visitor.fold_block(_i.then_branch),
         else_branch: (_i.else_branch).map(|it| {
             (
-                Token ! [ else ](tokens_helper(_visitor, &(it).0.span)),
+                Token![else](tokens_helper(_visitor, &(it).0.span)),
                 Box::new(_visitor.fold_expr(*(it).1)),
             )
         }),
     }
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn fold_expr_in_place<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprInPlace) -> ExprInPlace {
     ExprInPlace {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
@@ -1408,7 +1339,7 @@ pub fn fold_expr_in_place<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprInPlace) -
         value: Box::new(_visitor.fold_expr(*_i.value)),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_expr_index<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprIndex) -> ExprIndex {
     ExprIndex {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
@@ -1418,17 +1349,16 @@ pub fn fold_expr_index<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprIndex) -> Exp
     }
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn fold_expr_let<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprLet) -> ExprLet {
     ExprLet {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
-        let_token: Token ! [ let ](tokens_helper(_visitor, &_i.let_token.span)),
+        let_token: Token![let](tokens_helper(_visitor, &_i.let_token.span)),
         pats: FoldHelper::lift(_i.pats, |it| _visitor.fold_pat(it)),
         eq_token: Token ! [ = ](tokens_helper(_visitor, &_i.eq_token.spans)),
         expr: Box::new(_visitor.fold_expr(*_i.expr)),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_expr_lit<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprLit) -> ExprLit {
     ExprLit {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
@@ -1436,17 +1366,15 @@ pub fn fold_expr_lit<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprLit) -> ExprLit
     }
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn fold_expr_loop<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprLoop) -> ExprLoop {
     ExprLoop {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
         label: (_i.label).map(|it| _visitor.fold_label(it)),
-        loop_token: Token ! [ loop ](tokens_helper(_visitor, &_i.loop_token.span)),
+        loop_token: Token![loop](tokens_helper(_visitor, &_i.loop_token.span)),
         body: _visitor.fold_block(_i.body),
     }
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn fold_expr_macro<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprMacro) -> ExprMacro {
     ExprMacro {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
@@ -1454,18 +1382,16 @@ pub fn fold_expr_macro<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprMacro) -> Exp
     }
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn fold_expr_match<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprMatch) -> ExprMatch {
     ExprMatch {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
-        match_token: Token ! [ match ](tokens_helper(_visitor, &_i.match_token.span)),
+        match_token: Token![match](tokens_helper(_visitor, &_i.match_token.span)),
         expr: Box::new(_visitor.fold_expr(*_i.expr)),
         brace_token: Brace(tokens_helper(_visitor, &_i.brace_token.span)),
         arms: FoldHelper::lift(_i.arms, |it| _visitor.fold_arm(it)),
     }
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn fold_expr_method_call<V: Fold + ?Sized>(
     _visitor: &mut V,
     _i: ExprMethodCall,
@@ -1480,7 +1406,7 @@ pub fn fold_expr_method_call<V: Fold + ?Sized>(
         args: FoldHelper::lift(_i.args, |it| _visitor.fold_expr(it)),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_expr_paren<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprParen) -> ExprParen {
     ExprParen {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
@@ -1488,7 +1414,7 @@ pub fn fold_expr_paren<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprParen) -> Exp
         expr: Box::new(_visitor.fold_expr(*_i.expr)),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_expr_path<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprPath) -> ExprPath {
     ExprPath {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
@@ -1497,7 +1423,6 @@ pub fn fold_expr_path<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprPath) -> ExprP
     }
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn fold_expr_range<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprRange) -> ExprRange {
     ExprRange {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
@@ -1507,17 +1432,15 @@ pub fn fold_expr_range<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprRange) -> Exp
     }
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn fold_expr_reference<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprReference) -> ExprReference {
     ExprReference {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
         and_token: Token ! [ & ](tokens_helper(_visitor, &_i.and_token.spans)),
-        mutability: (_i.mutability).map(|it| Token ! [ mut ](tokens_helper(_visitor, &it.span))),
+        mutability: (_i.mutability).map(|it| Token![mut](tokens_helper(_visitor, &it.span))),
         expr: Box::new(_visitor.fold_expr(*_i.expr)),
     }
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn fold_expr_repeat<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprRepeat) -> ExprRepeat {
     ExprRepeat {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
@@ -1528,7 +1451,6 @@ pub fn fold_expr_repeat<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprRepeat) -> E
     }
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn fold_expr_return<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprReturn) -> ExprReturn {
     ExprReturn {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
@@ -1537,7 +1459,6 @@ pub fn fold_expr_return<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprReturn) -> E
     }
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn fold_expr_struct<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprStruct) -> ExprStruct {
     ExprStruct {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
@@ -1549,7 +1470,6 @@ pub fn fold_expr_struct<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprStruct) -> E
     }
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn fold_expr_try<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprTry) -> ExprTry {
     ExprTry {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
@@ -1558,7 +1478,6 @@ pub fn fold_expr_try<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprTry) -> ExprTry
     }
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn fold_expr_try_block<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprTryBlock) -> ExprTryBlock {
     ExprTryBlock {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
@@ -1567,7 +1486,6 @@ pub fn fold_expr_try_block<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprTryBlock)
     }
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn fold_expr_tuple<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprTuple) -> ExprTuple {
     ExprTuple {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
@@ -1576,7 +1494,6 @@ pub fn fold_expr_tuple<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprTuple) -> Exp
     }
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn fold_expr_type<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprType) -> ExprType {
     ExprType {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
@@ -1585,7 +1502,7 @@ pub fn fold_expr_type<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprType) -> ExprT
         ty: Box::new(_visitor.fold_type(*_i.ty)),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_expr_unary<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprUnary) -> ExprUnary {
     ExprUnary {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
@@ -1594,31 +1511,28 @@ pub fn fold_expr_unary<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprUnary) -> Exp
     }
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn fold_expr_unsafe<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprUnsafe) -> ExprUnsafe {
     ExprUnsafe {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
-        unsafe_token: Token ! [ unsafe ](tokens_helper(_visitor, &_i.unsafe_token.span)),
+        unsafe_token: Token![unsafe](tokens_helper(_visitor, &_i.unsafe_token.span)),
         block: _visitor.fold_block(_i.block),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_expr_verbatim<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprVerbatim) -> ExprVerbatim {
     ExprVerbatim { tts: _i.tts }
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn fold_expr_while<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprWhile) -> ExprWhile {
     ExprWhile {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
         label: (_i.label).map(|it| _visitor.fold_label(it)),
-        while_token: Token ! [ while ](tokens_helper(_visitor, &_i.while_token.span)),
+        while_token: Token![while](tokens_helper(_visitor, &_i.while_token.span)),
         cond: Box::new(_visitor.fold_expr(*_i.cond)),
         body: _visitor.fold_block(_i.body),
     }
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn fold_expr_yield<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprYield) -> ExprYield {
     ExprYield {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
@@ -1626,7 +1540,7 @@ pub fn fold_expr_yield<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprYield) -> Exp
         expr: (_i.expr).map(|it| Box::new(_visitor.fold_expr(*it))),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_field<V: Fold + ?Sized>(_visitor: &mut V, _i: Field) -> Field {
     Field {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
@@ -1636,7 +1550,6 @@ pub fn fold_field<V: Fold + ?Sized>(_visitor: &mut V, _i: Field) -> Field {
         ty: _visitor.fold_type(_i.ty),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn fold_field_pat<V: Fold + ?Sized>(_visitor: &mut V, _i: FieldPat) -> FieldPat {
     FieldPat {
@@ -1646,7 +1559,6 @@ pub fn fold_field_pat<V: Fold + ?Sized>(_visitor: &mut V, _i: FieldPat) -> Field
         pat: Box::new(_visitor.fold_pat(*_i.pat)),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn fold_field_value<V: Fold + ?Sized>(_visitor: &mut V, _i: FieldValue) -> FieldValue {
     FieldValue {
@@ -1656,7 +1568,7 @@ pub fn fold_field_value<V: Fold + ?Sized>(_visitor: &mut V, _i: FieldValue) -> F
         expr: _visitor.fold_expr(_i.expr),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_fields<V: Fold + ?Sized>(_visitor: &mut V, _i: Fields) -> Fields {
     match _i {
         Fields::Named(_binding_0) => Fields::Named(_visitor.fold_fields_named(_binding_0)),
@@ -1664,14 +1576,14 @@ pub fn fold_fields<V: Fold + ?Sized>(_visitor: &mut V, _i: Fields) -> Fields {
         Fields::Unit => Fields::Unit,
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_fields_named<V: Fold + ?Sized>(_visitor: &mut V, _i: FieldsNamed) -> FieldsNamed {
     FieldsNamed {
         brace_token: Brace(tokens_helper(_visitor, &_i.brace_token.span)),
         named: FoldHelper::lift(_i.named, |it| _visitor.fold_field(it)),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_fields_unnamed<V: Fold + ?Sized>(_visitor: &mut V, _i: FieldsUnnamed) -> FieldsUnnamed {
     FieldsUnnamed {
         paren_token: Paren(tokens_helper(_visitor, &_i.paren_token.span)),
@@ -1699,7 +1611,7 @@ pub fn fold_fn_arg<V: Fold + ?Sized>(_visitor: &mut V, _i: FnArg) -> FnArg {
 #[cfg(feature = "full")]
 pub fn fold_fn_decl<V: Fold + ?Sized>(_visitor: &mut V, _i: FnDecl) -> FnDecl {
     FnDecl {
-        fn_token: Token ! [ fn ](tokens_helper(_visitor, &_i.fn_token.span)),
+        fn_token: Token![fn](tokens_helper(_visitor, &_i.fn_token.span)),
         generics: _visitor.fold_generics(_i.generics),
         paren_token: Paren(tokens_helper(_visitor, &_i.paren_token.span)),
         inputs: FoldHelper::lift(_i.inputs, |it| _visitor.fold_fn_arg(it)),
@@ -1757,8 +1669,8 @@ pub fn fold_foreign_item_static<V: Fold + ?Sized>(
     ForeignItemStatic {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
         vis: _visitor.fold_visibility(_i.vis),
-        static_token: Token ! [ static ](tokens_helper(_visitor, &_i.static_token.span)),
-        mutability: (_i.mutability).map(|it| Token ! [ mut ](tokens_helper(_visitor, &it.span))),
+        static_token: Token![static](tokens_helper(_visitor, &_i.static_token.span)),
+        mutability: (_i.mutability).map(|it| Token![mut](tokens_helper(_visitor, &it.span))),
         ident: _visitor.fold_ident(_i.ident),
         colon_token: Token ! [ : ](tokens_helper(_visitor, &_i.colon_token.spans)),
         ty: Box::new(_visitor.fold_type(*_i.ty)),
@@ -1773,7 +1685,7 @@ pub fn fold_foreign_item_type<V: Fold + ?Sized>(
     ForeignItemType {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
         vis: _visitor.fold_visibility(_i.vis),
-        type_token: Token ! [ type ](tokens_helper(_visitor, &_i.type_token.span)),
+        type_token: Token![type](tokens_helper(_visitor, &_i.type_token.span)),
         ident: _visitor.fold_ident(_i.ident),
         semi_token: Token ! [ ; ](tokens_helper(_visitor, &_i.semi_token.spans)),
     }
@@ -1785,7 +1697,7 @@ pub fn fold_foreign_item_verbatim<V: Fold + ?Sized>(
 ) -> ForeignItemVerbatim {
     ForeignItemVerbatim { tts: _i.tts }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_generic_argument<V: Fold + ?Sized>(
     _visitor: &mut V,
     _i: GenericArgument,
@@ -1806,7 +1718,6 @@ pub fn fold_generic_argument<V: Fold + ?Sized>(
         }
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn fold_generic_method_argument<V: Fold + ?Sized>(
     _visitor: &mut V,
@@ -1821,7 +1732,7 @@ pub fn fold_generic_method_argument<V: Fold + ?Sized>(
         }
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_generic_param<V: Fold + ?Sized>(_visitor: &mut V, _i: GenericParam) -> GenericParam {
     match _i {
         GenericParam::Type(_binding_0) => GenericParam::Type(_visitor.fold_type_param(_binding_0)),
@@ -1833,7 +1744,7 @@ pub fn fold_generic_param<V: Fold + ?Sized>(_visitor: &mut V, _i: GenericParam)
         }
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_generics<V: Fold + ?Sized>(_visitor: &mut V, _i: Generics) -> Generics {
     Generics {
         lt_token: (_i.lt_token).map(|it| Token ! [ < ](tokens_helper(_visitor, &it.spans))),
@@ -1842,12 +1753,6 @@ pub fn fold_generics<V: Fold + ?Sized>(_visitor: &mut V, _i: Generics) -> Generi
         where_clause: (_i.where_clause).map(|it| _visitor.fold_where_clause(it)),
     }
 }
-pub fn fold_ident<V: Fold + ?Sized>(_visitor: &mut V, _i: Ident) -> Ident {
-    let mut _i = _i;
-    let span = _visitor.fold_span(_i.span());
-    _i.set_span(span);
-    _i
-}
 #[cfg(feature = "full")]
 pub fn fold_impl_item<V: Fold + ?Sized>(_visitor: &mut V, _i: ImplItem) -> ImplItem {
     match _i {
@@ -1874,7 +1779,7 @@ pub fn fold_impl_item_const<V: Fold + ?Sized>(
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
         vis: _visitor.fold_visibility(_i.vis),
         defaultness: (_i.defaultness).map(|it| Token![default](tokens_helper(_visitor, &it.span))),
-        const_token: Token ! [ const ](tokens_helper(_visitor, &_i.const_token.span)),
+        const_token: Token![const](tokens_helper(_visitor, &_i.const_token.span)),
         ident: _visitor.fold_ident(_i.ident),
         colon_token: Token ! [ : ](tokens_helper(_visitor, &_i.colon_token.spans)),
         ty: _visitor.fold_type(_i.ty),
@@ -1891,7 +1796,7 @@ pub fn fold_impl_item_existential<V: Fold + ?Sized>(
     ImplItemExistential {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
         existential_token: Token![existential](tokens_helper(_visitor, &_i.existential_token.span)),
-        type_token: Token ! [ type ](tokens_helper(_visitor, &_i.type_token.span)),
+        type_token: Token![type](tokens_helper(_visitor, &_i.type_token.span)),
         ident: _visitor.fold_ident(_i.ident),
         generics: _visitor.fold_generics(_i.generics),
         colon_token: (_i.colon_token).map(|it| Token ! [ : ](tokens_helper(_visitor, &it.spans))),
@@ -1929,7 +1834,7 @@ pub fn fold_impl_item_type<V: Fold + ?Sized>(_visitor: &mut V, _i: ImplItemType)
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
         vis: _visitor.fold_visibility(_i.vis),
         defaultness: (_i.defaultness).map(|it| Token![default](tokens_helper(_visitor, &it.span))),
-        type_token: Token ! [ type ](tokens_helper(_visitor, &_i.type_token.span)),
+        type_token: Token![type](tokens_helper(_visitor, &_i.type_token.span)),
         ident: _visitor.fold_ident(_i.ident),
         generics: _visitor.fold_generics(_i.generics),
         eq_token: Token ! [ = ](tokens_helper(_visitor, &_i.eq_token.spans)),
@@ -1944,7 +1849,7 @@ pub fn fold_impl_item_verbatim<V: Fold + ?Sized>(
 ) -> ImplItemVerbatim {
     ImplItemVerbatim { tts: _i.tts }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_index<V: Fold + ?Sized>(_visitor: &mut V, _i: Index) -> Index {
     Index {
         index: _i.index,
@@ -1987,7 +1892,7 @@ pub fn fold_item_const<V: Fold + ?Sized>(_visitor: &mut V, _i: ItemConst) -> Ite
     ItemConst {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
         vis: _visitor.fold_visibility(_i.vis),
-        const_token: Token ! [ const ](tokens_helper(_visitor, &_i.const_token.span)),
+        const_token: Token![const](tokens_helper(_visitor, &_i.const_token.span)),
         ident: _visitor.fold_ident(_i.ident),
         colon_token: Token ! [ : ](tokens_helper(_visitor, &_i.colon_token.spans)),
         ty: Box::new(_visitor.fold_type(*_i.ty)),
@@ -2001,7 +1906,7 @@ pub fn fold_item_enum<V: Fold + ?Sized>(_visitor: &mut V, _i: ItemEnum) -> ItemE
     ItemEnum {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
         vis: _visitor.fold_visibility(_i.vis),
-        enum_token: Token ! [ enum ](tokens_helper(_visitor, &_i.enum_token.span)),
+        enum_token: Token![enum](tokens_helper(_visitor, &_i.enum_token.span)),
         ident: _visitor.fold_ident(_i.ident),
         generics: _visitor.fold_generics(_i.generics),
         brace_token: Brace(tokens_helper(_visitor, &_i.brace_token.span)),
@@ -2017,7 +1922,7 @@ pub fn fold_item_existential<V: Fold + ?Sized>(
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
         vis: _visitor.fold_visibility(_i.vis),
         existential_token: Token![existential](tokens_helper(_visitor, &_i.existential_token.span)),
-        type_token: Token ! [ type ](tokens_helper(_visitor, &_i.type_token.span)),
+        type_token: Token![type](tokens_helper(_visitor, &_i.type_token.span)),
         ident: _visitor.fold_ident(_i.ident),
         generics: _visitor.fold_generics(_i.generics),
         colon_token: (_i.colon_token).map(|it| Token ! [ : ](tokens_helper(_visitor, &it.spans))),
@@ -2038,7 +1943,7 @@ pub fn fold_item_extern_crate<V: Fold + ?Sized>(
         ident: _visitor.fold_ident(_i.ident),
         rename: (_i.rename).map(|it| {
             (
-                Token ! [ as ](tokens_helper(_visitor, &(it).0.span)),
+                Token![as](tokens_helper(_visitor, &(it).0.span)),
                 _visitor.fold_ident((it).1),
             )
         }),
@@ -2050,8 +1955,8 @@ pub fn fold_item_fn<V: Fold + ?Sized>(_visitor: &mut V, _i: ItemFn) -> ItemFn {
     ItemFn {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
         vis: _visitor.fold_visibility(_i.vis),
-        constness: (_i.constness).map(|it| Token ! [ const ](tokens_helper(_visitor, &it.span))),
-        unsafety: (_i.unsafety).map(|it| Token ! [ unsafe ](tokens_helper(_visitor, &it.span))),
+        constness: (_i.constness).map(|it| Token![const](tokens_helper(_visitor, &it.span))),
+        unsafety: (_i.unsafety).map(|it| Token![unsafe](tokens_helper(_visitor, &it.span))),
         asyncness: (_i.asyncness).map(|it| Token![async](tokens_helper(_visitor, &it.span))),
         abi: (_i.abi).map(|it| _visitor.fold_abi(it)),
         ident: _visitor.fold_ident(_i.ident),
@@ -2076,14 +1981,14 @@ pub fn fold_item_impl<V: Fold + ?Sized>(_visitor: &mut V, _i: ItemImpl) -> ItemI
     ItemImpl {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
         defaultness: (_i.defaultness).map(|it| Token![default](tokens_helper(_visitor, &it.span))),
-        unsafety: (_i.unsafety).map(|it| Token ! [ unsafe ](tokens_helper(_visitor, &it.span))),
-        impl_token: Token![impl ](tokens_helper(_visitor, &_i.impl_token.span)),
+        unsafety: (_i.unsafety).map(|it| Token![unsafe](tokens_helper(_visitor, &it.span))),
+        impl_token: Token![impl](tokens_helper(_visitor, &_i.impl_token.span)),
         generics: _visitor.fold_generics(_i.generics),
         trait_: (_i.trait_).map(|it| {
             (
                 ((it).0).map(|it| Token![!](tokens_helper(_visitor, &it.spans))),
                 _visitor.fold_path((it).1),
-                Token ! [ for ](tokens_helper(_visitor, &(it).2.span)),
+                Token![for](tokens_helper(_visitor, &(it).2.span)),
             )
         }),
         self_ty: Box::new(_visitor.fold_type(*_i.self_ty)),
@@ -2105,7 +2010,7 @@ pub fn fold_item_macro2<V: Fold + ?Sized>(_visitor: &mut V, _i: ItemMacro2) -> I
     ItemMacro2 {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
         vis: _visitor.fold_visibility(_i.vis),
-        macro_token: Token ! [ macro ](tokens_helper(_visitor, &_i.macro_token.span)),
+        macro_token: Token![macro](tokens_helper(_visitor, &_i.macro_token.span)),
         ident: _visitor.fold_ident(_i.ident),
         paren_token: Paren(tokens_helper(_visitor, &_i.paren_token.span)),
         args: _i.args,
@@ -2118,7 +2023,7 @@ pub fn fold_item_mod<V: Fold + ?Sized>(_visitor: &mut V, _i: ItemMod) -> ItemMod
     ItemMod {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
         vis: _visitor.fold_visibility(_i.vis),
-        mod_token: Token ! [ mod ](tokens_helper(_visitor, &_i.mod_token.span)),
+        mod_token: Token![mod](tokens_helper(_visitor, &_i.mod_token.span)),
         ident: _visitor.fold_ident(_i.ident),
         content: (_i.content).map(|it| {
             (
@@ -2134,8 +2039,8 @@ pub fn fold_item_static<V: Fold + ?Sized>(_visitor: &mut V, _i: ItemStatic) -> I
     ItemStatic {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
         vis: _visitor.fold_visibility(_i.vis),
-        static_token: Token ! [ static ](tokens_helper(_visitor, &_i.static_token.span)),
-        mutability: (_i.mutability).map(|it| Token ! [ mut ](tokens_helper(_visitor, &it.span))),
+        static_token: Token![static](tokens_helper(_visitor, &_i.static_token.span)),
+        mutability: (_i.mutability).map(|it| Token![mut](tokens_helper(_visitor, &it.span))),
         ident: _visitor.fold_ident(_i.ident),
         colon_token: Token ! [ : ](tokens_helper(_visitor, &_i.colon_token.spans)),
         ty: Box::new(_visitor.fold_type(*_i.ty)),
@@ -2149,7 +2054,7 @@ pub fn fold_item_struct<V: Fold + ?Sized>(_visitor: &mut V, _i: ItemStruct) -> I
     ItemStruct {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
         vis: _visitor.fold_visibility(_i.vis),
-        struct_token: Token ! [ struct ](tokens_helper(_visitor, &_i.struct_token.span)),
+        struct_token: Token![struct](tokens_helper(_visitor, &_i.struct_token.span)),
         ident: _visitor.fold_ident(_i.ident),
         generics: _visitor.fold_generics(_i.generics),
         fields: _visitor.fold_fields(_i.fields),
@@ -2161,9 +2066,9 @@ pub fn fold_item_trait<V: Fold + ?Sized>(_visitor: &mut V, _i: ItemTrait) -> Ite
     ItemTrait {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
         vis: _visitor.fold_visibility(_i.vis),
-        unsafety: (_i.unsafety).map(|it| Token ! [ unsafe ](tokens_helper(_visitor, &it.span))),
+        unsafety: (_i.unsafety).map(|it| Token![unsafe](tokens_helper(_visitor, &it.span))),
         auto_token: (_i.auto_token).map(|it| Token![auto](tokens_helper(_visitor, &it.span))),
-        trait_token: Token ! [ trait ](tokens_helper(_visitor, &_i.trait_token.span)),
+        trait_token: Token![trait](tokens_helper(_visitor, &_i.trait_token.span)),
         ident: _visitor.fold_ident(_i.ident),
         generics: _visitor.fold_generics(_i.generics),
         colon_token: (_i.colon_token).map(|it| Token ! [ : ](tokens_helper(_visitor, &it.spans))),
@@ -2180,7 +2085,7 @@ pub fn fold_item_trait_alias<V: Fold + ?Sized>(
     ItemTraitAlias {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
         vis: _visitor.fold_visibility(_i.vis),
-        trait_token: Token ! [ trait ](tokens_helper(_visitor, &_i.trait_token.span)),
+        trait_token: Token![trait](tokens_helper(_visitor, &_i.trait_token.span)),
         ident: _visitor.fold_ident(_i.ident),
         generics: _visitor.fold_generics(_i.generics),
         eq_token: Token ! [ = ](tokens_helper(_visitor, &_i.eq_token.spans)),
@@ -2193,7 +2098,7 @@ pub fn fold_item_type<V: Fold + ?Sized>(_visitor: &mut V, _i: ItemType) -> ItemT
     ItemType {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
         vis: _visitor.fold_visibility(_i.vis),
-        type_token: Token ! [ type ](tokens_helper(_visitor, &_i.type_token.span)),
+        type_token: Token![type](tokens_helper(_visitor, &_i.type_token.span)),
         ident: _visitor.fold_ident(_i.ident),
         generics: _visitor.fold_generics(_i.generics),
         eq_token: Token ! [ = ](tokens_helper(_visitor, &_i.eq_token.spans)),
@@ -2217,7 +2122,7 @@ pub fn fold_item_use<V: Fold + ?Sized>(_visitor: &mut V, _i: ItemUse) -> ItemUse
     ItemUse {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
         vis: _visitor.fold_visibility(_i.vis),
-        use_token: Token ! [ use ](tokens_helper(_visitor, &_i.use_token.span)),
+        use_token: Token![use](tokens_helper(_visitor, &_i.use_token.span)),
         leading_colon: (_i.leading_colon)
             .map(|it| Token ! [ :: ](tokens_helper(_visitor, &it.spans))),
         tree: _visitor.fold_use_tree(_i.tree),
@@ -2228,7 +2133,6 @@ pub fn fold_item_use<V: Fold + ?Sized>(_visitor: &mut V, _i: ItemUse) -> ItemUse
 pub fn fold_item_verbatim<V: Fold + ?Sized>(_visitor: &mut V, _i: ItemVerbatim) -> ItemVerbatim {
     ItemVerbatim { tts: _i.tts }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn fold_label<V: Fold + ?Sized>(_visitor: &mut V, _i: Label) -> Label {
     Label {
@@ -2242,7 +2146,7 @@ pub fn fold_lifetime<V: Fold + ?Sized>(_visitor: &mut V, _i: Lifetime) -> Lifeti
         ident: _visitor.fold_ident(_i.ident),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_lifetime_def<V: Fold + ?Sized>(_visitor: &mut V, _i: LifetimeDef) -> LifetimeDef {
     LifetimeDef {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
@@ -2251,7 +2155,7 @@ pub fn fold_lifetime_def<V: Fold + ?Sized>(_visitor: &mut V, _i: LifetimeDef) ->
         bounds: FoldHelper::lift(_i.bounds, |it| _visitor.fold_lifetime(it)),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_lit<V: Fold + ?Sized>(_visitor: &mut V, _i: Lit) -> Lit {
     match _i {
         Lit::Str(_binding_0) => Lit::Str(_visitor.fold_lit_str(_binding_0)),
@@ -2264,23 +2168,22 @@ pub fn fold_lit<V: Fold + ?Sized>(_visitor: &mut V, _i: Lit) -> Lit {
         Lit::Verbatim(_binding_0) => Lit::Verbatim(_visitor.fold_lit_verbatim(_binding_0)),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_lit_bool<V: Fold + ?Sized>(_visitor: &mut V, _i: LitBool) -> LitBool {
     LitBool {
         value: _i.value,
         span: _visitor.fold_span(_i.span),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_lit_verbatim<V: Fold + ?Sized>(_visitor: &mut V, _i: LitVerbatim) -> LitVerbatim {
     LitVerbatim { token: _i.token }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn fold_local<V: Fold + ?Sized>(_visitor: &mut V, _i: Local) -> Local {
     Local {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
-        let_token: Token ! [ let ](tokens_helper(_visitor, &_i.let_token.span)),
+        let_token: Token![let](tokens_helper(_visitor, &_i.let_token.span)),
         pats: FoldHelper::lift(_i.pats, |it| _visitor.fold_pat(it)),
         ty: (_i.ty).map(|it| {
             (
@@ -2297,7 +2200,7 @@ pub fn fold_local<V: Fold + ?Sized>(_visitor: &mut V, _i: Local) -> Local {
         semi_token: Token ! [ ; ](tokens_helper(_visitor, &_i.semi_token.spans)),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_macro<V: Fold + ?Sized>(_visitor: &mut V, _i: Macro) -> Macro {
     Macro {
         path: _visitor.fold_path(_i.path),
@@ -2306,7 +2209,7 @@ pub fn fold_macro<V: Fold + ?Sized>(_visitor: &mut V, _i: Macro) -> Macro {
         tts: _i.tts,
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_macro_delimiter<V: Fold + ?Sized>(
     _visitor: &mut V,
     _i: MacroDelimiter,
@@ -2323,14 +2226,14 @@ pub fn fold_macro_delimiter<V: Fold + ?Sized>(
         }
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_member<V: Fold + ?Sized>(_visitor: &mut V, _i: Member) -> Member {
     match _i {
         Member::Named(_binding_0) => Member::Named(_visitor.fold_ident(_binding_0)),
         Member::Unnamed(_binding_0) => Member::Unnamed(_visitor.fold_index(_binding_0)),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_meta<V: Fold + ?Sized>(_visitor: &mut V, _i: Meta) -> Meta {
     match _i {
         Meta::Word(_binding_0) => Meta::Word(_visitor.fold_ident(_binding_0)),
@@ -2338,7 +2241,7 @@ pub fn fold_meta<V: Fold + ?Sized>(_visitor: &mut V, _i: Meta) -> Meta {
         Meta::NameValue(_binding_0) => Meta::NameValue(_visitor.fold_meta_name_value(_binding_0)),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_meta_list<V: Fold + ?Sized>(_visitor: &mut V, _i: MetaList) -> MetaList {
     MetaList {
         ident: _visitor.fold_ident(_i.ident),
@@ -2346,7 +2249,7 @@ pub fn fold_meta_list<V: Fold + ?Sized>(_visitor: &mut V, _i: MetaList) -> MetaL
         nested: FoldHelper::lift(_i.nested, |it| _visitor.fold_nested_meta(it)),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_meta_name_value<V: Fold + ?Sized>(
     _visitor: &mut V,
     _i: MetaNameValue,
@@ -2360,15 +2263,14 @@ pub fn fold_meta_name_value<V: Fold + ?Sized>(
 #[cfg(feature = "full")]
 pub fn fold_method_sig<V: Fold + ?Sized>(_visitor: &mut V, _i: MethodSig) -> MethodSig {
     MethodSig {
-        constness: (_i.constness).map(|it| Token ! [ const ](tokens_helper(_visitor, &it.span))),
-        unsafety: (_i.unsafety).map(|it| Token ! [ unsafe ](tokens_helper(_visitor, &it.span))),
+        constness: (_i.constness).map(|it| Token![const](tokens_helper(_visitor, &it.span))),
+        unsafety: (_i.unsafety).map(|it| Token![unsafe](tokens_helper(_visitor, &it.span))),
         asyncness: (_i.asyncness).map(|it| Token![async](tokens_helper(_visitor, &it.span))),
         abi: (_i.abi).map(|it| _visitor.fold_abi(it)),
         ident: _visitor.fold_ident(_i.ident),
         decl: _visitor.fold_fn_decl(_i.decl),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn fold_method_turbofish<V: Fold + ?Sized>(
     _visitor: &mut V,
@@ -2381,14 +2283,14 @@ pub fn fold_method_turbofish<V: Fold + ?Sized>(
         gt_token: Token ! [ > ](tokens_helper(_visitor, &_i.gt_token.spans)),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_nested_meta<V: Fold + ?Sized>(_visitor: &mut V, _i: NestedMeta) -> NestedMeta {
     match _i {
         NestedMeta::Meta(_binding_0) => NestedMeta::Meta(_visitor.fold_meta(_binding_0)),
         NestedMeta::Literal(_binding_0) => NestedMeta::Literal(_visitor.fold_lit(_binding_0)),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_parenthesized_generic_arguments<V: Fold + ?Sized>(
     _visitor: &mut V,
     _i: ParenthesizedGenericArguments,
@@ -2399,7 +2301,6 @@ pub fn fold_parenthesized_generic_arguments<V: Fold + ?Sized>(
         output: _visitor.fold_return_type(_i.output),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn fold_pat<V: Fold + ?Sized>(_visitor: &mut V, _i: Pat) -> Pat {
     match _i {
@@ -2420,20 +2321,18 @@ pub fn fold_pat<V: Fold + ?Sized>(_visitor: &mut V, _i: Pat) -> Pat {
         Pat::Verbatim(_binding_0) => Pat::Verbatim(_visitor.fold_pat_verbatim(_binding_0)),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn fold_pat_box<V: Fold + ?Sized>(_visitor: &mut V, _i: PatBox) -> PatBox {
     PatBox {
-        box_token: Token ! [ box ](tokens_helper(_visitor, &_i.box_token.span)),
+        box_token: Token![box](tokens_helper(_visitor, &_i.box_token.span)),
         pat: Box::new(_visitor.fold_pat(*_i.pat)),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn fold_pat_ident<V: Fold + ?Sized>(_visitor: &mut V, _i: PatIdent) -> PatIdent {
     PatIdent {
-        by_ref: (_i.by_ref).map(|it| Token ! [ ref ](tokens_helper(_visitor, &it.span))),
-        mutability: (_i.mutability).map(|it| Token ! [ mut ](tokens_helper(_visitor, &it.span))),
+        by_ref: (_i.by_ref).map(|it| Token![ref](tokens_helper(_visitor, &it.span))),
+        mutability: (_i.mutability).map(|it| Token![mut](tokens_helper(_visitor, &it.span))),
         ident: _visitor.fold_ident(_i.ident),
         subpat: (_i.subpat).map(|it| {
             (
@@ -2443,21 +2342,18 @@ pub fn fold_pat_ident<V: Fold + ?Sized>(_visitor: &mut V, _i: PatIdent) -> PatId
         }),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn fold_pat_lit<V: Fold + ?Sized>(_visitor: &mut V, _i: PatLit) -> PatLit {
     PatLit {
         expr: Box::new(_visitor.fold_expr(*_i.expr)),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn fold_pat_macro<V: Fold + ?Sized>(_visitor: &mut V, _i: PatMacro) -> PatMacro {
     PatMacro {
         mac: _visitor.fold_macro(_i.mac),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn fold_pat_path<V: Fold + ?Sized>(_visitor: &mut V, _i: PatPath) -> PatPath {
     PatPath {
@@ -2465,7 +2361,6 @@ pub fn fold_pat_path<V: Fold + ?Sized>(_visitor: &mut V, _i: PatPath) -> PatPath
         path: _visitor.fold_path(_i.path),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn fold_pat_range<V: Fold + ?Sized>(_visitor: &mut V, _i: PatRange) -> PatRange {
     PatRange {
@@ -2474,16 +2369,14 @@ pub fn fold_pat_range<V: Fold + ?Sized>(_visitor: &mut V, _i: PatRange) -> PatRa
         hi: Box::new(_visitor.fold_expr(*_i.hi)),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn fold_pat_ref<V: Fold + ?Sized>(_visitor: &mut V, _i: PatRef) -> PatRef {
     PatRef {
         and_token: Token ! [ & ](tokens_helper(_visitor, &_i.and_token.spans)),
-        mutability: (_i.mutability).map(|it| Token ! [ mut ](tokens_helper(_visitor, &it.span))),
+        mutability: (_i.mutability).map(|it| Token![mut](tokens_helper(_visitor, &it.span))),
         pat: Box::new(_visitor.fold_pat(*_i.pat)),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn fold_pat_slice<V: Fold + ?Sized>(_visitor: &mut V, _i: PatSlice) -> PatSlice {
     PatSlice {
@@ -2495,7 +2388,6 @@ pub fn fold_pat_slice<V: Fold + ?Sized>(_visitor: &mut V, _i: PatSlice) -> PatSl
         back: FoldHelper::lift(_i.back, |it| _visitor.fold_pat(it)),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn fold_pat_struct<V: Fold + ?Sized>(_visitor: &mut V, _i: PatStruct) -> PatStruct {
     PatStruct {
@@ -2505,7 +2397,6 @@ pub fn fold_pat_struct<V: Fold + ?Sized>(_visitor: &mut V, _i: PatStruct) -> Pat
         dot2_token: (_i.dot2_token).map(|it| Token![..](tokens_helper(_visitor, &it.spans))),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn fold_pat_tuple<V: Fold + ?Sized>(_visitor: &mut V, _i: PatTuple) -> PatTuple {
     PatTuple {
@@ -2516,7 +2407,6 @@ pub fn fold_pat_tuple<V: Fold + ?Sized>(_visitor: &mut V, _i: PatTuple) -> PatTu
         back: FoldHelper::lift(_i.back, |it| _visitor.fold_pat(it)),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn fold_pat_tuple_struct<V: Fold + ?Sized>(
     _visitor: &mut V,
@@ -2527,19 +2417,17 @@ pub fn fold_pat_tuple_struct<V: Fold + ?Sized>(
         pat: _visitor.fold_pat_tuple(_i.pat),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn fold_pat_verbatim<V: Fold + ?Sized>(_visitor: &mut V, _i: PatVerbatim) -> PatVerbatim {
     PatVerbatim { tts: _i.tts }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn fold_pat_wild<V: Fold + ?Sized>(_visitor: &mut V, _i: PatWild) -> PatWild {
     PatWild {
         underscore_token: Token![_](tokens_helper(_visitor, &_i.underscore_token.spans)),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_path<V: Fold + ?Sized>(_visitor: &mut V, _i: Path) -> Path {
     Path {
         leading_colon: (_i.leading_colon)
@@ -2547,7 +2435,7 @@ pub fn fold_path<V: Fold + ?Sized>(_visitor: &mut V, _i: Path) -> Path {
         segments: FoldHelper::lift(_i.segments, |it| _visitor.fold_path_segment(it)),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_path_arguments<V: Fold + ?Sized>(_visitor: &mut V, _i: PathArguments) -> PathArguments {
     match _i {
         PathArguments::None => PathArguments::None,
@@ -2559,14 +2447,14 @@ pub fn fold_path_arguments<V: Fold + ?Sized>(_visitor: &mut V, _i: PathArguments
         }
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_path_segment<V: Fold + ?Sized>(_visitor: &mut V, _i: PathSegment) -> PathSegment {
     PathSegment {
         ident: _visitor.fold_ident(_i.ident),
         arguments: _visitor.fold_path_arguments(_i.arguments),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_predicate_eq<V: Fold + ?Sized>(_visitor: &mut V, _i: PredicateEq) -> PredicateEq {
     PredicateEq {
         lhs_ty: _visitor.fold_type(_i.lhs_ty),
@@ -2574,7 +2462,7 @@ pub fn fold_predicate_eq<V: Fold + ?Sized>(_visitor: &mut V, _i: PredicateEq) ->
         rhs_ty: _visitor.fold_type(_i.rhs_ty),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_predicate_lifetime<V: Fold + ?Sized>(
     _visitor: &mut V,
     _i: PredicateLifetime,
@@ -2585,7 +2473,7 @@ pub fn fold_predicate_lifetime<V: Fold + ?Sized>(
         bounds: FoldHelper::lift(_i.bounds, |it| _visitor.fold_lifetime(it)),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_predicate_type<V: Fold + ?Sized>(_visitor: &mut V, _i: PredicateType) -> PredicateType {
     PredicateType {
         lifetimes: (_i.lifetimes).map(|it| _visitor.fold_bound_lifetimes(it)),
@@ -2594,17 +2482,16 @@ pub fn fold_predicate_type<V: Fold + ?Sized>(_visitor: &mut V, _i: PredicateType
         bounds: FoldHelper::lift(_i.bounds, |it| _visitor.fold_type_param_bound(it)),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_qself<V: Fold + ?Sized>(_visitor: &mut V, _i: QSelf) -> QSelf {
     QSelf {
         lt_token: Token ! [ < ](tokens_helper(_visitor, &_i.lt_token.spans)),
         ty: Box::new(_visitor.fold_type(*_i.ty)),
         position: _i.position,
-        as_token: (_i.as_token).map(|it| Token ! [ as ](tokens_helper(_visitor, &it.span))),
+        as_token: (_i.as_token).map(|it| Token![as](tokens_helper(_visitor, &it.span))),
         gt_token: Token ! [ > ](tokens_helper(_visitor, &_i.gt_token.spans)),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn fold_range_limits<V: Fold + ?Sized>(_visitor: &mut V, _i: RangeLimits) -> RangeLimits {
     match _i {
@@ -2616,7 +2503,7 @@ pub fn fold_range_limits<V: Fold + ?Sized>(_visitor: &mut V, _i: RangeLimits) ->
         }
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_return_type<V: Fold + ?Sized>(_visitor: &mut V, _i: ReturnType) -> ReturnType {
     match _i {
         ReturnType::Default => ReturnType::Default,
@@ -2626,10 +2513,6 @@ pub fn fold_return_type<V: Fold + ?Sized>(_visitor: &mut V, _i: ReturnType) -> R
         ),
     }
 }
-pub fn fold_span<V: Fold + ?Sized>(_visitor: &mut V, _i: Span) -> Span {
-    _i
-}
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn fold_stmt<V: Fold + ?Sized>(_visitor: &mut V, _i: Stmt) -> Stmt {
     match _i {
@@ -2642,7 +2525,7 @@ pub fn fold_stmt<V: Fold + ?Sized>(_visitor: &mut V, _i: Stmt) -> Stmt {
         ),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_trait_bound<V: Fold + ?Sized>(_visitor: &mut V, _i: TraitBound) -> TraitBound {
     TraitBound {
         paren_token: (_i.paren_token).map(|it| Paren(tokens_helper(_visitor, &it.span))),
@@ -2651,7 +2534,7 @@ pub fn fold_trait_bound<V: Fold + ?Sized>(_visitor: &mut V, _i: TraitBound) -> T
         path: _visitor.fold_path(_i.path),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_trait_bound_modifier<V: Fold + ?Sized>(
     _visitor: &mut V,
     _i: TraitBoundModifier,
@@ -2688,7 +2571,7 @@ pub fn fold_trait_item_const<V: Fold + ?Sized>(
 ) -> TraitItemConst {
     TraitItemConst {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
-        const_token: Token ! [ const ](tokens_helper(_visitor, &_i.const_token.span)),
+        const_token: Token![const](tokens_helper(_visitor, &_i.const_token.span)),
         ident: _visitor.fold_ident(_i.ident),
         colon_token: Token ! [ : ](tokens_helper(_visitor, &_i.colon_token.spans)),
         ty: _visitor.fold_type(_i.ty),
@@ -2731,7 +2614,7 @@ pub fn fold_trait_item_type<V: Fold + ?Sized>(
 ) -> TraitItemType {
     TraitItemType {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
-        type_token: Token ! [ type ](tokens_helper(_visitor, &_i.type_token.span)),
+        type_token: Token![type](tokens_helper(_visitor, &_i.type_token.span)),
         ident: _visitor.fold_ident(_i.ident),
         generics: _visitor.fold_generics(_i.generics),
         colon_token: (_i.colon_token).map(|it| Token ! [ : ](tokens_helper(_visitor, &it.spans))),
@@ -2752,7 +2635,7 @@ pub fn fold_trait_item_verbatim<V: Fold + ?Sized>(
 ) -> TraitItemVerbatim {
     TraitItemVerbatim { tts: _i.tts }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_type<V: Fold + ?Sized>(_visitor: &mut V, _i: Type) -> Type {
     match _i {
         Type::Slice(_binding_0) => Type::Slice(_visitor.fold_type_slice(_binding_0)),
@@ -2774,7 +2657,7 @@ pub fn fold_type<V: Fold + ?Sized>(_visitor: &mut V, _i: Type) -> Type {
         Type::Verbatim(_binding_0) => Type::Verbatim(_visitor.fold_type_verbatim(_binding_0)),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_type_array<V: Fold + ?Sized>(_visitor: &mut V, _i: TypeArray) -> TypeArray {
     TypeArray {
         bracket_token: Bracket(tokens_helper(_visitor, &_i.bracket_token.span)),
@@ -2783,55 +2666,55 @@ pub fn fold_type_array<V: Fold + ?Sized>(_visitor: &mut V, _i: TypeArray) -> Typ
         len: _visitor.fold_expr(_i.len),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_type_bare_fn<V: Fold + ?Sized>(_visitor: &mut V, _i: TypeBareFn) -> TypeBareFn {
     TypeBareFn {
         lifetimes: (_i.lifetimes).map(|it| _visitor.fold_bound_lifetimes(it)),
-        unsafety: (_i.unsafety).map(|it| Token ! [ unsafe ](tokens_helper(_visitor, &it.span))),
+        unsafety: (_i.unsafety).map(|it| Token![unsafe](tokens_helper(_visitor, &it.span))),
         abi: (_i.abi).map(|it| _visitor.fold_abi(it)),
-        fn_token: Token ! [ fn ](tokens_helper(_visitor, &_i.fn_token.span)),
+        fn_token: Token![fn](tokens_helper(_visitor, &_i.fn_token.span)),
         paren_token: Paren(tokens_helper(_visitor, &_i.paren_token.span)),
         inputs: FoldHelper::lift(_i.inputs, |it| _visitor.fold_bare_fn_arg(it)),
         variadic: (_i.variadic).map(|it| Token ! [ ... ](tokens_helper(_visitor, &it.spans))),
         output: _visitor.fold_return_type(_i.output),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_type_group<V: Fold + ?Sized>(_visitor: &mut V, _i: TypeGroup) -> TypeGroup {
     TypeGroup {
         group_token: Group(tokens_helper(_visitor, &_i.group_token.span)),
         elem: Box::new(_visitor.fold_type(*_i.elem)),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_type_impl_trait<V: Fold + ?Sized>(
     _visitor: &mut V,
     _i: TypeImplTrait,
 ) -> TypeImplTrait {
     TypeImplTrait {
-        impl_token: Token![impl ](tokens_helper(_visitor, &_i.impl_token.span)),
+        impl_token: Token![impl](tokens_helper(_visitor, &_i.impl_token.span)),
         bounds: FoldHelper::lift(_i.bounds, |it| _visitor.fold_type_param_bound(it)),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_type_infer<V: Fold + ?Sized>(_visitor: &mut V, _i: TypeInfer) -> TypeInfer {
     TypeInfer {
         underscore_token: Token![_](tokens_helper(_visitor, &_i.underscore_token.spans)),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_type_macro<V: Fold + ?Sized>(_visitor: &mut V, _i: TypeMacro) -> TypeMacro {
     TypeMacro {
         mac: _visitor.fold_macro(_i.mac),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_type_never<V: Fold + ?Sized>(_visitor: &mut V, _i: TypeNever) -> TypeNever {
     TypeNever {
         bang_token: Token![!](tokens_helper(_visitor, &_i.bang_token.spans)),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_type_param<V: Fold + ?Sized>(_visitor: &mut V, _i: TypeParam) -> TypeParam {
     TypeParam {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
@@ -2842,7 +2725,7 @@ pub fn fold_type_param<V: Fold + ?Sized>(_visitor: &mut V, _i: TypeParam) -> Typ
         default: (_i.default).map(|it| _visitor.fold_type(it)),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_type_param_bound<V: Fold + ?Sized>(
     _visitor: &mut V,
     _i: TypeParamBound,
@@ -2856,47 +2739,46 @@ pub fn fold_type_param_bound<V: Fold + ?Sized>(
         }
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_type_paren<V: Fold + ?Sized>(_visitor: &mut V, _i: TypeParen) -> TypeParen {
     TypeParen {
         paren_token: Paren(tokens_helper(_visitor, &_i.paren_token.span)),
         elem: Box::new(_visitor.fold_type(*_i.elem)),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_type_path<V: Fold + ?Sized>(_visitor: &mut V, _i: TypePath) -> TypePath {
     TypePath {
         qself: (_i.qself).map(|it| _visitor.fold_qself(it)),
         path: _visitor.fold_path(_i.path),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_type_ptr<V: Fold + ?Sized>(_visitor: &mut V, _i: TypePtr) -> TypePtr {
     TypePtr {
         star_token: Token ! [ * ](tokens_helper(_visitor, &_i.star_token.spans)),
-        const_token: (_i.const_token)
-            .map(|it| Token ! [ const ](tokens_helper(_visitor, &it.span))),
-        mutability: (_i.mutability).map(|it| Token ! [ mut ](tokens_helper(_visitor, &it.span))),
+        const_token: (_i.const_token).map(|it| Token![const](tokens_helper(_visitor, &it.span))),
+        mutability: (_i.mutability).map(|it| Token![mut](tokens_helper(_visitor, &it.span))),
         elem: Box::new(_visitor.fold_type(*_i.elem)),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_type_reference<V: Fold + ?Sized>(_visitor: &mut V, _i: TypeReference) -> TypeReference {
     TypeReference {
         and_token: Token ! [ & ](tokens_helper(_visitor, &_i.and_token.spans)),
         lifetime: (_i.lifetime).map(|it| _visitor.fold_lifetime(it)),
-        mutability: (_i.mutability).map(|it| Token ! [ mut ](tokens_helper(_visitor, &it.span))),
+        mutability: (_i.mutability).map(|it| Token![mut](tokens_helper(_visitor, &it.span))),
         elem: Box::new(_visitor.fold_type(*_i.elem)),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_type_slice<V: Fold + ?Sized>(_visitor: &mut V, _i: TypeSlice) -> TypeSlice {
     TypeSlice {
         bracket_token: Bracket(tokens_helper(_visitor, &_i.bracket_token.span)),
         elem: Box::new(_visitor.fold_type(*_i.elem)),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_type_trait_object<V: Fold + ?Sized>(
     _visitor: &mut V,
     _i: TypeTraitObject,
@@ -2906,18 +2788,18 @@ pub fn fold_type_trait_object<V: Fold + ?Sized>(
         bounds: FoldHelper::lift(_i.bounds, |it| _visitor.fold_type_param_bound(it)),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_type_tuple<V: Fold + ?Sized>(_visitor: &mut V, _i: TypeTuple) -> TypeTuple {
     TypeTuple {
         paren_token: Paren(tokens_helper(_visitor, &_i.paren_token.span)),
         elems: FoldHelper::lift(_i.elems, |it| _visitor.fold_type(it)),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_type_verbatim<V: Fold + ?Sized>(_visitor: &mut V, _i: TypeVerbatim) -> TypeVerbatim {
     TypeVerbatim { tts: _i.tts }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_un_op<V: Fold + ?Sized>(_visitor: &mut V, _i: UnOp) -> UnOp {
     match _i {
         UnOp::Deref(_binding_0) => {
@@ -2960,7 +2842,7 @@ pub fn fold_use_path<V: Fold + ?Sized>(_visitor: &mut V, _i: UsePath) -> UsePath
 pub fn fold_use_rename<V: Fold + ?Sized>(_visitor: &mut V, _i: UseRename) -> UseRename {
     UseRename {
         ident: _visitor.fold_ident(_i.ident),
-        as_token: Token ! [ as ](tokens_helper(_visitor, &_i.as_token.span)),
+        as_token: Token![as](tokens_helper(_visitor, &_i.as_token.span)),
         rename: _visitor.fold_ident(_i.rename),
     }
 }
@@ -2974,7 +2856,7 @@ pub fn fold_use_tree<V: Fold + ?Sized>(_visitor: &mut V, _i: UseTree) -> UseTree
         UseTree::Group(_binding_0) => UseTree::Group(_visitor.fold_use_group(_binding_0)),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_variant<V: Fold + ?Sized>(_visitor: &mut V, _i: Variant) -> Variant {
     Variant {
         attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
@@ -2988,28 +2870,28 @@ pub fn fold_variant<V: Fold + ?Sized>(_visitor: &mut V, _i: Variant) -> Variant
         }),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_vis_crate<V: Fold + ?Sized>(_visitor: &mut V, _i: VisCrate) -> VisCrate {
     VisCrate {
         crate_token: Token![crate](tokens_helper(_visitor, &_i.crate_token.span)),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_vis_public<V: Fold + ?Sized>(_visitor: &mut V, _i: VisPublic) -> VisPublic {
     VisPublic {
-        pub_token: Token ! [ pub ](tokens_helper(_visitor, &_i.pub_token.span)),
+        pub_token: Token![pub](tokens_helper(_visitor, &_i.pub_token.span)),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_vis_restricted<V: Fold + ?Sized>(_visitor: &mut V, _i: VisRestricted) -> VisRestricted {
     VisRestricted {
-        pub_token: Token ! [ pub ](tokens_helper(_visitor, &_i.pub_token.span)),
+        pub_token: Token![pub](tokens_helper(_visitor, &_i.pub_token.span)),
         paren_token: Paren(tokens_helper(_visitor, &_i.paren_token.span)),
-        in_token: (_i.in_token).map(|it| Token ! [ in ](tokens_helper(_visitor, &it.span))),
+        in_token: (_i.in_token).map(|it| Token![in](tokens_helper(_visitor, &it.span))),
         path: Box::new(_visitor.fold_path(*_i.path)),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_visibility<V: Fold + ?Sized>(_visitor: &mut V, _i: Visibility) -> Visibility {
     match _i {
         Visibility::Public(_binding_0) => Visibility::Public(_visitor.fold_vis_public(_binding_0)),
@@ -3020,14 +2902,14 @@ pub fn fold_visibility<V: Fold + ?Sized>(_visitor: &mut V, _i: Visibility) -> Vi
         Visibility::Inherited => Visibility::Inherited,
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_where_clause<V: Fold + ?Sized>(_visitor: &mut V, _i: WhereClause) -> WhereClause {
     WhereClause {
-        where_token: Token ! [ where ](tokens_helper(_visitor, &_i.where_token.span)),
+        where_token: Token![where](tokens_helper(_visitor, &_i.where_token.span)),
         predicates: FoldHelper::lift(_i.predicates, |it| _visitor.fold_where_predicate(it)),
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn fold_where_predicate<V: Fold + ?Sized>(
     _visitor: &mut V,
     _i: WherePredicate,
@@ -3044,3 +2926,12 @@ pub fn fold_where_predicate<V: Fold + ?Sized>(
         }
     }
 }
+pub fn fold_span<V: Fold + ?Sized>(_visitor: &mut V, _i: Span) -> Span {
+    _i
+}
+pub fn fold_ident<V: Fold + ?Sized>(_visitor: &mut V, _i: Ident) -> Ident {
+    let mut _i = _i;
+    let span = _visitor.fold_span(_i.span());
+    _i.set_span(span);
+    _i
+}
diff --git a/third_party/rust/syn/src/gen/visit.rs b/third_party/rust/syn/src/gen/visit.rs
index 1118fc914fb5..e449a0b9d625 100644
--- a/third_party/rust/syn/src/gen/visit.rs
+++ b/third_party/rust/syn/src/gen/visit.rs
@@ -23,19 +23,19 @@ macro_rules! full {
 macro_rules! skip {
     ($($tt:tt)*) => {};
 }
-#[doc = r" Syntax tree traversal to walk a shared borrow of a syntax tree."]
-#[doc = r""]
-#[doc = r" See the [module documentation] for details."]
-#[doc = r""]
-#[doc = r" [module documentation]: index.html"]
-#[doc = r""]
-#[doc = r#" *This trait is available if Syn is built with the `"visit"` feature.*"#]
+/// Syntax tree traversal to walk a shared borrow of a syntax tree.
+///
+/// See the [module documentation] for details.
+///
+/// [module documentation]: index.html
+///
+/// *This trait is available if Syn is built with the `"visit"` feature.*
 pub trait Visit<'ast> {
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_abi(&mut self, i: &'ast Abi) {
         visit_abi(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_angle_bracketed_generic_arguments(&mut self, i: &'ast AngleBracketedGenericArguments) {
         visit_angle_bracketed_generic_arguments(self, i)
     }
@@ -51,49 +51,47 @@ pub trait Visit<'ast> {
     fn visit_arg_self_ref(&mut self, i: &'ast ArgSelfRef) {
         visit_arg_self_ref(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn visit_arm(&mut self, i: &'ast Arm) {
         visit_arm(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_attr_style(&mut self, i: &'ast AttrStyle) {
         visit_attr_style(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_attribute(&mut self, i: &'ast Attribute) {
         visit_attribute(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_bare_fn_arg(&mut self, i: &'ast BareFnArg) {
         visit_bare_fn_arg(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_bare_fn_arg_name(&mut self, i: &'ast BareFnArgName) {
         visit_bare_fn_arg_name(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_bin_op(&mut self, i: &'ast BinOp) {
         visit_bin_op(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_binding(&mut self, i: &'ast Binding) {
         visit_binding(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn visit_block(&mut self, i: &'ast Block) {
         visit_block(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_bound_lifetimes(&mut self, i: &'ast BoundLifetimes) {
         visit_bound_lifetimes(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_const_param(&mut self, i: &'ast ConstParam) {
         visit_const_param(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_constraint(&mut self, i: &'ast Constraint) {
         visit_constraint(self, i)
     }
@@ -117,223 +115,191 @@ pub trait Visit<'ast> {
     fn visit_derive_input(&mut self, i: &'ast DeriveInput) {
         visit_derive_input(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_expr(&mut self, i: &'ast Expr) {
         visit_expr(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn visit_expr_array(&mut self, i: &'ast ExprArray) {
         visit_expr_array(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn visit_expr_assign(&mut self, i: &'ast ExprAssign) {
         visit_expr_assign(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn visit_expr_assign_op(&mut self, i: &'ast ExprAssignOp) {
         visit_expr_assign_op(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn visit_expr_async(&mut self, i: &'ast ExprAsync) {
         visit_expr_async(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_expr_binary(&mut self, i: &'ast ExprBinary) {
         visit_expr_binary(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn visit_expr_block(&mut self, i: &'ast ExprBlock) {
         visit_expr_block(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn visit_expr_box(&mut self, i: &'ast ExprBox) {
         visit_expr_box(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn visit_expr_break(&mut self, i: &'ast ExprBreak) {
         visit_expr_break(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_expr_call(&mut self, i: &'ast ExprCall) {
         visit_expr_call(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_expr_cast(&mut self, i: &'ast ExprCast) {
         visit_expr_cast(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn visit_expr_closure(&mut self, i: &'ast ExprClosure) {
         visit_expr_closure(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn visit_expr_continue(&mut self, i: &'ast ExprContinue) {
         visit_expr_continue(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_expr_field(&mut self, i: &'ast ExprField) {
         visit_expr_field(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn visit_expr_for_loop(&mut self, i: &'ast ExprForLoop) {
         visit_expr_for_loop(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn visit_expr_group(&mut self, i: &'ast ExprGroup) {
         visit_expr_group(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn visit_expr_if(&mut self, i: &'ast ExprIf) {
         visit_expr_if(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn visit_expr_in_place(&mut self, i: &'ast ExprInPlace) {
         visit_expr_in_place(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_expr_index(&mut self, i: &'ast ExprIndex) {
         visit_expr_index(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn visit_expr_let(&mut self, i: &'ast ExprLet) {
         visit_expr_let(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_expr_lit(&mut self, i: &'ast ExprLit) {
         visit_expr_lit(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn visit_expr_loop(&mut self, i: &'ast ExprLoop) {
         visit_expr_loop(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn visit_expr_macro(&mut self, i: &'ast ExprMacro) {
         visit_expr_macro(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn visit_expr_match(&mut self, i: &'ast ExprMatch) {
         visit_expr_match(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn visit_expr_method_call(&mut self, i: &'ast ExprMethodCall) {
         visit_expr_method_call(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_expr_paren(&mut self, i: &'ast ExprParen) {
         visit_expr_paren(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_expr_path(&mut self, i: &'ast ExprPath) {
         visit_expr_path(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn visit_expr_range(&mut self, i: &'ast ExprRange) {
         visit_expr_range(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn visit_expr_reference(&mut self, i: &'ast ExprReference) {
         visit_expr_reference(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn visit_expr_repeat(&mut self, i: &'ast ExprRepeat) {
         visit_expr_repeat(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn visit_expr_return(&mut self, i: &'ast ExprReturn) {
         visit_expr_return(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn visit_expr_struct(&mut self, i: &'ast ExprStruct) {
         visit_expr_struct(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn visit_expr_try(&mut self, i: &'ast ExprTry) {
         visit_expr_try(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn visit_expr_try_block(&mut self, i: &'ast ExprTryBlock) {
         visit_expr_try_block(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn visit_expr_tuple(&mut self, i: &'ast ExprTuple) {
         visit_expr_tuple(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn visit_expr_type(&mut self, i: &'ast ExprType) {
         visit_expr_type(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_expr_unary(&mut self, i: &'ast ExprUnary) {
         visit_expr_unary(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn visit_expr_unsafe(&mut self, i: &'ast ExprUnsafe) {
         visit_expr_unsafe(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_expr_verbatim(&mut self, i: &'ast ExprVerbatim) {
         visit_expr_verbatim(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn visit_expr_while(&mut self, i: &'ast ExprWhile) {
         visit_expr_while(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn visit_expr_yield(&mut self, i: &'ast ExprYield) {
         visit_expr_yield(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_field(&mut self, i: &'ast Field) {
         visit_field(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn visit_field_pat(&mut self, i: &'ast FieldPat) {
         visit_field_pat(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn visit_field_value(&mut self, i: &'ast FieldValue) {
         visit_field_value(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_fields(&mut self, i: &'ast Fields) {
         visit_fields(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_fields_named(&mut self, i: &'ast FieldsNamed) {
         visit_fields_named(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_fields_unnamed(&mut self, i: &'ast FieldsUnnamed) {
         visit_fields_unnamed(self, i)
     }
@@ -373,26 +339,22 @@ pub trait Visit<'ast> {
     fn visit_foreign_item_verbatim(&mut self, i: &'ast ForeignItemVerbatim) {
         visit_foreign_item_verbatim(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_generic_argument(&mut self, i: &'ast GenericArgument) {
         visit_generic_argument(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn visit_generic_method_argument(&mut self, i: &'ast GenericMethodArgument) {
         visit_generic_method_argument(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_generic_param(&mut self, i: &'ast GenericParam) {
         visit_generic_param(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_generics(&mut self, i: &'ast Generics) {
         visit_generics(self, i)
     }
-    fn visit_ident(&mut self, i: &'ast Ident) {
-        visit_ident(self, i)
-    }
     #[cfg(feature = "full")]
     fn visit_impl_item(&mut self, i: &'ast ImplItem) {
         visit_impl_item(self, i)
@@ -421,7 +383,7 @@ pub trait Visit<'ast> {
     fn visit_impl_item_verbatim(&mut self, i: &'ast ImplItemVerbatim) {
         visit_impl_item_verbatim(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_index(&mut self, i: &'ast Index) {
         visit_index(self, i)
     }
@@ -501,7 +463,6 @@ pub trait Visit<'ast> {
     fn visit_item_verbatim(&mut self, i: &'ast ItemVerbatim) {
         visit_item_verbatim(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn visit_label(&mut self, i: &'ast Label) {
         visit_label(self, i)
@@ -509,72 +470,71 @@ pub trait Visit<'ast> {
     fn visit_lifetime(&mut self, i: &'ast Lifetime) {
         visit_lifetime(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_lifetime_def(&mut self, i: &'ast LifetimeDef) {
         visit_lifetime_def(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_lit(&mut self, i: &'ast Lit) {
         visit_lit(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_lit_bool(&mut self, i: &'ast LitBool) {
         visit_lit_bool(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_lit_byte(&mut self, i: &'ast LitByte) {
         visit_lit_byte(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_lit_byte_str(&mut self, i: &'ast LitByteStr) {
         visit_lit_byte_str(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_lit_char(&mut self, i: &'ast LitChar) {
         visit_lit_char(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_lit_float(&mut self, i: &'ast LitFloat) {
         visit_lit_float(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_lit_int(&mut self, i: &'ast LitInt) {
         visit_lit_int(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_lit_str(&mut self, i: &'ast LitStr) {
         visit_lit_str(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_lit_verbatim(&mut self, i: &'ast LitVerbatim) {
         visit_lit_verbatim(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn visit_local(&mut self, i: &'ast Local) {
         visit_local(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_macro(&mut self, i: &'ast Macro) {
         visit_macro(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_macro_delimiter(&mut self, i: &'ast MacroDelimiter) {
         visit_macro_delimiter(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_member(&mut self, i: &'ast Member) {
         visit_member(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_meta(&mut self, i: &'ast Meta) {
         visit_meta(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_meta_list(&mut self, i: &'ast MetaList) {
         visit_meta_list(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_meta_name_value(&mut self, i: &'ast MetaNameValue) {
         visit_meta_name_value(self, i)
     }
@@ -582,139 +542,119 @@ pub trait Visit<'ast> {
     fn visit_method_sig(&mut self, i: &'ast MethodSig) {
         visit_method_sig(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn visit_method_turbofish(&mut self, i: &'ast MethodTurbofish) {
         visit_method_turbofish(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_nested_meta(&mut self, i: &'ast NestedMeta) {
         visit_nested_meta(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_parenthesized_generic_arguments(&mut self, i: &'ast ParenthesizedGenericArguments) {
         visit_parenthesized_generic_arguments(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn visit_pat(&mut self, i: &'ast Pat) {
         visit_pat(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn visit_pat_box(&mut self, i: &'ast PatBox) {
         visit_pat_box(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn visit_pat_ident(&mut self, i: &'ast PatIdent) {
         visit_pat_ident(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn visit_pat_lit(&mut self, i: &'ast PatLit) {
         visit_pat_lit(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn visit_pat_macro(&mut self, i: &'ast PatMacro) {
         visit_pat_macro(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn visit_pat_path(&mut self, i: &'ast PatPath) {
         visit_pat_path(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn visit_pat_range(&mut self, i: &'ast PatRange) {
         visit_pat_range(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn visit_pat_ref(&mut self, i: &'ast PatRef) {
         visit_pat_ref(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn visit_pat_slice(&mut self, i: &'ast PatSlice) {
         visit_pat_slice(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn visit_pat_struct(&mut self, i: &'ast PatStruct) {
         visit_pat_struct(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn visit_pat_tuple(&mut self, i: &'ast PatTuple) {
         visit_pat_tuple(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn visit_pat_tuple_struct(&mut self, i: &'ast PatTupleStruct) {
         visit_pat_tuple_struct(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn visit_pat_verbatim(&mut self, i: &'ast PatVerbatim) {
         visit_pat_verbatim(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn visit_pat_wild(&mut self, i: &'ast PatWild) {
         visit_pat_wild(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_path(&mut self, i: &'ast Path) {
         visit_path(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_path_arguments(&mut self, i: &'ast PathArguments) {
         visit_path_arguments(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_path_segment(&mut self, i: &'ast PathSegment) {
         visit_path_segment(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_predicate_eq(&mut self, i: &'ast PredicateEq) {
         visit_predicate_eq(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_predicate_lifetime(&mut self, i: &'ast PredicateLifetime) {
         visit_predicate_lifetime(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_predicate_type(&mut self, i: &'ast PredicateType) {
         visit_predicate_type(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_qself(&mut self, i: &'ast QSelf) {
         visit_qself(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn visit_range_limits(&mut self, i: &'ast RangeLimits) {
         visit_range_limits(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_return_type(&mut self, i: &'ast ReturnType) {
         visit_return_type(self, i)
     }
-    fn visit_span(&mut self, i: &'ast Span) {
-        visit_span(self, i)
-    }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn visit_stmt(&mut self, i: &'ast Stmt) {
         visit_stmt(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_trait_bound(&mut self, i: &'ast TraitBound) {
         visit_trait_bound(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_trait_bound_modifier(&mut self, i: &'ast TraitBoundModifier) {
         visit_trait_bound_modifier(self, i)
     }
@@ -742,79 +682,79 @@ pub trait Visit<'ast> {
     fn visit_trait_item_verbatim(&mut self, i: &'ast TraitItemVerbatim) {
         visit_trait_item_verbatim(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type(&mut self, i: &'ast Type) {
         visit_type(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_array(&mut self, i: &'ast TypeArray) {
         visit_type_array(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_bare_fn(&mut self, i: &'ast TypeBareFn) {
         visit_type_bare_fn(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_group(&mut self, i: &'ast TypeGroup) {
         visit_type_group(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_impl_trait(&mut self, i: &'ast TypeImplTrait) {
         visit_type_impl_trait(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_infer(&mut self, i: &'ast TypeInfer) {
         visit_type_infer(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_macro(&mut self, i: &'ast TypeMacro) {
         visit_type_macro(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_never(&mut self, i: &'ast TypeNever) {
         visit_type_never(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_param(&mut self, i: &'ast TypeParam) {
         visit_type_param(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_param_bound(&mut self, i: &'ast TypeParamBound) {
         visit_type_param_bound(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_paren(&mut self, i: &'ast TypeParen) {
         visit_type_paren(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_path(&mut self, i: &'ast TypePath) {
         visit_type_path(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_ptr(&mut self, i: &'ast TypePtr) {
         visit_type_ptr(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_reference(&mut self, i: &'ast TypeReference) {
         visit_type_reference(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_slice(&mut self, i: &'ast TypeSlice) {
         visit_type_slice(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_trait_object(&mut self, i: &'ast TypeTraitObject) {
         visit_type_trait_object(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_tuple(&mut self, i: &'ast TypeTuple) {
         visit_type_tuple(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_verbatim(&mut self, i: &'ast TypeVerbatim) {
         visit_type_verbatim(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_un_op(&mut self, i: &'ast UnOp) {
         visit_un_op(self, i)
     }
@@ -842,43 +782,49 @@ pub trait Visit<'ast> {
     fn visit_use_tree(&mut self, i: &'ast UseTree) {
         visit_use_tree(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_variant(&mut self, i: &'ast Variant) {
         visit_variant(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_vis_crate(&mut self, i: &'ast VisCrate) {
         visit_vis_crate(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_vis_public(&mut self, i: &'ast VisPublic) {
         visit_vis_public(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_vis_restricted(&mut self, i: &'ast VisRestricted) {
         visit_vis_restricted(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_visibility(&mut self, i: &'ast Visibility) {
         visit_visibility(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_where_clause(&mut self, i: &'ast WhereClause) {
         visit_where_clause(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_where_predicate(&mut self, i: &'ast WherePredicate) {
         visit_where_predicate(self, i)
     }
+    fn visit_span(&mut self, i: &'ast Span) {
+        visit_span(self, i)
+    }
+    fn visit_ident(&mut self, i: &'ast Ident) {
+        visit_ident(self, i)
+    }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_abi<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Abi) {
     tokens_helper(_visitor, &_i.extern_token.span);
     if let Some(ref it) = _i.name {
         _visitor.visit_lit_str(it)
     };
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_angle_bracketed_generic_arguments<'ast, V: Visit<'ast> + ?Sized>(
     _visitor: &mut V,
     _i: &'ast AngleBracketedGenericArguments,
@@ -917,7 +863,6 @@ pub fn visit_arg_self_ref<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &
     };
     tokens_helper(_visitor, &_i.self_token.span);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn visit_arm<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Arm) {
     for it in &_i.attrs {
@@ -940,7 +885,7 @@ pub fn visit_arm<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Arm)
         tokens_helper(_visitor, &it.spans)
     };
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_attr_style<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast AttrStyle) {
     match *_i {
         AttrStyle::Outer => {}
@@ -949,7 +894,7 @@ pub fn visit_attr_style<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'a
         }
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_attribute<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Attribute) {
     tokens_helper(_visitor, &_i.pound_token.spans);
     _visitor.visit_attr_style(&_i.style);
@@ -957,7 +902,7 @@ pub fn visit_attribute<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'as
     _visitor.visit_path(&_i.path);
     skip!(_i.tts);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_bare_fn_arg<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast BareFnArg) {
     if let Some(ref it) = _i.name {
         _visitor.visit_bare_fn_arg_name(&(it).0);
@@ -965,7 +910,7 @@ pub fn visit_bare_fn_arg<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'
     };
     _visitor.visit_type(&_i.ty);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_bare_fn_arg_name<'ast, V: Visit<'ast> + ?Sized>(
     _visitor: &mut V,
     _i: &'ast BareFnArgName,
@@ -979,7 +924,7 @@ pub fn visit_bare_fn_arg_name<'ast, V: Visit<'ast> + ?Sized>(
         }
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_bin_op<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast BinOp) {
     match *_i {
         BinOp::Add(ref _binding_0) => {
@@ -1068,13 +1013,12 @@ pub fn visit_bin_op<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast B
         }
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_binding<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Binding) {
     _visitor.visit_ident(&_i.ident);
     tokens_helper(_visitor, &_i.eq_token.spans);
     _visitor.visit_type(&_i.ty);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn visit_block<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Block) {
     tokens_helper(_visitor, &_i.brace_token.span);
@@ -1082,7 +1026,7 @@ pub fn visit_block<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Bl
         _visitor.visit_stmt(it)
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_bound_lifetimes<'ast, V: Visit<'ast> + ?Sized>(
     _visitor: &mut V,
     _i: &'ast BoundLifetimes,
@@ -1095,7 +1039,7 @@ pub fn visit_bound_lifetimes<'ast, V: Visit<'ast> + ?Sized>(
     }
     tokens_helper(_visitor, &_i.gt_token.spans);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_const_param<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ConstParam) {
     for it in &_i.attrs {
         _visitor.visit_attribute(it)
@@ -1111,7 +1055,7 @@ pub fn visit_const_param<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'
         _visitor.visit_expr(it)
     };
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_constraint<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Constraint) {
     _visitor.visit_ident(&_i.ident);
     tokens_helper(_visitor, &_i.colon_token.spans);
@@ -1166,7 +1110,7 @@ pub fn visit_derive_input<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &
     _visitor.visit_generics(&_i.generics);
     _visitor.visit_data(&_i.data);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_expr<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Expr) {
     match *_i {
         Expr::Box(ref _binding_0) => {
@@ -1292,7 +1236,6 @@ pub fn visit_expr<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Exp
     }
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_expr_array<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprArray) {
     for it in &_i.attrs {
         _visitor.visit_attribute(it)
@@ -1304,7 +1247,6 @@ pub fn visit_expr_array<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'a
     }
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_expr_assign<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprAssign) {
     for it in &_i.attrs {
         _visitor.visit_attribute(it)
@@ -1314,7 +1256,6 @@ pub fn visit_expr_assign<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'
     _visitor.visit_expr(&*_i.right);
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_expr_assign_op<'ast, V: Visit<'ast> + ?Sized>(
     _visitor: &mut V,
     _i: &'ast ExprAssignOp,
@@ -1327,7 +1268,6 @@ pub fn visit_expr_assign_op<'ast, V: Visit<'ast> + ?Sized>(
     _visitor.visit_expr(&*_i.right);
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_expr_async<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprAsync) {
     for it in &_i.attrs {
         _visitor.visit_attribute(it)
@@ -1338,7 +1278,7 @@ pub fn visit_expr_async<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'a
     };
     _visitor.visit_block(&_i.block);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_expr_binary<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprBinary) {
     for it in &_i.attrs {
         _visitor.visit_attribute(it)
@@ -1348,7 +1288,6 @@ pub fn visit_expr_binary<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'
     _visitor.visit_expr(&*_i.right);
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_expr_block<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprBlock) {
     for it in &_i.attrs {
         _visitor.visit_attribute(it)
@@ -1359,7 +1298,6 @@ pub fn visit_expr_block<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'a
     _visitor.visit_block(&_i.block);
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_expr_box<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprBox) {
     for it in &_i.attrs {
         _visitor.visit_attribute(it)
@@ -1368,7 +1306,6 @@ pub fn visit_expr_box<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast
     _visitor.visit_expr(&*_i.expr);
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_expr_break<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprBreak) {
     for it in &_i.attrs {
         _visitor.visit_attribute(it)
@@ -1381,7 +1318,7 @@ pub fn visit_expr_break<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'a
         _visitor.visit_expr(&**it)
     };
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_expr_call<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprCall) {
     for it in &_i.attrs {
         _visitor.visit_attribute(it)
@@ -1393,7 +1330,7 @@ pub fn visit_expr_call<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'as
         _visitor.visit_expr(it)
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_expr_cast<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprCast) {
     for it in &_i.attrs {
         _visitor.visit_attribute(it)
@@ -1403,7 +1340,6 @@ pub fn visit_expr_cast<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'as
     _visitor.visit_type(&*_i.ty);
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_expr_closure<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprClosure) {
     for it in &_i.attrs {
         _visitor.visit_attribute(it)
@@ -1427,7 +1363,6 @@ pub fn visit_expr_closure<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &
     _visitor.visit_expr(&*_i.body);
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_expr_continue<'ast, V: Visit<'ast> + ?Sized>(
     _visitor: &mut V,
     _i: &'ast ExprContinue,
@@ -1440,7 +1375,7 @@ pub fn visit_expr_continue<'ast, V: Visit<'ast> + ?Sized>(
         _visitor.visit_lifetime(it)
     };
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_expr_field<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprField) {
     for it in &_i.attrs {
         _visitor.visit_attribute(it)
@@ -1450,7 +1385,6 @@ pub fn visit_expr_field<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'a
     _visitor.visit_member(&_i.member);
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_expr_for_loop<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprForLoop) {
     for it in &_i.attrs {
         _visitor.visit_attribute(it)
@@ -1465,7 +1399,6 @@ pub fn visit_expr_for_loop<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i:
     _visitor.visit_block(&_i.body);
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_expr_group<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprGroup) {
     for it in &_i.attrs {
         _visitor.visit_attribute(it)
@@ -1474,7 +1407,6 @@ pub fn visit_expr_group<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'a
     _visitor.visit_expr(&*_i.expr);
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_expr_if<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprIf) {
     for it in &_i.attrs {
         _visitor.visit_attribute(it)
@@ -1488,7 +1420,6 @@ pub fn visit_expr_if<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast
     };
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_expr_in_place<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprInPlace) {
     for it in &_i.attrs {
         _visitor.visit_attribute(it)
@@ -1497,7 +1428,7 @@ pub fn visit_expr_in_place<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i:
     tokens_helper(_visitor, &_i.arrow_token.spans);
     _visitor.visit_expr(&*_i.value);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_expr_index<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprIndex) {
     for it in &_i.attrs {
         _visitor.visit_attribute(it)
@@ -1507,7 +1438,6 @@ pub fn visit_expr_index<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'a
     _visitor.visit_expr(&*_i.index);
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_expr_let<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprLet) {
     for it in &_i.attrs {
         _visitor.visit_attribute(it)
@@ -1520,7 +1450,7 @@ pub fn visit_expr_let<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast
     tokens_helper(_visitor, &_i.eq_token.spans);
     _visitor.visit_expr(&*_i.expr);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_expr_lit<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprLit) {
     for it in &_i.attrs {
         _visitor.visit_attribute(it)
@@ -1528,7 +1458,6 @@ pub fn visit_expr_lit<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast
     _visitor.visit_lit(&_i.lit);
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_expr_loop<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprLoop) {
     for it in &_i.attrs {
         _visitor.visit_attribute(it)
@@ -1540,7 +1469,6 @@ pub fn visit_expr_loop<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'as
     _visitor.visit_block(&_i.body);
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_expr_macro<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprMacro) {
     for it in &_i.attrs {
         _visitor.visit_attribute(it)
@@ -1548,7 +1476,6 @@ pub fn visit_expr_macro<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'a
     _visitor.visit_macro(&_i.mac);
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_expr_match<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprMatch) {
     for it in &_i.attrs {
         _visitor.visit_attribute(it)
@@ -1561,7 +1488,6 @@ pub fn visit_expr_match<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'a
     }
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_expr_method_call<'ast, V: Visit<'ast> + ?Sized>(
     _visitor: &mut V,
     _i: &'ast ExprMethodCall,
@@ -1581,7 +1507,7 @@ pub fn visit_expr_method_call<'ast, V: Visit<'ast> + ?Sized>(
         _visitor.visit_expr(it)
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_expr_paren<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprParen) {
     for it in &_i.attrs {
         _visitor.visit_attribute(it)
@@ -1589,7 +1515,7 @@ pub fn visit_expr_paren<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'a
     tokens_helper(_visitor, &_i.paren_token.span);
     _visitor.visit_expr(&*_i.expr);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_expr_path<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprPath) {
     for it in &_i.attrs {
         _visitor.visit_attribute(it)
@@ -1600,7 +1526,6 @@ pub fn visit_expr_path<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'as
     _visitor.visit_path(&_i.path);
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_expr_range<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprRange) {
     for it in &_i.attrs {
         _visitor.visit_attribute(it)
@@ -1614,7 +1539,6 @@ pub fn visit_expr_range<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'a
     };
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_expr_reference<'ast, V: Visit<'ast> + ?Sized>(
     _visitor: &mut V,
     _i: &'ast ExprReference,
@@ -1629,7 +1553,6 @@ pub fn visit_expr_reference<'ast, V: Visit<'ast> + ?Sized>(
     _visitor.visit_expr(&*_i.expr);
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_expr_repeat<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprRepeat) {
     for it in &_i.attrs {
         _visitor.visit_attribute(it)
@@ -1640,7 +1563,6 @@ pub fn visit_expr_repeat<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'
     _visitor.visit_expr(&*_i.len);
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_expr_return<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprReturn) {
     for it in &_i.attrs {
         _visitor.visit_attribute(it)
@@ -1651,7 +1573,6 @@ pub fn visit_expr_return<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'
     };
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_expr_struct<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprStruct) {
     for it in &_i.attrs {
         _visitor.visit_attribute(it)
@@ -1670,7 +1591,6 @@ pub fn visit_expr_struct<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'
     };
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_expr_try<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprTry) {
     for it in &_i.attrs {
         _visitor.visit_attribute(it)
@@ -1679,7 +1599,6 @@ pub fn visit_expr_try<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast
     tokens_helper(_visitor, &_i.question_token.spans);
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_expr_try_block<'ast, V: Visit<'ast> + ?Sized>(
     _visitor: &mut V,
     _i: &'ast ExprTryBlock,
@@ -1691,7 +1610,6 @@ pub fn visit_expr_try_block<'ast, V: Visit<'ast> + ?Sized>(
     _visitor.visit_block(&_i.block);
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_expr_tuple<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprTuple) {
     for it in &_i.attrs {
         _visitor.visit_attribute(it)
@@ -1703,7 +1621,6 @@ pub fn visit_expr_tuple<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'a
     }
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_expr_type<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprType) {
     for it in &_i.attrs {
         _visitor.visit_attribute(it)
@@ -1712,7 +1629,7 @@ pub fn visit_expr_type<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'as
     tokens_helper(_visitor, &_i.colon_token.spans);
     _visitor.visit_type(&*_i.ty);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_expr_unary<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprUnary) {
     for it in &_i.attrs {
         _visitor.visit_attribute(it)
@@ -1721,7 +1638,6 @@ pub fn visit_expr_unary<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'a
     _visitor.visit_expr(&*_i.expr);
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_expr_unsafe<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprUnsafe) {
     for it in &_i.attrs {
         _visitor.visit_attribute(it)
@@ -1729,7 +1645,7 @@ pub fn visit_expr_unsafe<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'
     tokens_helper(_visitor, &_i.unsafe_token.span);
     _visitor.visit_block(&_i.block);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_expr_verbatim<'ast, V: Visit<'ast> + ?Sized>(
     _visitor: &mut V,
     _i: &'ast ExprVerbatim,
@@ -1737,7 +1653,6 @@ pub fn visit_expr_verbatim<'ast, V: Visit<'ast> + ?Sized>(
     skip!(_i.tts);
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_expr_while<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprWhile) {
     for it in &_i.attrs {
         _visitor.visit_attribute(it)
@@ -1750,7 +1665,6 @@ pub fn visit_expr_while<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'a
     _visitor.visit_block(&_i.body);
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_expr_yield<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprYield) {
     for it in &_i.attrs {
         _visitor.visit_attribute(it)
@@ -1760,7 +1674,7 @@ pub fn visit_expr_yield<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'a
         _visitor.visit_expr(&**it)
     };
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_field<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Field) {
     for it in &_i.attrs {
         _visitor.visit_attribute(it)
@@ -1774,7 +1688,6 @@ pub fn visit_field<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Fi
     };
     _visitor.visit_type(&_i.ty);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn visit_field_pat<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast FieldPat) {
     for it in &_i.attrs {
@@ -1786,7 +1699,6 @@ pub fn visit_field_pat<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'as
     };
     _visitor.visit_pat(&*_i.pat);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn visit_field_value<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast FieldValue) {
     for it in &_i.attrs {
@@ -1798,7 +1710,7 @@ pub fn visit_field_value<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'
     };
     _visitor.visit_expr(&_i.expr);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_fields<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Fields) {
     match *_i {
         Fields::Named(ref _binding_0) => {
@@ -1810,7 +1722,7 @@ pub fn visit_fields<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast F
         Fields::Unit => {}
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_fields_named<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast FieldsNamed) {
     tokens_helper(_visitor, &_i.brace_token.span);
     for el in Punctuated::pairs(&_i.named) {
@@ -1818,7 +1730,7 @@ pub fn visit_fields_named<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &
         _visitor.visit_field(it)
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_fields_unnamed<'ast, V: Visit<'ast> + ?Sized>(
     _visitor: &mut V,
     _i: &'ast FieldsUnnamed,
@@ -1957,7 +1869,7 @@ pub fn visit_foreign_item_verbatim<'ast, V: Visit<'ast> + ?Sized>(
 ) {
     skip!(_i.tts);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_generic_argument<'ast, V: Visit<'ast> + ?Sized>(
     _visitor: &mut V,
     _i: &'ast GenericArgument,
@@ -1980,7 +1892,6 @@ pub fn visit_generic_argument<'ast, V: Visit<'ast> + ?Sized>(
         }
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn visit_generic_method_argument<'ast, V: Visit<'ast> + ?Sized>(
     _visitor: &mut V,
@@ -1995,7 +1906,7 @@ pub fn visit_generic_method_argument<'ast, V: Visit<'ast> + ?Sized>(
         }
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_generic_param<'ast, V: Visit<'ast> + ?Sized>(
     _visitor: &mut V,
     _i: &'ast GenericParam,
@@ -2012,7 +1923,7 @@ pub fn visit_generic_param<'ast, V: Visit<'ast> + ?Sized>(
         }
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_generics<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Generics) {
     if let Some(ref it) = _i.lt_token {
         tokens_helper(_visitor, &it.spans)
@@ -2028,7 +1939,6 @@ pub fn visit_generics<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast
         _visitor.visit_where_clause(it)
     };
 }
-pub fn visit_ident<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Ident) {}
 #[cfg(feature = "full")]
 pub fn visit_impl_item<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ImplItem) {
     match *_i {
@@ -2147,7 +2057,7 @@ pub fn visit_impl_item_verbatim<'ast, V: Visit<'ast> + ?Sized>(
 ) {
     skip!(_i.tts);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_index<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Index) {
     skip!(_i.index);
     _visitor.visit_span(&_i.span);
@@ -2507,7 +2417,6 @@ pub fn visit_item_verbatim<'ast, V: Visit<'ast> + ?Sized>(
 ) {
     skip!(_i.tts);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn visit_label<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Label) {
     _visitor.visit_lifetime(&_i.name);
@@ -2517,7 +2426,7 @@ pub fn visit_lifetime<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast
     _visitor.visit_span(&_i.apostrophe);
     _visitor.visit_ident(&_i.ident);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_lifetime_def<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast LifetimeDef) {
     for it in &_i.attrs {
         _visitor.visit_attribute(it)
@@ -2531,7 +2440,7 @@ pub fn visit_lifetime_def<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &
         _visitor.visit_lifetime(it)
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_lit<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Lit) {
     match *_i {
         Lit::Str(ref _binding_0) => {
@@ -2560,40 +2469,27 @@ pub fn visit_lit<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Lit)
         }
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_lit_bool<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast LitBool) {
     skip!(_i.value);
     _visitor.visit_span(&_i.span);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
-pub fn visit_lit_byte<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast LitByte) {
-    skip!(_i.token);
-}
-#[cfg(any(feature = "full", feature = "derive"))]
-pub fn visit_lit_byte_str<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast LitByteStr) {
-    skip!(_i.token);
-}
-#[cfg(any(feature = "full", feature = "derive"))]
-pub fn visit_lit_char<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast LitChar) {
-    skip!(_i.token);
-}
-#[cfg(any(feature = "full", feature = "derive"))]
-pub fn visit_lit_float<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast LitFloat) {
-    skip!(_i.token);
-}
-#[cfg(any(feature = "full", feature = "derive"))]
-pub fn visit_lit_int<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast LitInt) {
-    skip!(_i.token);
-}
-#[cfg(any(feature = "full", feature = "derive"))]
-pub fn visit_lit_str<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast LitStr) {
-    skip!(_i.token);
-}
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
+pub fn visit_lit_byte<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast LitByte) {}
+#[cfg(any(feature = "derive", feature = "full"))]
+pub fn visit_lit_byte_str<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast LitByteStr) {}
+#[cfg(any(feature = "derive", feature = "full"))]
+pub fn visit_lit_char<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast LitChar) {}
+#[cfg(any(feature = "derive", feature = "full"))]
+pub fn visit_lit_float<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast LitFloat) {}
+#[cfg(any(feature = "derive", feature = "full"))]
+pub fn visit_lit_int<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast LitInt) {}
+#[cfg(any(feature = "derive", feature = "full"))]
+pub fn visit_lit_str<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast LitStr) {}
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_lit_verbatim<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast LitVerbatim) {
     skip!(_i.token);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn visit_local<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Local) {
     for it in &_i.attrs {
@@ -2614,14 +2510,14 @@ pub fn visit_local<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Lo
     };
     tokens_helper(_visitor, &_i.semi_token.spans);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_macro<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Macro) {
     _visitor.visit_path(&_i.path);
     tokens_helper(_visitor, &_i.bang_token.spans);
     _visitor.visit_macro_delimiter(&_i.delimiter);
     skip!(_i.tts);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_macro_delimiter<'ast, V: Visit<'ast> + ?Sized>(
     _visitor: &mut V,
     _i: &'ast MacroDelimiter,
@@ -2638,7 +2534,7 @@ pub fn visit_macro_delimiter<'ast, V: Visit<'ast> + ?Sized>(
         }
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_member<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Member) {
     match *_i {
         Member::Named(ref _binding_0) => {
@@ -2649,7 +2545,7 @@ pub fn visit_member<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast M
         }
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_meta<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Meta) {
     match *_i {
         Meta::Word(ref _binding_0) => {
@@ -2663,7 +2559,7 @@ pub fn visit_meta<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Met
         }
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_meta_list<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast MetaList) {
     _visitor.visit_ident(&_i.ident);
     tokens_helper(_visitor, &_i.paren_token.span);
@@ -2672,7 +2568,7 @@ pub fn visit_meta_list<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'as
         _visitor.visit_nested_meta(it)
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_meta_name_value<'ast, V: Visit<'ast> + ?Sized>(
     _visitor: &mut V,
     _i: &'ast MetaNameValue,
@@ -2698,7 +2594,6 @@ pub fn visit_method_sig<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'a
     _visitor.visit_ident(&_i.ident);
     _visitor.visit_fn_decl(&_i.decl);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn visit_method_turbofish<'ast, V: Visit<'ast> + ?Sized>(
     _visitor: &mut V,
@@ -2712,7 +2607,7 @@ pub fn visit_method_turbofish<'ast, V: Visit<'ast> + ?Sized>(
     }
     tokens_helper(_visitor, &_i.gt_token.spans);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_nested_meta<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast NestedMeta) {
     match *_i {
         NestedMeta::Meta(ref _binding_0) => {
@@ -2723,7 +2618,7 @@ pub fn visit_nested_meta<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'
         }
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_parenthesized_generic_arguments<'ast, V: Visit<'ast> + ?Sized>(
     _visitor: &mut V,
     _i: &'ast ParenthesizedGenericArguments,
@@ -2735,7 +2630,6 @@ pub fn visit_parenthesized_generic_arguments<'ast, V: Visit<'ast> + ?Sized>(
     }
     _visitor.visit_return_type(&_i.output);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn visit_pat<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Pat) {
     match *_i {
@@ -2780,13 +2674,11 @@ pub fn visit_pat<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Pat)
         }
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn visit_pat_box<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PatBox) {
     tokens_helper(_visitor, &_i.box_token.span);
     _visitor.visit_pat(&*_i.pat);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn visit_pat_ident<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PatIdent) {
     if let Some(ref it) = _i.by_ref {
@@ -2801,17 +2693,14 @@ pub fn visit_pat_ident<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'as
         _visitor.visit_pat(&*(it).1);
     };
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn visit_pat_lit<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PatLit) {
     _visitor.visit_expr(&*_i.expr);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn visit_pat_macro<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PatMacro) {
     _visitor.visit_macro(&_i.mac);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn visit_pat_path<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PatPath) {
     if let Some(ref it) = _i.qself {
@@ -2819,14 +2708,12 @@ pub fn visit_pat_path<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast
     };
     _visitor.visit_path(&_i.path);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn visit_pat_range<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PatRange) {
     _visitor.visit_expr(&*_i.lo);
     _visitor.visit_range_limits(&_i.limits);
     _visitor.visit_expr(&*_i.hi);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn visit_pat_ref<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PatRef) {
     tokens_helper(_visitor, &_i.and_token.spans);
@@ -2835,7 +2722,6 @@ pub fn visit_pat_ref<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast
     };
     _visitor.visit_pat(&*_i.pat);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn visit_pat_slice<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PatSlice) {
     tokens_helper(_visitor, &_i.bracket_token.span);
@@ -2857,7 +2743,6 @@ pub fn visit_pat_slice<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'as
         _visitor.visit_pat(it)
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn visit_pat_struct<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PatStruct) {
     _visitor.visit_path(&_i.path);
@@ -2870,7 +2755,6 @@ pub fn visit_pat_struct<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'a
         tokens_helper(_visitor, &it.spans)
     };
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn visit_pat_tuple<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PatTuple) {
     tokens_helper(_visitor, &_i.paren_token.span);
@@ -2889,7 +2773,6 @@ pub fn visit_pat_tuple<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'as
         _visitor.visit_pat(it)
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn visit_pat_tuple_struct<'ast, V: Visit<'ast> + ?Sized>(
     _visitor: &mut V,
@@ -2898,17 +2781,15 @@ pub fn visit_pat_tuple_struct<'ast, V: Visit<'ast> + ?Sized>(
     _visitor.visit_path(&_i.path);
     _visitor.visit_pat_tuple(&_i.pat);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn visit_pat_verbatim<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PatVerbatim) {
     skip!(_i.tts);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn visit_pat_wild<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PatWild) {
     tokens_helper(_visitor, &_i.underscore_token.spans);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_path<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Path) {
     if let Some(ref it) = _i.leading_colon {
         tokens_helper(_visitor, &it.spans)
@@ -2918,7 +2799,7 @@ pub fn visit_path<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Pat
         _visitor.visit_path_segment(it)
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_path_arguments<'ast, V: Visit<'ast> + ?Sized>(
     _visitor: &mut V,
     _i: &'ast PathArguments,
@@ -2933,18 +2814,18 @@ pub fn visit_path_arguments<'ast, V: Visit<'ast> + ?Sized>(
         }
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_path_segment<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PathSegment) {
     _visitor.visit_ident(&_i.ident);
     _visitor.visit_path_arguments(&_i.arguments);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_predicate_eq<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PredicateEq) {
     _visitor.visit_type(&_i.lhs_ty);
     tokens_helper(_visitor, &_i.eq_token.spans);
     _visitor.visit_type(&_i.rhs_ty);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_predicate_lifetime<'ast, V: Visit<'ast> + ?Sized>(
     _visitor: &mut V,
     _i: &'ast PredicateLifetime,
@@ -2956,7 +2837,7 @@ pub fn visit_predicate_lifetime<'ast, V: Visit<'ast> + ?Sized>(
         _visitor.visit_lifetime(it)
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_predicate_type<'ast, V: Visit<'ast> + ?Sized>(
     _visitor: &mut V,
     _i: &'ast PredicateType,
@@ -2971,7 +2852,7 @@ pub fn visit_predicate_type<'ast, V: Visit<'ast> + ?Sized>(
         _visitor.visit_type_param_bound(it)
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_qself<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast QSelf) {
     tokens_helper(_visitor, &_i.lt_token.spans);
     _visitor.visit_type(&*_i.ty);
@@ -2981,7 +2862,6 @@ pub fn visit_qself<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast QS
     };
     tokens_helper(_visitor, &_i.gt_token.spans);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn visit_range_limits<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast RangeLimits) {
     match *_i {
@@ -2993,7 +2873,7 @@ pub fn visit_range_limits<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &
         }
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_return_type<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ReturnType) {
     match *_i {
         ReturnType::Default => {}
@@ -3003,8 +2883,6 @@ pub fn visit_return_type<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'
         }
     }
 }
-pub fn visit_span<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Span) {}
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn visit_stmt<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Stmt) {
     match *_i {
@@ -3023,7 +2901,7 @@ pub fn visit_stmt<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Stm
         }
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_trait_bound<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast TraitBound) {
     if let Some(ref it) = _i.paren_token {
         tokens_helper(_visitor, &it.span)
@@ -3034,7 +2912,7 @@ pub fn visit_trait_bound<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'
     };
     _visitor.visit_path(&_i.path);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_trait_bound_modifier<'ast, V: Visit<'ast> + ?Sized>(
     _visitor: &mut V,
     _i: &'ast TraitBoundModifier,
@@ -3144,7 +3022,7 @@ pub fn visit_trait_item_verbatim<'ast, V: Visit<'ast> + ?Sized>(
 ) {
     skip!(_i.tts);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_type<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Type) {
     match *_i {
         Type::Slice(ref _binding_0) => {
@@ -3194,14 +3072,14 @@ pub fn visit_type<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Typ
         }
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_type_array<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast TypeArray) {
     tokens_helper(_visitor, &_i.bracket_token.span);
     _visitor.visit_type(&*_i.elem);
     tokens_helper(_visitor, &_i.semi_token.spans);
     _visitor.visit_expr(&_i.len);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_type_bare_fn<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast TypeBareFn) {
     if let Some(ref it) = _i.lifetimes {
         _visitor.visit_bound_lifetimes(it)
@@ -3223,12 +3101,12 @@ pub fn visit_type_bare_fn<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &
     };
     _visitor.visit_return_type(&_i.output);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_type_group<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast TypeGroup) {
     tokens_helper(_visitor, &_i.group_token.span);
     _visitor.visit_type(&*_i.elem);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_type_impl_trait<'ast, V: Visit<'ast> + ?Sized>(
     _visitor: &mut V,
     _i: &'ast TypeImplTrait,
@@ -3239,19 +3117,19 @@ pub fn visit_type_impl_trait<'ast, V: Visit<'ast> + ?Sized>(
         _visitor.visit_type_param_bound(it)
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_type_infer<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast TypeInfer) {
     tokens_helper(_visitor, &_i.underscore_token.spans);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_type_macro<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast TypeMacro) {
     _visitor.visit_macro(&_i.mac);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_type_never<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast TypeNever) {
     tokens_helper(_visitor, &_i.bang_token.spans);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_type_param<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast TypeParam) {
     for it in &_i.attrs {
         _visitor.visit_attribute(it)
@@ -3271,7 +3149,7 @@ pub fn visit_type_param<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'a
         _visitor.visit_type(it)
     };
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_type_param_bound<'ast, V: Visit<'ast> + ?Sized>(
     _visitor: &mut V,
     _i: &'ast TypeParamBound,
@@ -3285,19 +3163,19 @@ pub fn visit_type_param_bound<'ast, V: Visit<'ast> + ?Sized>(
         }
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_type_paren<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast TypeParen) {
     tokens_helper(_visitor, &_i.paren_token.span);
     _visitor.visit_type(&*_i.elem);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_type_path<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast TypePath) {
     if let Some(ref it) = _i.qself {
         _visitor.visit_qself(it)
     };
     _visitor.visit_path(&_i.path);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_type_ptr<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast TypePtr) {
     tokens_helper(_visitor, &_i.star_token.spans);
     if let Some(ref it) = _i.const_token {
@@ -3308,7 +3186,7 @@ pub fn visit_type_ptr<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast
     };
     _visitor.visit_type(&*_i.elem);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_type_reference<'ast, V: Visit<'ast> + ?Sized>(
     _visitor: &mut V,
     _i: &'ast TypeReference,
@@ -3322,12 +3200,12 @@ pub fn visit_type_reference<'ast, V: Visit<'ast> + ?Sized>(
     };
     _visitor.visit_type(&*_i.elem);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_type_slice<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast TypeSlice) {
     tokens_helper(_visitor, &_i.bracket_token.span);
     _visitor.visit_type(&*_i.elem);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_type_trait_object<'ast, V: Visit<'ast> + ?Sized>(
     _visitor: &mut V,
     _i: &'ast TypeTraitObject,
@@ -3340,7 +3218,7 @@ pub fn visit_type_trait_object<'ast, V: Visit<'ast> + ?Sized>(
         _visitor.visit_type_param_bound(it)
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_type_tuple<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast TypeTuple) {
     tokens_helper(_visitor, &_i.paren_token.span);
     for el in Punctuated::pairs(&_i.elems) {
@@ -3348,14 +3226,14 @@ pub fn visit_type_tuple<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'a
         _visitor.visit_type(it)
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_type_verbatim<'ast, V: Visit<'ast> + ?Sized>(
     _visitor: &mut V,
     _i: &'ast TypeVerbatim,
 ) {
     skip!(_i.tts);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_un_op<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast UnOp) {
     match *_i {
         UnOp::Deref(ref _binding_0) => {
@@ -3417,7 +3295,7 @@ pub fn visit_use_tree<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast
         }
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_variant<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Variant) {
     for it in &_i.attrs {
         _visitor.visit_attribute(it)
@@ -3429,15 +3307,15 @@ pub fn visit_variant<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast
         _visitor.visit_expr(&(it).1);
     };
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_vis_crate<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast VisCrate) {
     tokens_helper(_visitor, &_i.crate_token.span);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_vis_public<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast VisPublic) {
     tokens_helper(_visitor, &_i.pub_token.span);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_vis_restricted<'ast, V: Visit<'ast> + ?Sized>(
     _visitor: &mut V,
     _i: &'ast VisRestricted,
@@ -3449,7 +3327,7 @@ pub fn visit_vis_restricted<'ast, V: Visit<'ast> + ?Sized>(
     };
     _visitor.visit_path(&*_i.path);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_visibility<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Visibility) {
     match *_i {
         Visibility::Public(ref _binding_0) => {
@@ -3464,7 +3342,7 @@ pub fn visit_visibility<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'a
         Visibility::Inherited => {}
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_where_clause<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast WhereClause) {
     tokens_helper(_visitor, &_i.where_token.span);
     for el in Punctuated::pairs(&_i.predicates) {
@@ -3472,7 +3350,7 @@ pub fn visit_where_clause<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &
         _visitor.visit_where_predicate(it)
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_where_predicate<'ast, V: Visit<'ast> + ?Sized>(
     _visitor: &mut V,
     _i: &'ast WherePredicate,
@@ -3489,3 +3367,5 @@ pub fn visit_where_predicate<'ast, V: Visit<'ast> + ?Sized>(
         }
     }
 }
+pub fn visit_span<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Span) {}
+pub fn visit_ident<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Ident) {}
diff --git a/third_party/rust/syn/src/gen/visit_mut.rs b/third_party/rust/syn/src/gen/visit_mut.rs
index ce875f5c8e34..399609ec5d4f 100644
--- a/third_party/rust/syn/src/gen/visit_mut.rs
+++ b/third_party/rust/syn/src/gen/visit_mut.rs
@@ -22,20 +22,20 @@ macro_rules! full {
 macro_rules! skip {
     ($($tt:tt)*) => {};
 }
-#[doc = r" Syntax tree traversal to mutate an exclusive borrow of a syntax tree in"]
-#[doc = r" place."]
-#[doc = r""]
-#[doc = r" See the [module documentation] for details."]
-#[doc = r""]
-#[doc = r" [module documentation]: index.html"]
-#[doc = r""]
-#[doc = r#" *This trait is available if Syn is built with the `"visit-mut"` feature.*"#]
+/// Syntax tree traversal to mutate an exclusive borrow of a syntax tree in
+/// place.
+///
+/// See the [module documentation] for details.
+///
+/// [module documentation]: index.html
+///
+/// *This trait is available if Syn is built with the `"visit-mut"` feature.*
 pub trait VisitMut {
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_abi_mut(&mut self, i: &mut Abi) {
         visit_abi_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_angle_bracketed_generic_arguments_mut(
         &mut self,
         i: &mut AngleBracketedGenericArguments,
@@ -54,49 +54,47 @@ pub trait VisitMut {
     fn visit_arg_self_ref_mut(&mut self, i: &mut ArgSelfRef) {
         visit_arg_self_ref_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn visit_arm_mut(&mut self, i: &mut Arm) {
         visit_arm_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_attr_style_mut(&mut self, i: &mut AttrStyle) {
         visit_attr_style_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_attribute_mut(&mut self, i: &mut Attribute) {
         visit_attribute_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_bare_fn_arg_mut(&mut self, i: &mut BareFnArg) {
         visit_bare_fn_arg_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_bare_fn_arg_name_mut(&mut self, i: &mut BareFnArgName) {
         visit_bare_fn_arg_name_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_bin_op_mut(&mut self, i: &mut BinOp) {
         visit_bin_op_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_binding_mut(&mut self, i: &mut Binding) {
         visit_binding_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn visit_block_mut(&mut self, i: &mut Block) {
         visit_block_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_bound_lifetimes_mut(&mut self, i: &mut BoundLifetimes) {
         visit_bound_lifetimes_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_const_param_mut(&mut self, i: &mut ConstParam) {
         visit_const_param_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_constraint_mut(&mut self, i: &mut Constraint) {
         visit_constraint_mut(self, i)
     }
@@ -120,223 +118,191 @@ pub trait VisitMut {
     fn visit_derive_input_mut(&mut self, i: &mut DeriveInput) {
         visit_derive_input_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_expr_mut(&mut self, i: &mut Expr) {
         visit_expr_mut(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn visit_expr_array_mut(&mut self, i: &mut ExprArray) {
         visit_expr_array_mut(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn visit_expr_assign_mut(&mut self, i: &mut ExprAssign) {
         visit_expr_assign_mut(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn visit_expr_assign_op_mut(&mut self, i: &mut ExprAssignOp) {
         visit_expr_assign_op_mut(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn visit_expr_async_mut(&mut self, i: &mut ExprAsync) {
         visit_expr_async_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_expr_binary_mut(&mut self, i: &mut ExprBinary) {
         visit_expr_binary_mut(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn visit_expr_block_mut(&mut self, i: &mut ExprBlock) {
         visit_expr_block_mut(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn visit_expr_box_mut(&mut self, i: &mut ExprBox) {
         visit_expr_box_mut(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn visit_expr_break_mut(&mut self, i: &mut ExprBreak) {
         visit_expr_break_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_expr_call_mut(&mut self, i: &mut ExprCall) {
         visit_expr_call_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_expr_cast_mut(&mut self, i: &mut ExprCast) {
         visit_expr_cast_mut(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn visit_expr_closure_mut(&mut self, i: &mut ExprClosure) {
         visit_expr_closure_mut(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn visit_expr_continue_mut(&mut self, i: &mut ExprContinue) {
         visit_expr_continue_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_expr_field_mut(&mut self, i: &mut ExprField) {
         visit_expr_field_mut(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn visit_expr_for_loop_mut(&mut self, i: &mut ExprForLoop) {
         visit_expr_for_loop_mut(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn visit_expr_group_mut(&mut self, i: &mut ExprGroup) {
         visit_expr_group_mut(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn visit_expr_if_mut(&mut self, i: &mut ExprIf) {
         visit_expr_if_mut(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn visit_expr_in_place_mut(&mut self, i: &mut ExprInPlace) {
         visit_expr_in_place_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_expr_index_mut(&mut self, i: &mut ExprIndex) {
         visit_expr_index_mut(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn visit_expr_let_mut(&mut self, i: &mut ExprLet) {
         visit_expr_let_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_expr_lit_mut(&mut self, i: &mut ExprLit) {
         visit_expr_lit_mut(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn visit_expr_loop_mut(&mut self, i: &mut ExprLoop) {
         visit_expr_loop_mut(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn visit_expr_macro_mut(&mut self, i: &mut ExprMacro) {
         visit_expr_macro_mut(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn visit_expr_match_mut(&mut self, i: &mut ExprMatch) {
         visit_expr_match_mut(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn visit_expr_method_call_mut(&mut self, i: &mut ExprMethodCall) {
         visit_expr_method_call_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_expr_paren_mut(&mut self, i: &mut ExprParen) {
         visit_expr_paren_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_expr_path_mut(&mut self, i: &mut ExprPath) {
         visit_expr_path_mut(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn visit_expr_range_mut(&mut self, i: &mut ExprRange) {
         visit_expr_range_mut(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn visit_expr_reference_mut(&mut self, i: &mut ExprReference) {
         visit_expr_reference_mut(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn visit_expr_repeat_mut(&mut self, i: &mut ExprRepeat) {
         visit_expr_repeat_mut(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn visit_expr_return_mut(&mut self, i: &mut ExprReturn) {
         visit_expr_return_mut(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn visit_expr_struct_mut(&mut self, i: &mut ExprStruct) {
         visit_expr_struct_mut(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn visit_expr_try_mut(&mut self, i: &mut ExprTry) {
         visit_expr_try_mut(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn visit_expr_try_block_mut(&mut self, i: &mut ExprTryBlock) {
         visit_expr_try_block_mut(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn visit_expr_tuple_mut(&mut self, i: &mut ExprTuple) {
         visit_expr_tuple_mut(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn visit_expr_type_mut(&mut self, i: &mut ExprType) {
         visit_expr_type_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_expr_unary_mut(&mut self, i: &mut ExprUnary) {
         visit_expr_unary_mut(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn visit_expr_unsafe_mut(&mut self, i: &mut ExprUnsafe) {
         visit_expr_unsafe_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_expr_verbatim_mut(&mut self, i: &mut ExprVerbatim) {
         visit_expr_verbatim_mut(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn visit_expr_while_mut(&mut self, i: &mut ExprWhile) {
         visit_expr_while_mut(self, i)
     }
     #[cfg(feature = "full")]
-    #[cfg(any(feature = "full", feature = "derive"))]
     fn visit_expr_yield_mut(&mut self, i: &mut ExprYield) {
         visit_expr_yield_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_field_mut(&mut self, i: &mut Field) {
         visit_field_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn visit_field_pat_mut(&mut self, i: &mut FieldPat) {
         visit_field_pat_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn visit_field_value_mut(&mut self, i: &mut FieldValue) {
         visit_field_value_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_fields_mut(&mut self, i: &mut Fields) {
         visit_fields_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_fields_named_mut(&mut self, i: &mut FieldsNamed) {
         visit_fields_named_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_fields_unnamed_mut(&mut self, i: &mut FieldsUnnamed) {
         visit_fields_unnamed_mut(self, i)
     }
@@ -376,26 +342,22 @@ pub trait VisitMut {
     fn visit_foreign_item_verbatim_mut(&mut self, i: &mut ForeignItemVerbatim) {
         visit_foreign_item_verbatim_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_generic_argument_mut(&mut self, i: &mut GenericArgument) {
         visit_generic_argument_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn visit_generic_method_argument_mut(&mut self, i: &mut GenericMethodArgument) {
         visit_generic_method_argument_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_generic_param_mut(&mut self, i: &mut GenericParam) {
         visit_generic_param_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_generics_mut(&mut self, i: &mut Generics) {
         visit_generics_mut(self, i)
     }
-    fn visit_ident_mut(&mut self, i: &mut Ident) {
-        visit_ident_mut(self, i)
-    }
     #[cfg(feature = "full")]
     fn visit_impl_item_mut(&mut self, i: &mut ImplItem) {
         visit_impl_item_mut(self, i)
@@ -424,7 +386,7 @@ pub trait VisitMut {
     fn visit_impl_item_verbatim_mut(&mut self, i: &mut ImplItemVerbatim) {
         visit_impl_item_verbatim_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_index_mut(&mut self, i: &mut Index) {
         visit_index_mut(self, i)
     }
@@ -504,7 +466,6 @@ pub trait VisitMut {
     fn visit_item_verbatim_mut(&mut self, i: &mut ItemVerbatim) {
         visit_item_verbatim_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn visit_label_mut(&mut self, i: &mut Label) {
         visit_label_mut(self, i)
@@ -512,72 +473,71 @@ pub trait VisitMut {
     fn visit_lifetime_mut(&mut self, i: &mut Lifetime) {
         visit_lifetime_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_lifetime_def_mut(&mut self, i: &mut LifetimeDef) {
         visit_lifetime_def_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_lit_mut(&mut self, i: &mut Lit) {
         visit_lit_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_lit_bool_mut(&mut self, i: &mut LitBool) {
         visit_lit_bool_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_lit_byte_mut(&mut self, i: &mut LitByte) {
         visit_lit_byte_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_lit_byte_str_mut(&mut self, i: &mut LitByteStr) {
         visit_lit_byte_str_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_lit_char_mut(&mut self, i: &mut LitChar) {
         visit_lit_char_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_lit_float_mut(&mut self, i: &mut LitFloat) {
         visit_lit_float_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_lit_int_mut(&mut self, i: &mut LitInt) {
         visit_lit_int_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_lit_str_mut(&mut self, i: &mut LitStr) {
         visit_lit_str_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_lit_verbatim_mut(&mut self, i: &mut LitVerbatim) {
         visit_lit_verbatim_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn visit_local_mut(&mut self, i: &mut Local) {
         visit_local_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_macro_mut(&mut self, i: &mut Macro) {
         visit_macro_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_macro_delimiter_mut(&mut self, i: &mut MacroDelimiter) {
         visit_macro_delimiter_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_member_mut(&mut self, i: &mut Member) {
         visit_member_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_meta_mut(&mut self, i: &mut Meta) {
         visit_meta_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_meta_list_mut(&mut self, i: &mut MetaList) {
         visit_meta_list_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_meta_name_value_mut(&mut self, i: &mut MetaNameValue) {
         visit_meta_name_value_mut(self, i)
     }
@@ -585,139 +545,119 @@ pub trait VisitMut {
     fn visit_method_sig_mut(&mut self, i: &mut MethodSig) {
         visit_method_sig_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn visit_method_turbofish_mut(&mut self, i: &mut MethodTurbofish) {
         visit_method_turbofish_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_nested_meta_mut(&mut self, i: &mut NestedMeta) {
         visit_nested_meta_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_parenthesized_generic_arguments_mut(&mut self, i: &mut ParenthesizedGenericArguments) {
         visit_parenthesized_generic_arguments_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn visit_pat_mut(&mut self, i: &mut Pat) {
         visit_pat_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn visit_pat_box_mut(&mut self, i: &mut PatBox) {
         visit_pat_box_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn visit_pat_ident_mut(&mut self, i: &mut PatIdent) {
         visit_pat_ident_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn visit_pat_lit_mut(&mut self, i: &mut PatLit) {
         visit_pat_lit_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn visit_pat_macro_mut(&mut self, i: &mut PatMacro) {
         visit_pat_macro_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn visit_pat_path_mut(&mut self, i: &mut PatPath) {
         visit_pat_path_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn visit_pat_range_mut(&mut self, i: &mut PatRange) {
         visit_pat_range_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn visit_pat_ref_mut(&mut self, i: &mut PatRef) {
         visit_pat_ref_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn visit_pat_slice_mut(&mut self, i: &mut PatSlice) {
         visit_pat_slice_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn visit_pat_struct_mut(&mut self, i: &mut PatStruct) {
         visit_pat_struct_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn visit_pat_tuple_mut(&mut self, i: &mut PatTuple) {
         visit_pat_tuple_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn visit_pat_tuple_struct_mut(&mut self, i: &mut PatTupleStruct) {
         visit_pat_tuple_struct_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn visit_pat_verbatim_mut(&mut self, i: &mut PatVerbatim) {
         visit_pat_verbatim_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn visit_pat_wild_mut(&mut self, i: &mut PatWild) {
         visit_pat_wild_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_path_mut(&mut self, i: &mut Path) {
         visit_path_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_path_arguments_mut(&mut self, i: &mut PathArguments) {
         visit_path_arguments_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_path_segment_mut(&mut self, i: &mut PathSegment) {
         visit_path_segment_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_predicate_eq_mut(&mut self, i: &mut PredicateEq) {
         visit_predicate_eq_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_predicate_lifetime_mut(&mut self, i: &mut PredicateLifetime) {
         visit_predicate_lifetime_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_predicate_type_mut(&mut self, i: &mut PredicateType) {
         visit_predicate_type_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_qself_mut(&mut self, i: &mut QSelf) {
         visit_qself_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn visit_range_limits_mut(&mut self, i: &mut RangeLimits) {
         visit_range_limits_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_return_type_mut(&mut self, i: &mut ReturnType) {
         visit_return_type_mut(self, i)
     }
-    fn visit_span_mut(&mut self, i: &mut Span) {
-        visit_span_mut(self, i)
-    }
-    #[cfg(any(feature = "full", feature = "derive"))]
     #[cfg(feature = "full")]
     fn visit_stmt_mut(&mut self, i: &mut Stmt) {
         visit_stmt_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_trait_bound_mut(&mut self, i: &mut TraitBound) {
         visit_trait_bound_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_trait_bound_modifier_mut(&mut self, i: &mut TraitBoundModifier) {
         visit_trait_bound_modifier_mut(self, i)
     }
@@ -745,79 +685,79 @@ pub trait VisitMut {
     fn visit_trait_item_verbatim_mut(&mut self, i: &mut TraitItemVerbatim) {
         visit_trait_item_verbatim_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_mut(&mut self, i: &mut Type) {
         visit_type_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_array_mut(&mut self, i: &mut TypeArray) {
         visit_type_array_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_bare_fn_mut(&mut self, i: &mut TypeBareFn) {
         visit_type_bare_fn_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_group_mut(&mut self, i: &mut TypeGroup) {
         visit_type_group_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_impl_trait_mut(&mut self, i: &mut TypeImplTrait) {
         visit_type_impl_trait_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_infer_mut(&mut self, i: &mut TypeInfer) {
         visit_type_infer_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_macro_mut(&mut self, i: &mut TypeMacro) {
         visit_type_macro_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_never_mut(&mut self, i: &mut TypeNever) {
         visit_type_never_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_param_mut(&mut self, i: &mut TypeParam) {
         visit_type_param_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_param_bound_mut(&mut self, i: &mut TypeParamBound) {
         visit_type_param_bound_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_paren_mut(&mut self, i: &mut TypeParen) {
         visit_type_paren_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_path_mut(&mut self, i: &mut TypePath) {
         visit_type_path_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_ptr_mut(&mut self, i: &mut TypePtr) {
         visit_type_ptr_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_reference_mut(&mut self, i: &mut TypeReference) {
         visit_type_reference_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_slice_mut(&mut self, i: &mut TypeSlice) {
         visit_type_slice_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_trait_object_mut(&mut self, i: &mut TypeTraitObject) {
         visit_type_trait_object_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_tuple_mut(&mut self, i: &mut TypeTuple) {
         visit_type_tuple_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_type_verbatim_mut(&mut self, i: &mut TypeVerbatim) {
         visit_type_verbatim_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_un_op_mut(&mut self, i: &mut UnOp) {
         visit_un_op_mut(self, i)
     }
@@ -845,43 +785,49 @@ pub trait VisitMut {
     fn visit_use_tree_mut(&mut self, i: &mut UseTree) {
         visit_use_tree_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_variant_mut(&mut self, i: &mut Variant) {
         visit_variant_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_vis_crate_mut(&mut self, i: &mut VisCrate) {
         visit_vis_crate_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_vis_public_mut(&mut self, i: &mut VisPublic) {
         visit_vis_public_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_vis_restricted_mut(&mut self, i: &mut VisRestricted) {
         visit_vis_restricted_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_visibility_mut(&mut self, i: &mut Visibility) {
         visit_visibility_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_where_clause_mut(&mut self, i: &mut WhereClause) {
         visit_where_clause_mut(self, i)
     }
-    #[cfg(any(feature = "full", feature = "derive"))]
+    #[cfg(any(feature = "derive", feature = "full"))]
     fn visit_where_predicate_mut(&mut self, i: &mut WherePredicate) {
         visit_where_predicate_mut(self, i)
     }
+    fn visit_span_mut(&mut self, i: &mut Span) {
+        visit_span_mut(self, i)
+    }
+    fn visit_ident_mut(&mut self, i: &mut Ident) {
+        visit_ident_mut(self, i)
+    }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_abi_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Abi) {
     tokens_helper(_visitor, &mut _i.extern_token.span);
     if let Some(ref mut it) = _i.name {
         _visitor.visit_lit_str_mut(it)
     };
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_angle_bracketed_generic_arguments_mut<V: VisitMut + ?Sized>(
     _visitor: &mut V,
     _i: &mut AngleBracketedGenericArguments,
@@ -920,7 +866,6 @@ pub fn visit_arg_self_ref_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut A
     };
     tokens_helper(_visitor, &mut _i.self_token.span);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn visit_arm_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Arm) {
     for it in &mut _i.attrs {
@@ -943,7 +888,7 @@ pub fn visit_arm_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Arm) {
         tokens_helper(_visitor, &mut it.spans)
     };
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_attr_style_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut AttrStyle) {
     match *_i {
         AttrStyle::Outer => {}
@@ -952,7 +897,7 @@ pub fn visit_attr_style_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Att
         }
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_attribute_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Attribute) {
     tokens_helper(_visitor, &mut _i.pound_token.spans);
     _visitor.visit_attr_style_mut(&mut _i.style);
@@ -960,7 +905,7 @@ pub fn visit_attribute_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Attr
     _visitor.visit_path_mut(&mut _i.path);
     skip!(_i.tts);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_bare_fn_arg_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut BareFnArg) {
     if let Some(ref mut it) = _i.name {
         _visitor.visit_bare_fn_arg_name_mut(&mut (it).0);
@@ -968,7 +913,7 @@ pub fn visit_bare_fn_arg_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Ba
     };
     _visitor.visit_type_mut(&mut _i.ty);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_bare_fn_arg_name_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut BareFnArgName) {
     match *_i {
         BareFnArgName::Named(ref mut _binding_0) => {
@@ -979,7 +924,7 @@ pub fn visit_bare_fn_arg_name_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &m
         }
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_bin_op_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut BinOp) {
     match *_i {
         BinOp::Add(ref mut _binding_0) => {
@@ -1068,13 +1013,12 @@ pub fn visit_bin_op_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut BinOp)
         }
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_binding_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Binding) {
     _visitor.visit_ident_mut(&mut _i.ident);
     tokens_helper(_visitor, &mut _i.eq_token.spans);
     _visitor.visit_type_mut(&mut _i.ty);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn visit_block_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Block) {
     tokens_helper(_visitor, &mut _i.brace_token.span);
@@ -1082,7 +1026,7 @@ pub fn visit_block_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Block) {
         _visitor.visit_stmt_mut(it)
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_bound_lifetimes_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut BoundLifetimes) {
     tokens_helper(_visitor, &mut _i.for_token.span);
     tokens_helper(_visitor, &mut _i.lt_token.spans);
@@ -1092,7 +1036,7 @@ pub fn visit_bound_lifetimes_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mu
     }
     tokens_helper(_visitor, &mut _i.gt_token.spans);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_const_param_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ConstParam) {
     for it in &mut _i.attrs {
         _visitor.visit_attribute_mut(it)
@@ -1108,7 +1052,7 @@ pub fn visit_const_param_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Co
         _visitor.visit_expr_mut(it)
     };
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_constraint_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Constraint) {
     _visitor.visit_ident_mut(&mut _i.ident);
     tokens_helper(_visitor, &mut _i.colon_token.spans);
@@ -1163,7 +1107,7 @@ pub fn visit_derive_input_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut D
     _visitor.visit_generics_mut(&mut _i.generics);
     _visitor.visit_data_mut(&mut _i.data);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_expr_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Expr) {
     match *_i {
         Expr::Box(ref mut _binding_0) => {
@@ -1289,7 +1233,6 @@ pub fn visit_expr_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Expr) {
     }
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_expr_array_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprArray) {
     for it in &mut _i.attrs {
         _visitor.visit_attribute_mut(it)
@@ -1301,7 +1244,6 @@ pub fn visit_expr_array_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Exp
     }
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_expr_assign_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprAssign) {
     for it in &mut _i.attrs {
         _visitor.visit_attribute_mut(it)
@@ -1311,7 +1253,6 @@ pub fn visit_expr_assign_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Ex
     _visitor.visit_expr_mut(&mut *_i.right);
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_expr_assign_op_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprAssignOp) {
     for it in &mut _i.attrs {
         _visitor.visit_attribute_mut(it)
@@ -1321,7 +1262,6 @@ pub fn visit_expr_assign_op_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut
     _visitor.visit_expr_mut(&mut *_i.right);
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_expr_async_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprAsync) {
     for it in &mut _i.attrs {
         _visitor.visit_attribute_mut(it)
@@ -1332,7 +1272,7 @@ pub fn visit_expr_async_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Exp
     };
     _visitor.visit_block_mut(&mut _i.block);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_expr_binary_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprBinary) {
     for it in &mut _i.attrs {
         _visitor.visit_attribute_mut(it)
@@ -1342,7 +1282,6 @@ pub fn visit_expr_binary_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Ex
     _visitor.visit_expr_mut(&mut *_i.right);
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_expr_block_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprBlock) {
     for it in &mut _i.attrs {
         _visitor.visit_attribute_mut(it)
@@ -1353,7 +1292,6 @@ pub fn visit_expr_block_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Exp
     _visitor.visit_block_mut(&mut _i.block);
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_expr_box_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprBox) {
     for it in &mut _i.attrs {
         _visitor.visit_attribute_mut(it)
@@ -1362,7 +1300,6 @@ pub fn visit_expr_box_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprB
     _visitor.visit_expr_mut(&mut *_i.expr);
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_expr_break_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprBreak) {
     for it in &mut _i.attrs {
         _visitor.visit_attribute_mut(it)
@@ -1375,7 +1312,7 @@ pub fn visit_expr_break_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Exp
         _visitor.visit_expr_mut(&mut **it)
     };
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_expr_call_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprCall) {
     for it in &mut _i.attrs {
         _visitor.visit_attribute_mut(it)
@@ -1387,7 +1324,7 @@ pub fn visit_expr_call_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Expr
         _visitor.visit_expr_mut(it)
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_expr_cast_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprCast) {
     for it in &mut _i.attrs {
         _visitor.visit_attribute_mut(it)
@@ -1397,7 +1334,6 @@ pub fn visit_expr_cast_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Expr
     _visitor.visit_type_mut(&mut *_i.ty);
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_expr_closure_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprClosure) {
     for it in &mut _i.attrs {
         _visitor.visit_attribute_mut(it)
@@ -1421,7 +1357,6 @@ pub fn visit_expr_closure_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut E
     _visitor.visit_expr_mut(&mut *_i.body);
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_expr_continue_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprContinue) {
     for it in &mut _i.attrs {
         _visitor.visit_attribute_mut(it)
@@ -1431,7 +1366,7 @@ pub fn visit_expr_continue_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut
         _visitor.visit_lifetime_mut(it)
     };
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_expr_field_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprField) {
     for it in &mut _i.attrs {
         _visitor.visit_attribute_mut(it)
@@ -1441,7 +1376,6 @@ pub fn visit_expr_field_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Exp
     _visitor.visit_member_mut(&mut _i.member);
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_expr_for_loop_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprForLoop) {
     for it in &mut _i.attrs {
         _visitor.visit_attribute_mut(it)
@@ -1456,7 +1390,6 @@ pub fn visit_expr_for_loop_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut
     _visitor.visit_block_mut(&mut _i.body);
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_expr_group_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprGroup) {
     for it in &mut _i.attrs {
         _visitor.visit_attribute_mut(it)
@@ -1465,7 +1398,6 @@ pub fn visit_expr_group_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Exp
     _visitor.visit_expr_mut(&mut *_i.expr);
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_expr_if_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprIf) {
     for it in &mut _i.attrs {
         _visitor.visit_attribute_mut(it)
@@ -1479,7 +1411,6 @@ pub fn visit_expr_if_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprIf
     };
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_expr_in_place_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprInPlace) {
     for it in &mut _i.attrs {
         _visitor.visit_attribute_mut(it)
@@ -1488,7 +1419,7 @@ pub fn visit_expr_in_place_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut
     tokens_helper(_visitor, &mut _i.arrow_token.spans);
     _visitor.visit_expr_mut(&mut *_i.value);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_expr_index_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprIndex) {
     for it in &mut _i.attrs {
         _visitor.visit_attribute_mut(it)
@@ -1498,7 +1429,6 @@ pub fn visit_expr_index_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Exp
     _visitor.visit_expr_mut(&mut *_i.index);
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_expr_let_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprLet) {
     for it in &mut _i.attrs {
         _visitor.visit_attribute_mut(it)
@@ -1511,7 +1441,7 @@ pub fn visit_expr_let_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprL
     tokens_helper(_visitor, &mut _i.eq_token.spans);
     _visitor.visit_expr_mut(&mut *_i.expr);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_expr_lit_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprLit) {
     for it in &mut _i.attrs {
         _visitor.visit_attribute_mut(it)
@@ -1519,7 +1449,6 @@ pub fn visit_expr_lit_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprL
     _visitor.visit_lit_mut(&mut _i.lit);
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_expr_loop_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprLoop) {
     for it in &mut _i.attrs {
         _visitor.visit_attribute_mut(it)
@@ -1531,7 +1460,6 @@ pub fn visit_expr_loop_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Expr
     _visitor.visit_block_mut(&mut _i.body);
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_expr_macro_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprMacro) {
     for it in &mut _i.attrs {
         _visitor.visit_attribute_mut(it)
@@ -1539,7 +1467,6 @@ pub fn visit_expr_macro_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Exp
     _visitor.visit_macro_mut(&mut _i.mac);
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_expr_match_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprMatch) {
     for it in &mut _i.attrs {
         _visitor.visit_attribute_mut(it)
@@ -1552,7 +1479,6 @@ pub fn visit_expr_match_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Exp
     }
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_expr_method_call_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprMethodCall) {
     for it in &mut _i.attrs {
         _visitor.visit_attribute_mut(it)
@@ -1569,7 +1495,7 @@ pub fn visit_expr_method_call_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &m
         _visitor.visit_expr_mut(it)
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_expr_paren_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprParen) {
     for it in &mut _i.attrs {
         _visitor.visit_attribute_mut(it)
@@ -1577,7 +1503,7 @@ pub fn visit_expr_paren_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Exp
     tokens_helper(_visitor, &mut _i.paren_token.span);
     _visitor.visit_expr_mut(&mut *_i.expr);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_expr_path_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprPath) {
     for it in &mut _i.attrs {
         _visitor.visit_attribute_mut(it)
@@ -1588,7 +1514,6 @@ pub fn visit_expr_path_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Expr
     _visitor.visit_path_mut(&mut _i.path);
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_expr_range_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprRange) {
     for it in &mut _i.attrs {
         _visitor.visit_attribute_mut(it)
@@ -1602,7 +1527,6 @@ pub fn visit_expr_range_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Exp
     };
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_expr_reference_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprReference) {
     for it in &mut _i.attrs {
         _visitor.visit_attribute_mut(it)
@@ -1614,7 +1538,6 @@ pub fn visit_expr_reference_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut
     _visitor.visit_expr_mut(&mut *_i.expr);
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_expr_repeat_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprRepeat) {
     for it in &mut _i.attrs {
         _visitor.visit_attribute_mut(it)
@@ -1625,7 +1548,6 @@ pub fn visit_expr_repeat_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Ex
     _visitor.visit_expr_mut(&mut *_i.len);
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_expr_return_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprReturn) {
     for it in &mut _i.attrs {
         _visitor.visit_attribute_mut(it)
@@ -1636,7 +1558,6 @@ pub fn visit_expr_return_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Ex
     };
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_expr_struct_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprStruct) {
     for it in &mut _i.attrs {
         _visitor.visit_attribute_mut(it)
@@ -1655,7 +1576,6 @@ pub fn visit_expr_struct_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Ex
     };
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_expr_try_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprTry) {
     for it in &mut _i.attrs {
         _visitor.visit_attribute_mut(it)
@@ -1664,7 +1584,6 @@ pub fn visit_expr_try_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprT
     tokens_helper(_visitor, &mut _i.question_token.spans);
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_expr_try_block_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprTryBlock) {
     for it in &mut _i.attrs {
         _visitor.visit_attribute_mut(it)
@@ -1673,7 +1592,6 @@ pub fn visit_expr_try_block_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut
     _visitor.visit_block_mut(&mut _i.block);
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_expr_tuple_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprTuple) {
     for it in &mut _i.attrs {
         _visitor.visit_attribute_mut(it)
@@ -1685,7 +1603,6 @@ pub fn visit_expr_tuple_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Exp
     }
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_expr_type_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprType) {
     for it in &mut _i.attrs {
         _visitor.visit_attribute_mut(it)
@@ -1694,7 +1611,7 @@ pub fn visit_expr_type_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Expr
     tokens_helper(_visitor, &mut _i.colon_token.spans);
     _visitor.visit_type_mut(&mut *_i.ty);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_expr_unary_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprUnary) {
     for it in &mut _i.attrs {
         _visitor.visit_attribute_mut(it)
@@ -1703,7 +1620,6 @@ pub fn visit_expr_unary_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Exp
     _visitor.visit_expr_mut(&mut *_i.expr);
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_expr_unsafe_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprUnsafe) {
     for it in &mut _i.attrs {
         _visitor.visit_attribute_mut(it)
@@ -1711,12 +1627,11 @@ pub fn visit_expr_unsafe_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Ex
     tokens_helper(_visitor, &mut _i.unsafe_token.span);
     _visitor.visit_block_mut(&mut _i.block);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_expr_verbatim_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprVerbatim) {
     skip!(_i.tts);
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_expr_while_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprWhile) {
     for it in &mut _i.attrs {
         _visitor.visit_attribute_mut(it)
@@ -1729,7 +1644,6 @@ pub fn visit_expr_while_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Exp
     _visitor.visit_block_mut(&mut _i.body);
 }
 #[cfg(feature = "full")]
-#[cfg(any(feature = "full", feature = "derive"))]
 pub fn visit_expr_yield_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprYield) {
     for it in &mut _i.attrs {
         _visitor.visit_attribute_mut(it)
@@ -1739,7 +1653,7 @@ pub fn visit_expr_yield_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Exp
         _visitor.visit_expr_mut(&mut **it)
     };
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_field_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Field) {
     for it in &mut _i.attrs {
         _visitor.visit_attribute_mut(it)
@@ -1753,7 +1667,6 @@ pub fn visit_field_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Field) {
     };
     _visitor.visit_type_mut(&mut _i.ty);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn visit_field_pat_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut FieldPat) {
     for it in &mut _i.attrs {
@@ -1765,7 +1678,6 @@ pub fn visit_field_pat_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Fiel
     };
     _visitor.visit_pat_mut(&mut *_i.pat);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn visit_field_value_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut FieldValue) {
     for it in &mut _i.attrs {
@@ -1777,7 +1689,7 @@ pub fn visit_field_value_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Fi
     };
     _visitor.visit_expr_mut(&mut _i.expr);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_fields_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Fields) {
     match *_i {
         Fields::Named(ref mut _binding_0) => {
@@ -1789,7 +1701,7 @@ pub fn visit_fields_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Fields)
         Fields::Unit => {}
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_fields_named_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut FieldsNamed) {
     tokens_helper(_visitor, &mut _i.brace_token.span);
     for mut el in Punctuated::pairs_mut(&mut _i.named) {
@@ -1797,7 +1709,7 @@ pub fn visit_fields_named_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut F
         _visitor.visit_field_mut(it)
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_fields_unnamed_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut FieldsUnnamed) {
     tokens_helper(_visitor, &mut _i.paren_token.span);
     for mut el in Punctuated::pairs_mut(&mut _i.unnamed) {
@@ -1930,7 +1842,7 @@ pub fn visit_foreign_item_verbatim_mut<V: VisitMut + ?Sized>(
 ) {
     skip!(_i.tts);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_generic_argument_mut<V: VisitMut + ?Sized>(
     _visitor: &mut V,
     _i: &mut GenericArgument,
@@ -1953,7 +1865,6 @@ pub fn visit_generic_argument_mut<V: VisitMut + ?Sized>(
         }
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn visit_generic_method_argument_mut<V: VisitMut + ?Sized>(
     _visitor: &mut V,
@@ -1968,7 +1879,7 @@ pub fn visit_generic_method_argument_mut<V: VisitMut + ?Sized>(
         }
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_generic_param_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut GenericParam) {
     match *_i {
         GenericParam::Type(ref mut _binding_0) => {
@@ -1982,7 +1893,7 @@ pub fn visit_generic_param_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut
         }
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_generics_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Generics) {
     if let Some(ref mut it) = _i.lt_token {
         tokens_helper(_visitor, &mut it.spans)
@@ -1998,7 +1909,6 @@ pub fn visit_generics_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Gener
         _visitor.visit_where_clause_mut(it)
     };
 }
-pub fn visit_ident_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Ident) {}
 #[cfg(feature = "full")]
 pub fn visit_impl_item_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ImplItem) {
     match *_i {
@@ -2105,7 +2015,7 @@ pub fn visit_impl_item_verbatim_mut<V: VisitMut + ?Sized>(
 ) {
     skip!(_i.tts);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_index_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Index) {
     skip!(_i.index);
     _visitor.visit_span_mut(&mut _i.span);
@@ -2456,7 +2366,6 @@ pub fn visit_item_use_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ItemU
 pub fn visit_item_verbatim_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ItemVerbatim) {
     skip!(_i.tts);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn visit_label_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Label) {
     _visitor.visit_lifetime_mut(&mut _i.name);
@@ -2466,7 +2375,7 @@ pub fn visit_lifetime_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Lifet
     _visitor.visit_span_mut(&mut _i.apostrophe);
     _visitor.visit_ident_mut(&mut _i.ident);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_lifetime_def_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut LifetimeDef) {
     for it in &mut _i.attrs {
         _visitor.visit_attribute_mut(it)
@@ -2480,7 +2389,7 @@ pub fn visit_lifetime_def_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut L
         _visitor.visit_lifetime_mut(it)
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_lit_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Lit) {
     match *_i {
         Lit::Str(ref mut _binding_0) => {
@@ -2509,40 +2418,27 @@ pub fn visit_lit_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Lit) {
         }
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_lit_bool_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut LitBool) {
     skip!(_i.value);
     _visitor.visit_span_mut(&mut _i.span);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
-pub fn visit_lit_byte_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut LitByte) {
-    skip!(_i.token);
-}
-#[cfg(any(feature = "full", feature = "derive"))]
-pub fn visit_lit_byte_str_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut LitByteStr) {
-    skip!(_i.token);
-}
-#[cfg(any(feature = "full", feature = "derive"))]
-pub fn visit_lit_char_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut LitChar) {
-    skip!(_i.token);
-}
-#[cfg(any(feature = "full", feature = "derive"))]
-pub fn visit_lit_float_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut LitFloat) {
-    skip!(_i.token);
-}
-#[cfg(any(feature = "full", feature = "derive"))]
-pub fn visit_lit_int_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut LitInt) {
-    skip!(_i.token);
-}
-#[cfg(any(feature = "full", feature = "derive"))]
-pub fn visit_lit_str_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut LitStr) {
-    skip!(_i.token);
-}
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
+pub fn visit_lit_byte_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut LitByte) {}
+#[cfg(any(feature = "derive", feature = "full"))]
+pub fn visit_lit_byte_str_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut LitByteStr) {}
+#[cfg(any(feature = "derive", feature = "full"))]
+pub fn visit_lit_char_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut LitChar) {}
+#[cfg(any(feature = "derive", feature = "full"))]
+pub fn visit_lit_float_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut LitFloat) {}
+#[cfg(any(feature = "derive", feature = "full"))]
+pub fn visit_lit_int_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut LitInt) {}
+#[cfg(any(feature = "derive", feature = "full"))]
+pub fn visit_lit_str_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut LitStr) {}
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_lit_verbatim_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut LitVerbatim) {
     skip!(_i.token);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn visit_local_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Local) {
     for it in &mut _i.attrs {
@@ -2563,14 +2459,14 @@ pub fn visit_local_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Local) {
     };
     tokens_helper(_visitor, &mut _i.semi_token.spans);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_macro_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Macro) {
     _visitor.visit_path_mut(&mut _i.path);
     tokens_helper(_visitor, &mut _i.bang_token.spans);
     _visitor.visit_macro_delimiter_mut(&mut _i.delimiter);
     skip!(_i.tts);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_macro_delimiter_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut MacroDelimiter) {
     match *_i {
         MacroDelimiter::Paren(ref mut _binding_0) => {
@@ -2584,7 +2480,7 @@ pub fn visit_macro_delimiter_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mu
         }
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_member_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Member) {
     match *_i {
         Member::Named(ref mut _binding_0) => {
@@ -2595,7 +2491,7 @@ pub fn visit_member_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Member)
         }
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_meta_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Meta) {
     match *_i {
         Meta::Word(ref mut _binding_0) => {
@@ -2609,7 +2505,7 @@ pub fn visit_meta_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Meta) {
         }
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_meta_list_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut MetaList) {
     _visitor.visit_ident_mut(&mut _i.ident);
     tokens_helper(_visitor, &mut _i.paren_token.span);
@@ -2618,7 +2514,7 @@ pub fn visit_meta_list_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Meta
         _visitor.visit_nested_meta_mut(it)
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_meta_name_value_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut MetaNameValue) {
     _visitor.visit_ident_mut(&mut _i.ident);
     tokens_helper(_visitor, &mut _i.eq_token.spans);
@@ -2641,7 +2537,6 @@ pub fn visit_method_sig_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Met
     _visitor.visit_ident_mut(&mut _i.ident);
     _visitor.visit_fn_decl_mut(&mut _i.decl);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn visit_method_turbofish_mut<V: VisitMut + ?Sized>(
     _visitor: &mut V,
@@ -2655,7 +2550,7 @@ pub fn visit_method_turbofish_mut<V: VisitMut + ?Sized>(
     }
     tokens_helper(_visitor, &mut _i.gt_token.spans);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_nested_meta_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut NestedMeta) {
     match *_i {
         NestedMeta::Meta(ref mut _binding_0) => {
@@ -2666,7 +2561,7 @@ pub fn visit_nested_meta_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Ne
         }
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_parenthesized_generic_arguments_mut<V: VisitMut + ?Sized>(
     _visitor: &mut V,
     _i: &mut ParenthesizedGenericArguments,
@@ -2678,7 +2573,6 @@ pub fn visit_parenthesized_generic_arguments_mut<V: VisitMut + ?Sized>(
     }
     _visitor.visit_return_type_mut(&mut _i.output);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn visit_pat_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Pat) {
     match *_i {
@@ -2723,13 +2617,11 @@ pub fn visit_pat_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Pat) {
         }
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn visit_pat_box_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut PatBox) {
     tokens_helper(_visitor, &mut _i.box_token.span);
     _visitor.visit_pat_mut(&mut *_i.pat);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn visit_pat_ident_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut PatIdent) {
     if let Some(ref mut it) = _i.by_ref {
@@ -2744,17 +2636,14 @@ pub fn visit_pat_ident_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut PatI
         _visitor.visit_pat_mut(&mut *(it).1);
     };
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn visit_pat_lit_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut PatLit) {
     _visitor.visit_expr_mut(&mut *_i.expr);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn visit_pat_macro_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut PatMacro) {
     _visitor.visit_macro_mut(&mut _i.mac);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn visit_pat_path_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut PatPath) {
     if let Some(ref mut it) = _i.qself {
@@ -2762,14 +2651,12 @@ pub fn visit_pat_path_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut PatPa
     };
     _visitor.visit_path_mut(&mut _i.path);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn visit_pat_range_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut PatRange) {
     _visitor.visit_expr_mut(&mut *_i.lo);
     _visitor.visit_range_limits_mut(&mut _i.limits);
     _visitor.visit_expr_mut(&mut *_i.hi);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn visit_pat_ref_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut PatRef) {
     tokens_helper(_visitor, &mut _i.and_token.spans);
@@ -2778,7 +2665,6 @@ pub fn visit_pat_ref_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut PatRef
     };
     _visitor.visit_pat_mut(&mut *_i.pat);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn visit_pat_slice_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut PatSlice) {
     tokens_helper(_visitor, &mut _i.bracket_token.span);
@@ -2800,7 +2686,6 @@ pub fn visit_pat_slice_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut PatS
         _visitor.visit_pat_mut(it)
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn visit_pat_struct_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut PatStruct) {
     _visitor.visit_path_mut(&mut _i.path);
@@ -2813,7 +2698,6 @@ pub fn visit_pat_struct_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Pat
         tokens_helper(_visitor, &mut it.spans)
     };
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn visit_pat_tuple_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut PatTuple) {
     tokens_helper(_visitor, &mut _i.paren_token.span);
@@ -2832,23 +2716,20 @@ pub fn visit_pat_tuple_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut PatT
         _visitor.visit_pat_mut(it)
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn visit_pat_tuple_struct_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut PatTupleStruct) {
     _visitor.visit_path_mut(&mut _i.path);
     _visitor.visit_pat_tuple_mut(&mut _i.pat);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn visit_pat_verbatim_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut PatVerbatim) {
     skip!(_i.tts);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn visit_pat_wild_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut PatWild) {
     tokens_helper(_visitor, &mut _i.underscore_token.spans);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_path_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Path) {
     if let Some(ref mut it) = _i.leading_colon {
         tokens_helper(_visitor, &mut it.spans)
@@ -2858,7 +2739,7 @@ pub fn visit_path_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Path) {
         _visitor.visit_path_segment_mut(it)
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_path_arguments_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut PathArguments) {
     match *_i {
         PathArguments::None => {}
@@ -2870,18 +2751,18 @@ pub fn visit_path_arguments_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut
         }
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_path_segment_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut PathSegment) {
     _visitor.visit_ident_mut(&mut _i.ident);
     _visitor.visit_path_arguments_mut(&mut _i.arguments);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_predicate_eq_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut PredicateEq) {
     _visitor.visit_type_mut(&mut _i.lhs_ty);
     tokens_helper(_visitor, &mut _i.eq_token.spans);
     _visitor.visit_type_mut(&mut _i.rhs_ty);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_predicate_lifetime_mut<V: VisitMut + ?Sized>(
     _visitor: &mut V,
     _i: &mut PredicateLifetime,
@@ -2893,7 +2774,7 @@ pub fn visit_predicate_lifetime_mut<V: VisitMut + ?Sized>(
         _visitor.visit_lifetime_mut(it)
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_predicate_type_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut PredicateType) {
     if let Some(ref mut it) = _i.lifetimes {
         _visitor.visit_bound_lifetimes_mut(it)
@@ -2905,7 +2786,7 @@ pub fn visit_predicate_type_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut
         _visitor.visit_type_param_bound_mut(it)
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_qself_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut QSelf) {
     tokens_helper(_visitor, &mut _i.lt_token.spans);
     _visitor.visit_type_mut(&mut *_i.ty);
@@ -2915,7 +2796,6 @@ pub fn visit_qself_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut QSelf) {
     };
     tokens_helper(_visitor, &mut _i.gt_token.spans);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn visit_range_limits_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut RangeLimits) {
     match *_i {
@@ -2927,7 +2807,7 @@ pub fn visit_range_limits_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut R
         }
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_return_type_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ReturnType) {
     match *_i {
         ReturnType::Default => {}
@@ -2937,8 +2817,6 @@ pub fn visit_return_type_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Re
         }
     }
 }
-pub fn visit_span_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Span) {}
-#[cfg(any(feature = "full", feature = "derive"))]
 #[cfg(feature = "full")]
 pub fn visit_stmt_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Stmt) {
     match *_i {
@@ -2957,7 +2835,7 @@ pub fn visit_stmt_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Stmt) {
         }
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_trait_bound_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut TraitBound) {
     if let Some(ref mut it) = _i.paren_token {
         tokens_helper(_visitor, &mut it.span)
@@ -2968,7 +2846,7 @@ pub fn visit_trait_bound_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Tr
     };
     _visitor.visit_path_mut(&mut _i.path);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_trait_bound_modifier_mut<V: VisitMut + ?Sized>(
     _visitor: &mut V,
     _i: &mut TraitBoundModifier,
@@ -3069,7 +2947,7 @@ pub fn visit_trait_item_verbatim_mut<V: VisitMut + ?Sized>(
 ) {
     skip!(_i.tts);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_type_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Type) {
     match *_i {
         Type::Slice(ref mut _binding_0) => {
@@ -3119,14 +2997,14 @@ pub fn visit_type_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Type) {
         }
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_type_array_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut TypeArray) {
     tokens_helper(_visitor, &mut _i.bracket_token.span);
     _visitor.visit_type_mut(&mut *_i.elem);
     tokens_helper(_visitor, &mut _i.semi_token.spans);
     _visitor.visit_expr_mut(&mut _i.len);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_type_bare_fn_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut TypeBareFn) {
     if let Some(ref mut it) = _i.lifetimes {
         _visitor.visit_bound_lifetimes_mut(it)
@@ -3148,12 +3026,12 @@ pub fn visit_type_bare_fn_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut T
     };
     _visitor.visit_return_type_mut(&mut _i.output);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_type_group_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut TypeGroup) {
     tokens_helper(_visitor, &mut _i.group_token.span);
     _visitor.visit_type_mut(&mut *_i.elem);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_type_impl_trait_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut TypeImplTrait) {
     tokens_helper(_visitor, &mut _i.impl_token.span);
     for mut el in Punctuated::pairs_mut(&mut _i.bounds) {
@@ -3161,19 +3039,19 @@ pub fn visit_type_impl_trait_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mu
         _visitor.visit_type_param_bound_mut(it)
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_type_infer_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut TypeInfer) {
     tokens_helper(_visitor, &mut _i.underscore_token.spans);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_type_macro_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut TypeMacro) {
     _visitor.visit_macro_mut(&mut _i.mac);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_type_never_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut TypeNever) {
     tokens_helper(_visitor, &mut _i.bang_token.spans);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_type_param_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut TypeParam) {
     for it in &mut _i.attrs {
         _visitor.visit_attribute_mut(it)
@@ -3193,7 +3071,7 @@ pub fn visit_type_param_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Typ
         _visitor.visit_type_mut(it)
     };
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_type_param_bound_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut TypeParamBound) {
     match *_i {
         TypeParamBound::Trait(ref mut _binding_0) => {
@@ -3204,19 +3082,19 @@ pub fn visit_type_param_bound_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &m
         }
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_type_paren_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut TypeParen) {
     tokens_helper(_visitor, &mut _i.paren_token.span);
     _visitor.visit_type_mut(&mut *_i.elem);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_type_path_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut TypePath) {
     if let Some(ref mut it) = _i.qself {
         _visitor.visit_qself_mut(it)
     };
     _visitor.visit_path_mut(&mut _i.path);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_type_ptr_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut TypePtr) {
     tokens_helper(_visitor, &mut _i.star_token.spans);
     if let Some(ref mut it) = _i.const_token {
@@ -3227,7 +3105,7 @@ pub fn visit_type_ptr_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut TypeP
     };
     _visitor.visit_type_mut(&mut *_i.elem);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_type_reference_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut TypeReference) {
     tokens_helper(_visitor, &mut _i.and_token.spans);
     if let Some(ref mut it) = _i.lifetime {
@@ -3238,12 +3116,12 @@ pub fn visit_type_reference_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut
     };
     _visitor.visit_type_mut(&mut *_i.elem);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_type_slice_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut TypeSlice) {
     tokens_helper(_visitor, &mut _i.bracket_token.span);
     _visitor.visit_type_mut(&mut *_i.elem);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_type_trait_object_mut<V: VisitMut + ?Sized>(
     _visitor: &mut V,
     _i: &mut TypeTraitObject,
@@ -3256,7 +3134,7 @@ pub fn visit_type_trait_object_mut<V: VisitMut + ?Sized>(
         _visitor.visit_type_param_bound_mut(it)
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_type_tuple_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut TypeTuple) {
     tokens_helper(_visitor, &mut _i.paren_token.span);
     for mut el in Punctuated::pairs_mut(&mut _i.elems) {
@@ -3264,11 +3142,11 @@ pub fn visit_type_tuple_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Typ
         _visitor.visit_type_mut(it)
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_type_verbatim_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut TypeVerbatim) {
     skip!(_i.tts);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_un_op_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut UnOp) {
     match *_i {
         UnOp::Deref(ref mut _binding_0) => {
@@ -3330,7 +3208,7 @@ pub fn visit_use_tree_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut UseTr
         }
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_variant_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Variant) {
     for it in &mut _i.attrs {
         _visitor.visit_attribute_mut(it)
@@ -3342,15 +3220,15 @@ pub fn visit_variant_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Varian
         _visitor.visit_expr_mut(&mut (it).1);
     };
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_vis_crate_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut VisCrate) {
     tokens_helper(_visitor, &mut _i.crate_token.span);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_vis_public_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut VisPublic) {
     tokens_helper(_visitor, &mut _i.pub_token.span);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_vis_restricted_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut VisRestricted) {
     tokens_helper(_visitor, &mut _i.pub_token.span);
     tokens_helper(_visitor, &mut _i.paren_token.span);
@@ -3359,7 +3237,7 @@ pub fn visit_vis_restricted_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut
     };
     _visitor.visit_path_mut(&mut *_i.path);
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_visibility_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Visibility) {
     match *_i {
         Visibility::Public(ref mut _binding_0) => {
@@ -3374,7 +3252,7 @@ pub fn visit_visibility_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Vis
         Visibility::Inherited => {}
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_where_clause_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut WhereClause) {
     tokens_helper(_visitor, &mut _i.where_token.span);
     for mut el in Punctuated::pairs_mut(&mut _i.predicates) {
@@ -3382,7 +3260,7 @@ pub fn visit_where_clause_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut W
         _visitor.visit_where_predicate_mut(it)
     }
 }
-#[cfg(any(feature = "full", feature = "derive"))]
+#[cfg(any(feature = "derive", feature = "full"))]
 pub fn visit_where_predicate_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut WherePredicate) {
     match *_i {
         WherePredicate::Type(ref mut _binding_0) => {
@@ -3396,3 +3274,5 @@ pub fn visit_where_predicate_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mu
         }
     }
 }
+pub fn visit_span_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Span) {}
+pub fn visit_ident_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Ident) {}
diff --git a/third_party/rust/syn/src/ident.rs b/third_party/rust/syn/src/ident.rs
index adc545f06327..f5a76a1de8b6 100644
--- a/third_party/rust/syn/src/ident.rs
+++ b/third_party/rust/syn/src/ident.rs
@@ -81,6 +81,6 @@ ident_from_token!(extern);
 
 impl From<Token![_]> for Ident {
     fn from(token: Token![_]) -> Ident {
-        Ident::new("_", token.spans[0])
+        Ident::new("_", token.span)
     }
 }
diff --git a/third_party/rust/syn/src/item.rs b/third_party/rust/syn/src/item.rs
index 78709bb8191b..858e8ecc9191 100644
--- a/third_party/rust/syn/src/item.rs
+++ b/third_party/rust/syn/src/item.rs
@@ -1092,6 +1092,13 @@ pub mod parsing {
             let content;
             let paren_token = parenthesized!(content in input);
             let inputs = content.parse_terminated(FnArg::parse)?;
+            let variadic: Option<Token![...]> = match inputs.last() {
+                Some(punctuated::Pair::End(&FnArg::Captured(ArgCaptured {
+                    ty: Type::Verbatim(TypeVerbatim { ref tts }),
+                    ..
+                }))) => parse2(tts.clone()).ok(),
+                _ => None,
+            };
 
             let output: ReturnType = input.parse()?;
             let where_clause: Option<WhereClause> = input.parse()?;
@@ -1114,7 +1121,7 @@ pub mod parsing {
                     paren_token: paren_token,
                     inputs: inputs,
                     output: output,
-                    variadic: None,
+                    variadic: variadic,
                     generics: Generics {
                         where_clause: where_clause,
                         ..generics
@@ -1179,7 +1186,23 @@ pub mod parsing {
         Ok(ArgCaptured {
             pat: input.parse()?,
             colon_token: input.parse()?,
-            ty: input.parse()?,
+            ty: match input.parse::<Token![...]>() {
+                Ok(dot3) => {
+                    let mut args = vec![
+                        TokenTree::Punct(Punct::new('.', Spacing::Joint)),
+                        TokenTree::Punct(Punct::new('.', Spacing::Joint)),
+                        TokenTree::Punct(Punct::new('.', Spacing::Alone)),
+                    ];
+                    let tokens = TokenStream::from_iter(args.into_iter().zip(&dot3.spans).map(
+                        |(mut arg, span)| {
+                            arg.set_span(*span);
+                            arg
+                        },
+                    ));
+                    Type::Verbatim(TypeVerbatim { tts: tokens })
+                }
+                Err(_) => input.parse()?,
+            },
         })
     }
 
diff --git a/third_party/rust/syn/src/keyword.rs b/third_party/rust/syn/src/keyword.rs
index baebc701a4a0..07ee1bd8e22e 100644
--- a/third_party/rust/syn/src/keyword.rs
+++ b/third_party/rust/syn/src/keyword.rs
@@ -29,7 +29,7 @@
 /// [Peeking]: parse/struct.ParseBuffer.html#method.peek
 /// [Parsing]: parse/struct.ParseBuffer.html#method.parse
 /// [Printing]: https://docs.rs/quote/0.6/quote/trait.ToTokens.html
-/// [`Span`]: struct.Span.html
+/// [`Span`]: https://docs.rs/proc-macro2/0.4/proc_macro2/struct.Span.html
 ///
 /// # Example
 ///
@@ -89,6 +89,7 @@
 #[macro_export(local_inner_macros)]
 macro_rules! custom_keyword {
     ($ident:ident) => {
+        #[allow(non_camel_case_types)]
         pub struct $ident {
             pub span: $crate::export::Span,
         }
diff --git a/third_party/rust/syn/src/lib.rs b/third_party/rust/syn/src/lib.rs
index dafc3d1784a5..24f682e1c85b 100644
--- a/third_party/rust/syn/src/lib.rs
+++ b/third_party/rust/syn/src/lib.rs
@@ -222,7 +222,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/0.15.24")]
+#![doc(html_root_url = "https://docs.rs/syn/0.15.30")]
 #![cfg_attr(feature = "cargo-clippy", allow(renamed_and_removed_lints))]
 #![cfg_attr(feature = "cargo-clippy", deny(clippy, clippy_pedantic))]
 // Ignored clippy lints.
@@ -230,8 +230,8 @@
     feature = "cargo-clippy",
     allow(
         block_in_if_condition_stmt,
+        cognitive_complexity,
         const_static_lifetime,
-        cyclomatic_complexity,
         deprecated_cfg_attr,
         doc_markdown,
         eval_order_dependence,
@@ -672,7 +672,8 @@ pub fn parse_str<T: parse::Parse>(s: &str) -> Result<T> {
 ///
 /// If present, either of these would be an error using `from_str`.
 ///
-/// *This function is available if Syn is built with the `"parsing"` and `"full"` features.*
+/// *This function is available if Syn is built with the `"parsing"` and
+/// `"full"` features.*
 ///
 /// # Examples
 ///
diff --git a/third_party/rust/syn/src/lit.rs b/third_party/rust/syn/src/lit.rs
index d58730a79c4e..3a66cb763f5c 100644
--- a/third_party/rust/syn/src/lit.rs
+++ b/third_party/rust/syn/src/lit.rs
@@ -6,8 +6,6 @@ use proc_macro2::Ident;
 
 #[cfg(feature = "parsing")]
 use proc_macro2::TokenStream;
-#[cfg(feature = "parsing")]
-use Error;
 
 use proc_macro2::TokenTree;
 
@@ -17,7 +15,7 @@ use std::hash::{Hash, Hasher};
 #[cfg(feature = "parsing")]
 use lookahead;
 #[cfg(feature = "parsing")]
-use parse::Parse;
+use parse::{Parse, Parser, Result};
 
 ast_enum_of_structs! {
     /// A Rust literal such as a string or integer or boolean.
@@ -140,23 +138,44 @@ impl LitStr {
     ///             lit_str.parse().map(Some)
     ///         }
     ///         _ => {
-    ///             let error_span = attr.bracket_token.span;
     ///             let message = "expected #[path = \"...\"]";
-    ///             Err(Error::new(error_span, message))
+    ///             Err(Error::new_spanned(attr, message))
     ///         }
     ///     }
     /// }
     /// ```
     #[cfg(feature = "parsing")]
-    pub fn parse<T: Parse>(&self) -> Result<T, Error> {
-        use proc_macro2::Group;
+    pub fn parse<T: Parse>(&self) -> Result<T> {
+        self.parse_with(T::parse)
+    }
 
-        // Parse string literal into a token stream with every span equal to the
-        // original literal's span.
-        fn spanned_tokens(s: &LitStr) -> Result<TokenStream, Error> {
-            let stream = ::parse_str(&s.value())?;
-            Ok(respan_token_stream(stream, s.span()))
-        }
+    /// Invoke parser on the content of this string literal.
+    ///
+    /// All spans in the syntax tree will point to the span of this `LitStr`.
+    ///
+    /// # Example
+    ///
+    /// ```edition2018
+    /// # use proc_macro2::Span;
+    /// # use syn::{LitStr, Result};
+    /// #
+    /// # fn main() -> Result<()> {
+    /// #     let lit_str = LitStr::new("a::b::c", Span::call_site());
+    /// #
+    /// #     const IGNORE: &str = stringify! {
+    /// let lit_str: LitStr = /* ... */;
+    /// #     };
+    ///
+    /// // Parse a string literal like "a::b::c" into a Path, not allowing
+    /// // generic arguments on any of the path segments.
+    /// let basic_path = lit_str.parse_with(syn::Path::parse_mod_style)?;
+    /// #
+    /// #     Ok(())
+    /// # }
+    /// ```
+    #[cfg(feature = "parsing")]
+    pub fn parse_with<F: Parser>(&self, parser: F) -> Result<F::Output> {
+        use proc_macro2::Group;
 
         // Token stream with every span replaced by the given one.
         fn respan_token_stream(stream: TokenStream, span: Span) -> TokenStream {
@@ -179,7 +198,12 @@ impl LitStr {
             token
         }
 
-        spanned_tokens(self).and_then(::parse2)
+        // Parse string literal into a token stream with every span equal to the
+        // original literal's span.
+        let mut tokens = ::parse_str(&self.value())?;
+        tokens = respan_token_stream(tokens, self.span());
+
+        parser.parse2(tokens)
     }
 
     pub fn span(&self) -> Span {
diff --git a/third_party/rust/syn/src/path.rs b/third_party/rust/syn/src/path.rs
index 10a043ec1e23..20c70cd79f4d 100644
--- a/third_party/rust/syn/src/path.rs
+++ b/third_party/rust/syn/src/path.rs
@@ -86,6 +86,7 @@ impl PathArguments {
         }
     }
 
+    #[cfg(feature = "parsing")]
     fn is_none(&self) -> bool {
         match *self {
             PathArguments::None => true,
@@ -427,6 +428,9 @@ pub mod parsing {
         /// - the first path segment has no angle bracketed or parenthesized
         ///   path arguments
         /// - and the ident of the first path segment is equal to the given one.
+        ///
+        /// *This function is available if Syn is built with the `"parsing"`
+        /// feature.*
         pub fn is_ident<I>(&self, ident: I) -> bool
         where
             Ident: PartialEq<I>,
diff --git a/third_party/rust/syn/src/punctuated.rs b/third_party/rust/syn/src/punctuated.rs
index c6f07d30e0ef..6b29176b3209 100644
--- a/third_party/rust/syn/src/punctuated.rs
+++ b/third_party/rust/syn/src/punctuated.rs
@@ -4,7 +4,8 @@
 //!
 //! - The fields of a struct are `Punctuated<Field, Token![,]>`.
 //! - The segments of a path are `Punctuated<PathSegment, Token![::]>`.
-//! - The bounds on a generic parameter are `Punctuated<TypeParamBound, Token![+]>`.
+//! - The bounds on a generic parameter are `Punctuated<TypeParamBound,
+//!   Token![+]>`.
 //! - The arguments to a function call are `Punctuated<Expr, Token![,]>`.
 //!
 //! This module provides a common representation for these punctuated sequences
@@ -104,7 +105,7 @@ impl<T, P> Punctuated<T, P> {
         Iter {
             inner: Box::new(PrivateIter {
                 inner: self.inner.iter(),
-                last: self.last.as_ref().map(|t| t.as_ref()).into_iter(),
+                last: self.last.as_ref().map(Box::as_ref).into_iter(),
             }),
         }
     }
@@ -115,7 +116,7 @@ impl<T, P> Punctuated<T, P> {
         IterMut {
             inner: Box::new(PrivateIterMut {
                 inner: self.inner.iter_mut(),
-                last: self.last.as_mut().map(|t| t.as_mut()).into_iter(),
+                last: self.last.as_mut().map(Box::as_mut).into_iter(),
             }),
         }
     }
@@ -125,7 +126,7 @@ impl<T, P> Punctuated<T, P> {
     pub fn pairs(&self) -> Pairs<T, P> {
         Pairs {
             inner: self.inner.iter(),
-            last: self.last.as_ref().map(|t| t.as_ref()).into_iter(),
+            last: self.last.as_ref().map(Box::as_ref).into_iter(),
         }
     }
 
@@ -134,7 +135,7 @@ impl<T, P> Punctuated<T, P> {
     pub fn pairs_mut(&mut self) -> PairsMut<T, P> {
         PairsMut {
             inner: self.inner.iter_mut(),
-            last: self.last.as_mut().map(|t| t.as_mut()).into_iter(),
+            last: self.last.as_mut().map(Box::as_mut).into_iter(),
         }
     }
 
diff --git a/third_party/rust/syn/src/synom.rs b/third_party/rust/syn/src/synom.rs
deleted file mode 100644
index e69de29bb2d1..000000000000
diff --git a/third_party/rust/syn/src/thread.rs b/third_party/rust/syn/src/thread.rs
index 8a79e951b077..ff47e4af4d78 100644
--- a/third_party/rust/syn/src/thread.rs
+++ b/third_party/rust/syn/src/thread.rs
@@ -54,10 +54,12 @@ mod thread_id {
 
 #[cfg(not(syn_can_use_thread_id))]
 mod thread_id {
+    #[allow(deprecated)]
     use std::sync::atomic::{AtomicUsize, Ordering, ATOMIC_USIZE_INIT};
 
     thread_local! {
         static THREAD_ID: usize = {
+            #[allow(deprecated)]
             static NEXT_THREAD_ID: AtomicUsize = ATOMIC_USIZE_INIT;
 
             // Ordering::Relaxed because our only requirement for the ids is
diff --git a/third_party/rust/syn/src/token.rs b/third_party/rust/syn/src/token.rs
index f54d02cb2189..04d69670fe59 100644
--- a/third_party/rust/syn/src/token.rs
+++ b/third_party/rust/syn/src/token.rs
@@ -68,6 +68,25 @@
 //!     }
 //! }
 //! ```
+//!
+//! # Other operations
+//!
+//! Every keyword and punctuation token supports the following operations.
+//!
+//! - [Peeking] — `input.peek(Token![...])`
+//!
+//! - [Parsing] — `input.parse::<Token![...]>()?`
+//!
+//! - [Printing] — `quote!( ... #the_token ... )`
+//!
+//! - Construction from a [`Span`] — `let the_token = Token![...](sp)`
+//!
+//! - Field access to its span — `let sp = the_token.span`
+//!
+//! [Peeking]: ../parse/struct.ParseBuffer.html#method.peek
+//! [Parsing]: ../parse/struct.ParseBuffer.html#method.parse
+//! [Printing]: https://docs.rs/quote/0.6/quote/trait.ToTokens.html
+//! [`Span`]: https://docs.rs/proc-macro2/0.4/proc_macro2/struct.Span.html
 
 use std;
 #[cfg(feature = "extra-traits")]
@@ -76,6 +95,7 @@ use std::cmp;
 use std::fmt::{self, Debug};
 #[cfg(feature = "extra-traits")]
 use std::hash::{Hash, Hasher};
+use std::ops::{Deref, DerefMut};
 
 #[cfg(feature = "parsing")]
 use proc_macro2::Delimiter;
@@ -87,6 +107,7 @@ use proc_macro2::TokenStream;
 #[cfg(feature = "printing")]
 use quote::{ToTokens, TokenStreamExt};
 
+use self::private::WithSpan;
 #[cfg(feature = "parsing")]
 use buffer::Cursor;
 #[cfg(feature = "parsing")]
@@ -117,9 +138,18 @@ pub trait Token: private::Sealed {
     fn display() -> &'static str;
 }
 
-#[cfg(feature = "parsing")]
 mod private {
+    use proc_macro2::Span;
+
+    #[cfg(feature = "parsing")]
     pub trait Sealed {}
+
+    /// Support writing `token.span` rather than `token.spans[0]` on tokens that
+    /// hold a single span.
+    #[repr(C)]
+    pub struct WithSpan {
+        pub span: Span,
+    }
 }
 
 #[cfg(feature = "parsing")]
@@ -285,10 +315,31 @@ macro_rules! define_keywords {
     };
 }
 
+macro_rules! impl_deref_if_len_is_1 {
+    ($name:ident/1) => {
+        impl Deref for $name {
+            type Target = WithSpan;
+
+            fn deref(&self) -> &Self::Target {
+                unsafe { &*(self as *const Self as *const WithSpan) }
+            }
+        }
+
+        impl DerefMut for $name {
+            fn deref_mut(&mut self) -> &mut Self::Target {
+                unsafe { &mut *(self as *mut Self as *mut WithSpan) }
+            }
+        }
+    };
+
+    ($name:ident/$len:tt) => {};
+}
+
 macro_rules! define_punctuation_structs {
     ($($token:tt pub struct $name:ident/$len:tt #[$doc:meta])*) => {
         $(
             #[cfg_attr(feature = "clone-impls", derive(Copy, Clone))]
+            #[repr(C)]
             #[$doc]
             ///
             /// Don't try to remember the name of this type -- use the [`Token!`]
@@ -336,6 +387,8 @@ macro_rules! define_punctuation_structs {
             impl Hash for $name {
                 fn hash<H: Hasher>(&self, _state: &mut H) {}
             }
+
+            impl_deref_if_len_is_1!($name/$len);
         )*
     };
 }
@@ -450,7 +503,7 @@ define_punctuation_structs! {
 #[cfg(feature = "printing")]
 impl ToTokens for Underscore {
     fn to_tokens(&self, tokens: &mut TokenStream) {
-        tokens.append(Ident::new("_", self.spans[0]));
+        tokens.append(Ident::new("_", self.span));
     }
 }