New upstream version 1.41.1+dfsg1

[rustc.git] / vendor / syn / tests / test_derive_input.rs

diff --git a/vendor/syn/tests/test_derive_input.rs b/vendor/syn/tests/test_derive_input.rs
index de682401664994baaada10c3f032811cf2b8f6b2..e3685aeaea7359fd6f66ea154aed0be61b278264 100644 (file)
--- a/vendor/syn/tests/test_derive_input.rs
+++ b/vendor/syn/tests/test_derive_input.rs
@@ -1,6 +1,3 @@
-extern crate quote;
-extern crate syn;
-
 mod features;
 
 #[macro_use]
@@ -16,15 +13,15 @@ fn test_unit() {
     };
 
     snapshot!(input as DeriveInput, @r###"
-   ⋮DeriveInput {
-   ⋮    vis: Inherited,
-   ⋮    ident: "Unit",
-   ⋮    generics: Generics,
-   ⋮    data: Data::Struct {
-   ⋮        fields: Unit,
-   ⋮        semi_token: Some,
-   ⋮    },
-   ⋮}
+    DeriveInput {
+        vis: Inherited,
+        ident: "Unit",
+        generics: Generics,
+        data: Data::Struct {
+            fields: Unit,
+            semi_token: Some,
+        },
+    }
     "###);
 }
 
