Parse default field values as Type::Verbatim

src/data.rs

@@ -334,6 +334,7 @@ pub(crate) mod parsing {
 
             let colon_token: Token![:] = input.parse()?;
 
+            let type_start = input.fork();
             let ty: Type = if unnamed_field
                 && (input.peek(Token![struct])
                     || input.peek(Token![union]) && input.peek2(token::Brace))
@@ -346,6 +347,19 @@ pub(crate) mod parsing {
                 input.parse()?
             };
 
+            let ty = if input.peek(Token![=]) {
+                // We don't support parsing default_field_values, a (currently unstable) feature (see https://github.com/rust-lang/rfcs/pull/3681)
+                // because `Field` is not `non_exhaustive`, and so can't have new fields added to it.
+                // We know that this isn't the correct semantics; the default field value is not part of the type.
+                // However, for parsing purposes, it is in type position.
+                // We use a similar solution for negative inherent impls, e.g. `impl !SomeType {}`
+                input.parse::<Token![=]>()?;
+                input.parse::<Expr>()?;
+                Type::Verbatim(verbatim::between(&type_start, input))
+            } else {
+                ty
+            };
+
             Ok(Field {
                 attrs,
                 vis,

src/parse_quote.rs

@@ -194,6 +194,8 @@ impl ParseQuote for Field {
 
         let ty: Type = input.parse()?;
 
+        // TODO: Once `Field` supports default_field_values, parse them here
+
         Ok(Field {
             attrs,
             vis,

tests/test_item.rs

@@ -274,6 +274,67 @@ fn test_impl_visibility() {
     snapshot!(tokens as Item, @"Item::Verbatim(`pub default unsafe impl union { }`)");
 }
 
+#[test]
+fn test_struct_default_field_values() {
+    let tokens = quote! {
+        struct Foo {
+            field: i32 = const { 42 },
+        }
+    };
+    snapshot!(tokens as Item, @r#"
+    Item::Struct {
+        vis: Visibility::Inherited,
+        ident: "Foo",
+        generics: Generics,
+        fields: Fields::Named {
+            named: [
+                Field {
+                    vis: Visibility::Inherited,
+                    ident: Some("field"),
+                    colon_token: Some,
+                    ty: Type::Verbatim(`i32 = const { 42 }`),
+                },
+                Token![,],
+            ],
+        },
+    }
+    "#);
+}
+
+#[test]
+fn test_enum_default_field_values() {
+    let tokens = quote! {
+        enum Foo {
+            Bar {
+                field: i32 = 42,
+            }
+        }
+    };
+    snapshot!(tokens as Item, @r#"
+    Item::Enum {
+        vis: Visibility::Inherited,
+        ident: "Foo",
+        generics: Generics,
+        variants: [
+            Variant {
+                ident: "Bar",
+                fields: Fields::Named {
+                    named: [
+                        Field {
+                            vis: Visibility::Inherited,
+                            ident: Some("field"),
+                            colon_token: Some,
+                            ty: Type::Verbatim(`i32 = 42`),
+                        },
+                        Token![,],
+                    ],
+                },
+            },
+        ],
+    }
+    "#);
+}
+
 #[test]
 fn test_impl_type_parameter_defaults() {
     #[cfg(any())]