Support parsing #![feature(default_field_values)]

- RFC: rust-lang/rfcs#3681
- Tracking issue: rust-lang/rust#132162
- Feature gate: `#![feature(default_field_values)]`

```rust
struct Pet {
    name: Option<String>,
    age: i128 = 42,
    //        ^^^^
}
```

Fix dtolnay#1774.

src/data.rs

@@ -196,6 +196,11 @@ ast_struct! {
         pub colon_token: Option<Token![:]>,
 
         pub ty: Type,
+
+        /// Default value: `field_name: i32 = 1`
+        ///
+        /// `#![feature(default_field_values)]`
+        pub default: Option<(Token![=], Expr)>,
     }
 }
 
@@ -345,6 +350,11 @@ pub(crate) mod parsing {
             } else {
                 input.parse()?
             };
+            let mut default: Option<(Token![=], Expr)> = None;
+            if input.peek(Token![=]) {
+                let eq_token: Token![=] = input.parse()?;
+                default = Some((eq_token, input.parse()?));
+            }
 
             Ok(Field {
                 attrs,
@@ -353,6 +363,7 @@ pub(crate) mod parsing {
                 ident: Some(ident),
                 colon_token: Some(colon_token),
                 ty,
+                default,
             })
         }
 
@@ -366,6 +377,7 @@ pub(crate) mod parsing {
                 ident: None,
                 colon_token: None,
                 ty: input.parse()?,
+                default: None,
             })
         }
     }

src/parse_quote.rs

@@ -149,7 +149,7 @@ impl<T: Parse> ParseQuote for T {
 
 use crate::punctuated::Punctuated;
 #[cfg(any(feature = "full", feature = "derive"))]
-use crate::{attr, Attribute, Field, FieldMutability, Ident, Type, Visibility};
+use crate::{attr, Attribute, Expr, Field, FieldMutability, Ident, Type, Visibility};
 #[cfg(feature = "full")]
 use crate::{Arm, Block, Pat, Stmt};
 
@@ -194,13 +194,20 @@ impl ParseQuote for Field {
 
         let ty: Type = input.parse()?;
 
+        let mut default: Option<(Token![=], Expr)> = None;
+        if is_named && input.peek(Token![=]) {
+            let eq_token: Token![=] = input.parse()?;
+            default = Some((eq_token, input.parse()?));
+        }
+
         Ok(Field {
             attrs,
             vis,
             mutability: FieldMutability::None,
             ident,
             colon_token,
             ty,
+            default,
         })
     }
 }

tests/test_item.rs

@@ -274,6 +274,114 @@ fn test_impl_visibility() {
     snapshot!(tokens as Item, @"Item::Verbatim(`pub default unsafe impl union { }`)");
 }
 
+#[test]
+fn test_default_field_values() {
+    let tokens = quote! {
+        struct Foo {
+            field_int: i32 = 42,
+            field_const: 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_int"),
+                    colon_token: Some,
+                    ty: Type::Path {
+                        path: Path {
+                            segments: [
+                                PathSegment {
+                                    ident: "i32",
+                                },
+                            ],
+                        },
+                    },
+                    default: Some(Expr::Lit {
+                        lit: 42,
+                    }),
+                },
+                Token![,],
+                Field {
+                    vis: Visibility::Inherited,
+                    ident: Some("field_const"),
+                    colon_token: Some,
+                    ty: Type::Path {
+                        path: Path {
+                            segments: [
+                                PathSegment {
+                                    ident: "i32",
+                                },
+                            ],
+                        },
+                    },
+                    default: Some(Expr::Const {
+                        block: Block {
+                            stmts: [
+                                Stmt::Expr(
+                                    Expr::Lit {
+                                        lit: 42,
+                                    },
+                                    None,
+                                ),
+                            ],
+                        },
+                    }),
+                },
+                Token![,],
+            ],
+        },
+    }
+    "#);
+
+    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::Path {
+                                path: Path {
+                                    segments: [
+                                        PathSegment {
+                                            ident: "i32",
+                                        },
+                                    ],
+                                },
+                            },
+                            default: Some(Expr::Lit {
+                                lit: 42,
+                            }),
+                        },
+                        Token![,],
+                    ],
+                },
+            },
+        ],
+    }
+    "#);
+}
+
 #[test]
 fn test_impl_type_parameter_defaults() {
     #[cfg(any())]