@@ -39,105 +36,105 @@ fn test_struct() {
     };
 
     snapshot!(input as DeriveInput, @r###"
-   ⋮DeriveInput {
-   ⋮    attrs: [
-   ⋮        Attribute {
-   ⋮            style: Outer,
-   ⋮            path: Path {
-   ⋮                segments: [
-   ⋮                    PathSegment {
-   ⋮                        ident: "derive",
-   ⋮                        arguments: None,
-   ⋮                    },
-   ⋮                ],
-   ⋮            },
-   ⋮            tokens: `( Debug , Clone )`,
-   ⋮        },
-   ⋮    ],
-   ⋮    vis: Visibility::Public,
-   ⋮    ident: "Item",
-   ⋮    generics: Generics,
-   ⋮    data: Data::Struct {
-   ⋮        fields: Fields::Named {
-   ⋮            named: [
-   ⋮                Field {
-   ⋮                    vis: Visibility::Public,
-   ⋮                    ident: Some("ident"),
-   ⋮                    colon_token: Some,
-   ⋮                    ty: Type::Path {
-   ⋮                        path: Path {
-   ⋮                            segments: [
-   ⋮                                PathSegment {
-   ⋮                                    ident: "Ident",
-   ⋮                                    arguments: None,
-   ⋮                                },
-   ⋮                            ],
-   ⋮                        },
-   ⋮                    },
-   ⋮                },
-   ⋮                Field {
-   ⋮                    vis: Visibility::Public,
-   ⋮                    ident: Some("attrs"),
-   ⋮                    colon_token: Some,
-   ⋮                    ty: Type::Path {
-   ⋮                        path: Path {
-   ⋮                            segments: [
-   ⋮                                PathSegment {
-   ⋮                                    ident: "Vec",
-   ⋮                                    arguments: PathArguments::AngleBracketed {
-   ⋮                                        args: [
-   ⋮                                            Type(Type::Path {
-   ⋮                                                path: Path {
-   ⋮                                                    segments: [
-   ⋮                                                        PathSegment {
-   ⋮                                                            ident: "Attribute",
-   ⋮                                                            arguments: None,
-   ⋮                                                        },
-   ⋮                                                    ],
-   ⋮                                                },
-   ⋮                                            }),
-   ⋮                                        ],
-   ⋮                                    },
-   ⋮                                },
-   ⋮                            ],
-   ⋮                        },
-   ⋮                    },
-   ⋮                },
-   ⋮            ],
-   ⋮        },
-   ⋮    },
-   ⋮}
+    DeriveInput {
+        attrs: [
+            Attribute {
+                style: Outer,
+                path: Path {
+                    segments: [
+                        PathSegment {
+                            ident: "derive",
+                            arguments: None,
+                        },
+                    ],
+                },
+                tokens: `( Debug , Clone )`,
+            },
+        ],
+        vis: Visibility::Public,
+        ident: "Item",
+        generics: Generics,
+        data: Data::Struct {
+            fields: Fields::Named {
+                named: [
+                    Field {
+                        vis: Visibility::Public,
+                        ident: Some("ident"),
+                        colon_token: Some,
+                        ty: Type::Path {
+                            path: Path {
+                                segments: [
+                                    PathSegment {
+                                        ident: "Ident",
+                                        arguments: None,
+                                    },
+                                ],
+                            },
+                        },
+                    },
+                    Field {
+                        vis: Visibility::Public,
+                        ident: Some("attrs"),
+                        colon_token: Some,
+                        ty: Type::Path {
+                            path: Path {
+                                segments: [
+                                    PathSegment {
+                                        ident: "Vec",
+                                        arguments: PathArguments::AngleBracketed {
+                                            args: [
+                                                Type(Type::Path {
+                                                    path: Path {
+                                                        segments: [
+                                                            PathSegment {
+                                                                ident: "Attribute",
+                                                                arguments: None,
+                                                            },
+                                                        ],
+                                                    },
+                                                }),
+                                            ],
+                                        },
+                                    },
+                                ],
+                            },
+                        },
+                    },
+                ],
+            },
+        },
+    }
     "###);
 
     snapshot!(input.attrs[0].parse_meta().unwrap(), @r###"
-   ⋮Meta::List {
-   ⋮    path: Path {
-   ⋮        segments: [
-   ⋮            PathSegment {
-   ⋮                ident: "derive",
-   ⋮                arguments: None,
-   ⋮            },
-   ⋮        ],
-   ⋮    },
-   ⋮    nested: [
-   ⋮        Meta(Path(Path {
-   ⋮            segments: [
-   ⋮                PathSegment {
-   ⋮                    ident: "Debug",
-   ⋮                    arguments: None,
-   ⋮                },
-   ⋮            ],
-   ⋮        })),
-   ⋮        Meta(Path(Path {
-   ⋮            segments: [
-   ⋮                PathSegment {
-   ⋮                    ident: "Clone",
-   ⋮                    arguments: None,
-   ⋮                },
-   ⋮            ],
-   ⋮        })),
-   ⋮    ],
-   ⋮}
+    Meta::List {
+        path: Path {
+            segments: [
+                PathSegment {
+                    ident: "derive",
+                    arguments: None,
+                },
+            ],
+        },
+        nested: [
+            Meta(Path(Path {
+                segments: [
+                    PathSegment {
+                        ident: "Debug",
+                        arguments: None,
+                    },
+                ],
+            })),
+            Meta(Path(Path {
+                segments: [
+                    PathSegment {
+                        ident: "Clone",
+                        arguments: None,
+                    },
+                ],
+            })),
+        ],
+    }
     "###);
 }
 
@@ -151,46 +148,46 @@ fn test_union() {
     };
 
     snapshot!(input as DeriveInput, @r###"
-   ⋮DeriveInput {
-   ⋮    vis: Inherited,
-   ⋮    ident: "MaybeUninit",
-   ⋮    generics: Generics {
-   ⋮        lt_token: Some,
-   ⋮        params: [
-   ⋮            Type(TypeParam {
-   ⋮                ident: "T",
-   ⋮            }),
-   ⋮        ],
-   ⋮        gt_token: Some,
-   ⋮    },
-   ⋮    data: Data::Union {
-   ⋮        fields: FieldsNamed {
-   ⋮            named: [
-   ⋮                Field {
-   ⋮                    vis: Inherited,
-   ⋮                    ident: Some("uninit"),
-   ⋮                    colon_token: Some,
-   ⋮                    ty: Type::Tuple,
-   ⋮                },
-   ⋮                Field {
-   ⋮                    vis: Inherited,
-   ⋮                    ident: Some("value"),
-   ⋮                    colon_token: Some,
-   ⋮                    ty: Type::Path {
-   ⋮                        path: Path {
-   ⋮                            segments: [
-   ⋮                                PathSegment {
-   ⋮                                    ident: "T",
-   ⋮                                    arguments: None,
-   ⋮                                },
-   ⋮                            ],
-   ⋮                        },
-   ⋮                    },
-   ⋮                },
-   ⋮            ],
-   ⋮        },
-   ⋮    },
-   ⋮}
+    DeriveInput {
+        vis: Inherited,
+        ident: "MaybeUninit",
+        generics: Generics {
+            lt_token: Some,
+            params: [
+                Type(TypeParam {
+                    ident: "T",
+                }),
+            ],
+            gt_token: Some,
+        },
+        data: Data::Union {
+            fields: FieldsNamed {
+                named: [
+                    Field {
+                        vis: Inherited,
+                        ident: Some("uninit"),
+                        colon_token: Some,
+                        ty: Type::Tuple,
+                    },
+                    Field {
+                        vis: Inherited,
+                        ident: Some("value"),
+                        colon_token: Some,
+                        ty: Type::Path {
+                            path: Path {
+                                segments: [
+                                    PathSegment {
+                                        ident: "T",
+                                        arguments: None,
+                                    },
+                                ],
+                            },
+                        },
+                    },
+                ],
+            },
+        },
+    }
     "###);
 }
 
@@ -212,118 +209,118 @@ fn test_enum() {
     };
 
     snapshot!(input as DeriveInput, @r###"
-   ⋮DeriveInput {
-   ⋮    attrs: [
-   ⋮        Attribute {
-   ⋮            style: Outer,
-   ⋮            path: Path {
-   ⋮                segments: [
-   ⋮                    PathSegment {
-   ⋮                        ident: "doc",
-   ⋮                        arguments: None,
-   ⋮                    },
-   ⋮                ],
-   ⋮            },
-   ⋮            tokens: `= r" See the std::result module documentation for details."`,
-   ⋮        },
-   ⋮        Attribute {
-   ⋮            style: Outer,
-   ⋮            path: Path {
-   ⋮                segments: [
-   ⋮                    PathSegment {
-   ⋮                        ident: "must_use",
-   ⋮                        arguments: None,
-   ⋮                    },
-   ⋮                ],
-   ⋮            },
-   ⋮            tokens: ``,
-   ⋮        },
-   ⋮    ],
-   ⋮    vis: Visibility::Public,
-   ⋮    ident: "Result",
-   ⋮    generics: Generics {
-   ⋮        lt_token: Some,
-   ⋮        params: [
-   ⋮            Type(TypeParam {
-   ⋮                ident: "T",
-   ⋮            }),
-   ⋮            Type(TypeParam {
-   ⋮                ident: "E",
-   ⋮            }),
-   ⋮        ],
-   ⋮        gt_token: Some,
-   ⋮    },
-   ⋮    data: Data::Enum {
-   ⋮        variants: [
-   ⋮            Variant {
-   ⋮                ident: "Ok",
-   ⋮                fields: Fields::Unnamed {
-   ⋮                    unnamed: [
-   ⋮                        Field {
-   ⋮                            vis: Inherited,
-   ⋮                            ty: Type::Path {
-   ⋮                                path: Path {
-   ⋮                                    segments: [
-   ⋮                                        PathSegment {
-   ⋮                                            ident: "T",
-   ⋮                                            arguments: None,
-   ⋮                                        },
-   ⋮                                    ],
-   ⋮                                },
-   ⋮                            },
-   ⋮                        },
-   ⋮                    ],
-   ⋮                },
-   ⋮            },
-   ⋮            Variant {
-   ⋮                ident: "Err",
-   ⋮                fields: Fields::Unnamed {
-   ⋮                    unnamed: [
-   ⋮                        Field {
-   ⋮                            vis: Inherited,
-   ⋮                            ty: Type::Path {
-   ⋮                                path: Path {
-   ⋮                                    segments: [
-   ⋮                                        PathSegment {
-   ⋮                                            ident: "E",
-   ⋮                                            arguments: None,
-   ⋮                                        },
-   ⋮                                    ],
-   ⋮                                },
-   ⋮                            },
-   ⋮                        },
-   ⋮                    ],
-   ⋮                },
-   ⋮            },
-   ⋮            Variant {
-   ⋮                ident: "Surprise",
-   ⋮                fields: Unit,
-   ⋮                discriminant: Some(Expr::Lit {
-   ⋮                    lit: 0isize,
-   ⋮                }),
-   ⋮            },
-   ⋮            Variant {
-   ⋮                ident: "ProcMacroHack",
-   ⋮                fields: Unit,
-   ⋮                discriminant: Some(Expr::Field {
-   ⋮                    base: Expr::Tuple {
-   ⋮                        elems: [
-   ⋮                            Expr::Lit {
-   ⋮                                lit: 0,
-   ⋮                            },
-   ⋮                            Expr::Lit {
-   ⋮                                lit: "data",
-   ⋮                            },
-   ⋮                        ],
-   ⋮                    },
-   ⋮                    member: Unnamed(Index {
-   ⋮                        index: 0,
-   ⋮                    }),
-   ⋮                }),
-   ⋮            },
-   ⋮        ],
-   ⋮    },
-   ⋮}
+    DeriveInput {
+        attrs: [
+            Attribute {
+                style: Outer,
+                path: Path {
+                    segments: [
+                        PathSegment {
+                            ident: "doc",
+                            arguments: None,
+                        },
+                    ],
+                },
+                tokens: `= r" See the std::result module documentation for details."`,
+            },
+            Attribute {
+                style: Outer,
+                path: Path {
+                    segments: [
+                        PathSegment {
+                            ident: "must_use",
+                            arguments: None,
+                        },
+                    ],
+                },
+                tokens: ``,
+            },
+        ],
+        vis: Visibility::Public,
+        ident: "Result",
+        generics: Generics {
+            lt_token: Some,
+            params: [
+                Type(TypeParam {
+                    ident: "T",
+                }),
+                Type(TypeParam {
+                    ident: "E",
+                }),
+            ],
+            gt_token: Some,
+        },
+        data: Data::Enum {
+            variants: [
+                Variant {
+                    ident: "Ok",
+                    fields: Fields::Unnamed {
+                        unnamed: [
+                            Field {
+                                vis: Inherited,
+                                ty: Type::Path {
+                                    path: Path {
+                                        segments: [
+                                            PathSegment {
+                                                ident: "T",
+                                                arguments: None,
+                                            },
+                                        ],
+                                    },
+                                },
+                            },
+                        ],
+                    },
+                },
+                Variant {
+                    ident: "Err",
+                    fields: Fields::Unnamed {
+                        unnamed: [
+                            Field {
+                                vis: Inherited,
+                                ty: Type::Path {
+                                    path: Path {
+                                        segments: [
+                                            PathSegment {
+                                                ident: "E",
+                                                arguments: None,
+                                            },
+                                        ],
+                                    },
+                                },
+                            },
+                        ],
+                    },
+                },
+                Variant {
+                    ident: "Surprise",
+                    fields: Unit,
+                    discriminant: Some(Expr::Lit {
+                        lit: 0isize,
+                    }),
+                },
+                Variant {
+                    ident: "ProcMacroHack",
+                    fields: Unit,
+                    discriminant: Some(Expr::Field {
+                        base: Expr::Tuple {
+                            elems: [
+                                Expr::Lit {
+                                    lit: 0,
+                                },
+                                Expr::Lit {
+                                    lit: "data",
+                                },
+                            ],
+                        },
+                        member: Unnamed(Index {
+                            index: 0,
+                        }),
+                    }),
+                },
+            ],
+        },
+    }
     "###);
 
     let meta_items: Vec<_> = input
@@ -333,27 +330,27 @@ fn test_enum() {
         .collect();
 
     snapshot!(meta_items, @r###"
-   ⋮[
-   ⋮    Meta::NameValue {
-   ⋮        path: Path {
-   ⋮            segments: [
-   ⋮                PathSegment {
-   ⋮                    ident: "doc",
-   ⋮                    arguments: None,
-   ⋮                },
-   ⋮            ],
-   ⋮        },
-   ⋮        lit: " See the std::result module documentation for details.",
-   ⋮    },
-   ⋮    Path(Path {
-   ⋮        segments: [
-   ⋮            PathSegment {
-   ⋮                ident: "must_use",
-   ⋮                arguments: None,
-   ⋮            },
-   ⋮        ],
-   ⋮    }),
-   ⋮]
+    [
+        Meta::NameValue {
+            path: Path {
+                segments: [
+                    PathSegment {
+                        ident: "doc",
+                        arguments: None,
+                    },
+                ],
+            },
+            lit: " See the std::result module documentation for details.",
+        },
+        Path(Path {
+            segments: [
+                PathSegment {
+                    ident: "must_use",
+                    arguments: None,
+                },
+            ],
+        }),
+    ]
     "###);
 }
 
@@ -366,34 +363,34 @@ fn test_attr_with_path() {
     };
 
     snapshot!(input as DeriveInput, @r###"
-   ⋮DeriveInput {
-   ⋮    attrs: [
-   ⋮        Attribute {
-   ⋮            style: Outer,
-   ⋮            path: Path {
-   ⋮                leading_colon: Some,
-   ⋮                segments: [
-   ⋮                    PathSegment {
-   ⋮                        ident: "attr_args",
-   ⋮                        arguments: None,
-   ⋮                    },
-   ⋮                    PathSegment {
-   ⋮                        ident: "identity",
-   ⋮                        arguments: None,
-   ⋮                    },
-   ⋮                ],
-   ⋮            },
-   ⋮            tokens: `fn main ( ) { assert_eq ! ( foo ( ) , "Hello, world!" ) ; }`,
-   ⋮        },
-   ⋮    ],
-   ⋮    vis: Inherited,
-   ⋮    ident: "Dummy",
-   ⋮    generics: Generics,
-   ⋮    data: Data::Struct {
-   ⋮        fields: Unit,
-   ⋮        semi_token: Some,
-   ⋮    },
-   ⋮}
+    DeriveInput {
+        attrs: [
+            Attribute {
+                style: Outer,
+                path: Path {
+                    leading_colon: Some,
+                    segments: [
+                        PathSegment {
+                            ident: "attr_args",
+                            arguments: None,
+                        },
+                        PathSegment {
+                            ident: "identity",
+                            arguments: None,
+                        },
+                    ],
+                },
+                tokens: `fn main ( ) { assert_eq ! ( foo ( ) , "Hello, world!" ) ; }`,
+            },
+        ],
+        vis: Inherited,
+        ident: "Dummy",
+        generics: Generics,
+        data: Data::Struct {
+            fields: Unit,
+            semi_token: Some,
+        },
+    }
     "###);
 
     assert!(input.attrs[0].parse_meta().is_err());
@@ -407,29 +404,29 @@ fn test_attr_with_non_mod_style_path() {
     };
 
     snapshot!(input as DeriveInput, @r###"
-   ⋮DeriveInput {
-   ⋮    attrs: [
-   ⋮        Attribute {
-   ⋮            style: Outer,
-   ⋮            path: Path {
-   ⋮                segments: [
-   ⋮                    PathSegment {
-   ⋮                        ident: "inert",
-   ⋮                        arguments: None,
-   ⋮                    },
-   ⋮                ],
-   ⋮            },
-   ⋮            tokens: `< T >`,
-   ⋮        },
-   ⋮    ],
-   ⋮    vis: Inherited,
-   ⋮    ident: "S",
-   ⋮    generics: Generics,
-   ⋮    data: Data::Struct {
-   ⋮        fields: Unit,
-   ⋮        semi_token: Some,
-   ⋮    },
-   ⋮}
+    DeriveInput {
+        attrs: [
+            Attribute {
+                style: Outer,
+                path: Path {
+                    segments: [
+                        PathSegment {
+                            ident: "inert",
+                            arguments: None,
+                        },
+                    ],
+                },
+                tokens: `< T >`,
+            },
+        ],
+        vis: Inherited,
+        ident: "S",
+        generics: Generics,
+        data: Data::Struct {
+            fields: Unit,
+            semi_token: Some,
+        },
+    }
     "###);
 
     assert!(input.attrs[0].parse_meta().is_err());
@@ -443,48 +440,48 @@ fn test_attr_with_mod_style_path_with_self() {
     };
 
     snapshot!(input as DeriveInput, @r###"
-   ⋮DeriveInput {
-   ⋮    attrs: [
-   ⋮        Attribute {
-   ⋮            style: Outer,
-   ⋮            path: Path {
-   ⋮                segments: [
-   ⋮                    PathSegment {
-   ⋮                        ident: "foo",
-   ⋮                        arguments: None,
-   ⋮                    },
-   ⋮                    PathSegment {
-   ⋮                        ident: "self",
-   ⋮                        arguments: None,
-   ⋮                    },
-   ⋮                ],
-   ⋮            },
-   ⋮            tokens: ``,
-   ⋮        },
-   ⋮    ],
-   ⋮    vis: Inherited,
-   ⋮    ident: "S",
-   ⋮    generics: Generics,
-   ⋮    data: Data::Struct {
-   ⋮        fields: Unit,
-   ⋮        semi_token: Some,
-   ⋮    },
-   ⋮}
+    DeriveInput {
+        attrs: [
+            Attribute {
+                style: Outer,
+                path: Path {
+                    segments: [
+                        PathSegment {
+                            ident: "foo",
+                            arguments: None,
+                        },
+                        PathSegment {
+                            ident: "self",
+                            arguments: None,
+                        },
+                    ],
+                },
+                tokens: ``,
+            },
+        ],
+        vis: Inherited,
+        ident: "S",
+        generics: Generics,
+        data: Data::Struct {
+            fields: Unit,
+            semi_token: Some,
+        },
+    }
     "###);
 
     snapshot!(input.attrs[0].parse_meta().unwrap(), @r###"
-   ⋮Path(Path {
-   ⋮    segments: [
-   ⋮        PathSegment {
-   ⋮            ident: "foo",
-   ⋮            arguments: None,
-   ⋮        },
-   ⋮        PathSegment {
-   ⋮            ident: "self",
-   ⋮            arguments: None,
-   ⋮        },
-   ⋮    ],
-   ⋮})
+    Path(Path {
+        segments: [
+            PathSegment {
+                ident: "foo",
+                arguments: None,
+            },
+            PathSegment {
+                ident: "self",
+                arguments: None,
+            },
+        ],
+    })
     "###);
 }
 
@@ -496,55 +493,55 @@ fn test_pub_restricted() {
     };
 
     snapshot!(input as DeriveInput, @r###"
-   ⋮DeriveInput {
-   ⋮    vis: Visibility::Restricted {
-   ⋮        in_token: Some,
-   ⋮        path: Path {
-   ⋮            segments: [
-   ⋮                PathSegment {
-   ⋮                    ident: "m",
-   ⋮                    arguments: None,
-   ⋮                },
-   ⋮            ],
-   ⋮        },
-   ⋮    },
-   ⋮    ident: "Z",
-   ⋮    generics: Generics,
-   ⋮    data: Data::Struct {
-   ⋮        fields: Fields::Unnamed {
-   ⋮            unnamed: [
-   ⋮                Field {
-   ⋮                    vis: Visibility::Restricted {
-   ⋮                        in_token: Some,
-   ⋮                        path: Path {
-   ⋮                            segments: [
-   ⋮                                PathSegment {
-   ⋮                                    ident: "m",
-   ⋮                                    arguments: None,
-   ⋮                                },
-   ⋮                                PathSegment {
-   ⋮                                    ident: "n",
-   ⋮                                    arguments: None,
-   ⋮                                },
-   ⋮                            ],
-   ⋮                        },
-   ⋮                    },
-   ⋮                    ty: Type::Path {
-   ⋮                        path: Path {
-   ⋮                            segments: [
-   ⋮                                PathSegment {
-   ⋮                                    ident: "u8",
-   ⋮                                    arguments: None,
-   ⋮                                },
-   ⋮                            ],
-   ⋮                        },
-   ⋮                    },
-   ⋮                },
-   ⋮            ],
-   ⋮        },
-   ⋮        semi_token: Some,
-   ⋮    },
-   ⋮}
+    DeriveInput {
+        vis: Visibility::Restricted {
+            in_token: Some,
+            path: Path {
+                segments: [
+                    PathSegment {
+                        ident: "m",
+                        arguments: None,
+                    },
+                ],
+            },
+        },
+        ident: "Z",
+        generics: Generics,
+        data: Data::Struct {
+            fields: Fields::Unnamed {
+                unnamed: [
+                    Field {
+                        vis: Visibility::Restricted {
+                            in_token: Some,
+                            path: Path {
+                                segments: [
+                                    PathSegment {
+                                        ident: "m",
+                                        arguments: None,
+                                    },
+                                    PathSegment {
+                                        ident: "n",
+                                        arguments: None,
+                                    },
+                                ],
+                            },
+                        },
+                        ty: Type::Path {
+                            path: Path {
+                                segments: [
+                                    PathSegment {
+                                        ident: "u8",
+                                        arguments: None,
+                                    },
+                                ],
+                            },
+                        },
+                    },
+                ],
+            },
+            semi_token: Some,
+        },
+    }
     "###);
 }
 
@@ -555,15 +552,15 @@ fn test_vis_crate() {
     };
 
     snapshot!(input as DeriveInput, @r###"
-   ⋮DeriveInput {
-   ⋮    vis: Visibility::Crate,
-   ⋮    ident: "S",
-   ⋮    generics: Generics,
-   ⋮    data: Data::Struct {
-   ⋮        fields: Unit,
-   ⋮        semi_token: Some,
-   ⋮    },
-   ⋮}
+    DeriveInput {
+        vis: Visibility::Crate,
+        ident: "S",
+        generics: Generics,
+        data: Data::Struct {
+            fields: Unit,
+            semi_token: Some,
+        },
+    }
     "###);
 }
 
@@ -574,24 +571,24 @@ fn test_pub_restricted_crate() {
     };
 
     snapshot!(input as DeriveInput, @r###"
-   ⋮DeriveInput {
-   ⋮    vis: Visibility::Restricted {
-   ⋮        path: Path {
-   ⋮            segments: [
-   ⋮                PathSegment {
-   ⋮                    ident: "crate",
-   ⋮                    arguments: None,
-   ⋮                },
-   ⋮            ],
-   ⋮        },
-   ⋮    },
-   ⋮    ident: "S",
-   ⋮    generics: Generics,
-   ⋮    data: Data::Struct {
-   ⋮        fields: Unit,
-   ⋮        semi_token: Some,
-   ⋮    },
-   ⋮}
+    DeriveInput {
+        vis: Visibility::Restricted {
+            path: Path {
+                segments: [
+                    PathSegment {
+                        ident: "crate",
+                        arguments: None,
+                    },
+                ],
+            },
+        },
+        ident: "S",
+        generics: Generics,
+        data: Data::Struct {
+            fields: Unit,
+            semi_token: Some,
+        },
+    }
     "###);
 }
 
@@ -602,24 +599,24 @@ fn test_pub_restricted_super() {
     };
 
     snapshot!(input as DeriveInput, @r###"
-   ⋮DeriveInput {
-   ⋮    vis: Visibility::Restricted {
-   ⋮        path: Path {
-   ⋮            segments: [
-   ⋮                PathSegment {
-   ⋮                    ident: "super",
-   ⋮                    arguments: None,
-   ⋮                },
-   ⋮            ],
-   ⋮        },
-   ⋮    },
-   ⋮    ident: "S",
-   ⋮    generics: Generics,
-   ⋮    data: Data::Struct {
-   ⋮        fields: Unit,
-   ⋮        semi_token: Some,
-   ⋮    },
-   ⋮}
+    DeriveInput {
+        vis: Visibility::Restricted {
+            path: Path {
+                segments: [
+                    PathSegment {
+                        ident: "super",
+                        arguments: None,
+                    },
+                ],
+            },
+        },
+        ident: "S",
+        generics: Generics,
+        data: Data::Struct {
+            fields: Unit,
+            semi_token: Some,
+        },
+    }
     "###);
 }
 
@@ -630,25 +627,25 @@ fn test_pub_restricted_in_super() {
     };
 
     snapshot!(input as DeriveInput, @r###"
-   ⋮DeriveInput {
-   ⋮    vis: Visibility::Restricted {
-   ⋮        in_token: Some,
-   ⋮        path: Path {
-   ⋮            segments: [
-   ⋮                PathSegment {
-   ⋮                    ident: "super",
-   ⋮                    arguments: None,
-   ⋮                },
-   ⋮            ],
-   ⋮        },
-   ⋮    },
-   ⋮    ident: "S",
-   ⋮    generics: Generics,
-   ⋮    data: Data::Struct {
-   ⋮        fields: Unit,
-   ⋮        semi_token: Some,
-   ⋮    },
-   ⋮}
+    DeriveInput {
+        vis: Visibility::Restricted {
+            in_token: Some,
+            path: Path {
+                segments: [
+                    PathSegment {
+                        ident: "super",
+                        arguments: None,
+                    },
+                ],
+            },
+        },
+        ident: "S",
+        generics: Generics,
+        data: Data::Struct {
+            fields: Unit,
+            semi_token: Some,
+        },
+    }
     "###);
 }
 
@@ -659,15 +656,15 @@ fn test_fields_on_unit_struct() {
     };
 
     snapshot!(input as DeriveInput, @r###"
-   ⋮DeriveInput {
-   ⋮    vis: Inherited,
-   ⋮    ident: "S",
-   ⋮    generics: Generics,
-   ⋮    data: Data::Struct {
-   ⋮        fields: Unit,
-   ⋮        semi_token: Some,
-   ⋮    },
-   ⋮}
+    DeriveInput {
+        vis: Inherited,
+        ident: "S",
+        generics: Generics,
+        data: Data::Struct {
+            fields: Unit,
+            semi_token: Some,
+        },
+    }
     "###);
 
     let data = match input.data {
@@ -688,47 +685,47 @@ fn test_fields_on_named_struct() {
     };
 
     snapshot!(input as DeriveInput, @r###"
-   ⋮DeriveInput {
-   ⋮    vis: Inherited,
-   ⋮    ident: "S",
-   ⋮    generics: Generics,
-   ⋮    data: Data::Struct {
-   ⋮        fields: Fields::Named {
-   ⋮            named: [
-   ⋮                Field {
-   ⋮                    vis: Inherited,
-   ⋮                    ident: Some("foo"),
-   ⋮                    colon_token: Some,
-   ⋮                    ty: Type::Path {
-   ⋮                        path: Path {
-   ⋮                            segments: [
-   ⋮                                PathSegment {
-   ⋮                                    ident: "i32",
-   ⋮                                    arguments: None,
-   ⋮                                },
-   ⋮                            ],
-   ⋮                        },
-   ⋮                    },
-   ⋮                },
-   ⋮                Field {
-   ⋮                    vis: Visibility::Public,
-   ⋮                    ident: Some("bar"),
-   ⋮                    colon_token: Some,
-   ⋮                    ty: Type::Path {
-   ⋮                        path: Path {
-   ⋮                            segments: [
-   ⋮                                PathSegment {
-   ⋮                                    ident: "String",
-   ⋮                                    arguments: None,
-   ⋮                                },
-   ⋮                            ],
-   ⋮                        },
-   ⋮                    },
-   ⋮                },
-   ⋮            ],
-   ⋮        },
-   ⋮    },
-   ⋮}
+    DeriveInput {
+        vis: Inherited,
+        ident: "S",
+        generics: Generics,
+        data: Data::Struct {
+            fields: Fields::Named {
+                named: [
+                    Field {
+                        vis: Inherited,
+                        ident: Some("foo"),
+                        colon_token: Some,
+                        ty: Type::Path {
+                            path: Path {
+                                segments: [
+                                    PathSegment {
+                                        ident: "i32",
+                                        arguments: None,
+                                    },
+                                ],
+                            },
+                        },
+                    },
+                    Field {
+                        vis: Visibility::Public,
+                        ident: Some("bar"),
+                        colon_token: Some,
+                        ty: Type::Path {
+                            path: Path {
+                                segments: [
+                                    PathSegment {
+                                        ident: "String",
+                                        arguments: None,
+                                    },
+                                ],
+                            },
+                        },
+                    },
+                ],
+            },
+        },
+    }
     "###);
 
     let data = match input.data {
@@ -737,38 +734,38 @@ fn test_fields_on_named_struct() {
     };
 
     snapshot!(data.fields.into_iter().collect::<Vec<_>>(), @r###"
-   ⋮[
-   ⋮    Field {
-   ⋮        vis: Inherited,
-   ⋮        ident: Some("foo"),
-   ⋮        colon_token: Some,
-   ⋮        ty: Type::Path {
-   ⋮            path: Path {
-   ⋮                segments: [
-   ⋮                    PathSegment {
-   ⋮                        ident: "i32",
-   ⋮                        arguments: None,
-   ⋮                    },
-   ⋮                ],
-   ⋮            },
-   ⋮        },
-   ⋮    },
-   ⋮    Field {
-   ⋮        vis: Visibility::Public,
-   ⋮        ident: Some("bar"),
-   ⋮        colon_token: Some,
-   ⋮        ty: Type::Path {
-   ⋮            path: Path {
-   ⋮                segments: [
-   ⋮                    PathSegment {
-   ⋮                        ident: "String",
-   ⋮                        arguments: None,
-   ⋮                    },
-   ⋮                ],
-   ⋮            },
-   ⋮        },
-   ⋮    },
-   ⋮]
+    [
+        Field {
+            vis: Inherited,
+            ident: Some("foo"),
+            colon_token: Some,
+            ty: Type::Path {
+                path: Path {
+                    segments: [
+                        PathSegment {
+                            ident: "i32",
+                            arguments: None,
+                        },
+                    ],
+                },
+            },
+        },
+        Field {
+            vis: Visibility::Public,
+            ident: Some("bar"),
+            colon_token: Some,
+            ty: Type::Path {
+                path: Path {
+                    segments: [
+                        PathSegment {
+                            ident: "String",
+                            arguments: None,
+                        },
+                    ],
+                },
+            },
+        },
+    ]
     "###);
 }
 
@@ -779,44 +776,44 @@ fn test_fields_on_tuple_struct() {
     };
 
     snapshot!(input as DeriveInput, @r###"
-   ⋮DeriveInput {
-   ⋮    vis: Inherited,
-   ⋮    ident: "S",
-   ⋮    generics: Generics,
-   ⋮    data: Data::Struct {
-   ⋮        fields: Fields::Unnamed {
-   ⋮            unnamed: [
-   ⋮                Field {
-   ⋮                    vis: Inherited,
-   ⋮                    ty: Type::Path {
-   ⋮                        path: Path {
-   ⋮                            segments: [
-   ⋮                                PathSegment {
-   ⋮                                    ident: "i32",
-   ⋮                                    arguments: None,
-   ⋮                                },
-   ⋮                            ],
-   ⋮                        },
-   ⋮                    },
-   ⋮                },
-   ⋮                Field {
-   ⋮                    vis: Visibility::Public,
-   ⋮                    ty: Type::Path {
-   ⋮                        path: Path {
-   ⋮                            segments: [
-   ⋮                                PathSegment {
-   ⋮                                    ident: "String",
-   ⋮                                    arguments: None,
-   ⋮                                },
-   ⋮                            ],
-   ⋮                        },
-   ⋮                    },
-   ⋮                },
-   ⋮            ],
-   ⋮        },
-   ⋮        semi_token: Some,
-   ⋮    },
-   ⋮}
+    DeriveInput {
+        vis: Inherited,
+        ident: "S",
+        generics: Generics,
+        data: Data::Struct {
+            fields: Fields::Unnamed {
+                unnamed: [
+                    Field {
+                        vis: Inherited,
+                        ty: Type::Path {
+                            path: Path {
+                                segments: [
+                                    PathSegment {
+                                        ident: "i32",
+                                        arguments: None,
+                                    },
+                                ],
+                            },
+                        },
+                    },
+                    Field {
+                        vis: Visibility::Public,
+                        ty: Type::Path {
+                            path: Path {
+                                segments: [
+                                    PathSegment {
+                                        ident: "String",
+                                        arguments: None,
+                                    },
+                                ],
+                            },
+                        },
+                    },
+                ],
+            },
+            semi_token: Some,
+        },
+    }
     "###);
 
     let data = match input.data {
@@ -825,34 +822,34 @@ fn test_fields_on_tuple_struct() {
     };
 
     snapshot!(data.fields.iter().collect::<Vec<_>>(), @r###"
-   ⋮[
-   ⋮    Field {
-   ⋮        vis: Inherited,
-   ⋮        ty: Type::Path {
-   ⋮            path: Path {
-   ⋮                segments: [
-   ⋮                    PathSegment {
-   ⋮                        ident: "i32",
-   ⋮                        arguments: None,
-   ⋮                    },
-   ⋮                ],
-   ⋮            },
-   ⋮        },
-   ⋮    },
-   ⋮    Field {
-   ⋮        vis: Visibility::Public,
-   ⋮        ty: Type::Path {
-   ⋮            path: Path {
-   ⋮                segments: [
-   ⋮                    PathSegment {
-   ⋮                        ident: "String",
-   ⋮                        arguments: None,
-   ⋮                    },
-   ⋮                ],
-   ⋮            },
-   ⋮        },
-   ⋮    },
-   ⋮]
+    [
+        Field {
+            vis: Inherited,
+            ty: Type::Path {
+                path: Path {
+                    segments: [
+                        PathSegment {
+                            ident: "i32",
+                            arguments: None,
+                        },
+                    ],
+                },
+            },
+        },
+        Field {
+            vis: Visibility::Public,
+            ty: Type::Path {
+                path: Path {
+                    segments: [
+                        PathSegment {
+                            ident: "String",
+                            arguments: None,
+                        },
+                    ],
+                },
+            },
+        },
+    ]
     "###);
 }
 
@@ -864,34 +861,34 @@ fn test_ambiguous_crate() {
     };
 
     snapshot!(input as DeriveInput, @r###"
-   ⋮DeriveInput {
-   ⋮    vis: Inherited,
-   ⋮    ident: "S",
-   ⋮    generics: Generics,
-   ⋮    data: Data::Struct {
-   ⋮        fields: Fields::Unnamed {
-   ⋮            unnamed: [
-   ⋮                Field {
-   ⋮                    vis: Inherited,
-   ⋮                    ty: Type::Path {
-   ⋮                        path: Path {
-   ⋮                            segments: [
-   ⋮                                PathSegment {
-   ⋮                                    ident: "crate",
-   ⋮                                    arguments: None,
-   ⋮                                },
-   ⋮                                PathSegment {
-   ⋮                                    ident: "X",
-   ⋮                                    arguments: None,
-   ⋮                                },
-   ⋮                            ],
-   ⋮                        },
-   ⋮                    },
-   ⋮                },
-   ⋮            ],
-   ⋮        },
-   ⋮        semi_token: Some,
-   ⋮    },
-   ⋮}
+    DeriveInput {
+        vis: Inherited,
+        ident: "S",
+        generics: Generics,
+        data: Data::Struct {
+            fields: Fields::Unnamed {
+                unnamed: [
+                    Field {
+                        vis: Inherited,
+                        ty: Type::Path {
+                            path: Path {
+                                segments: [
+                                    PathSegment {
+                                        ident: "crate",
+                                        arguments: None,
+                                    },
+                                    PathSegment {
+                                        ident: "X",
+                                        arguments: None,
+                                    },
+                                ],
+                            },
+                        },
+                    },
+                ],
+            },
+            semi_token: Some,
+        },
+    }
     "###);
 }