Deleted vendor folder

1 files changed, 0 insertions, 397 deletions

diff --git a/vendor/syn/tests/test_ty.rs b/vendor/syn/tests/test_ty.rs
deleted file mode 100644
index 0645393..0000000
--- a/vendor/syn/tests/test_ty.rs
+++ /dev/null
@@ -1,397 +0,0 @@
-#![allow(clippy::uninlined_format_args)]
-
-#[macro_use]
-mod macros;
-
-use proc_macro2::{Delimiter, Group, Ident, Punct, Spacing, Span, TokenStream, TokenTree};
-use quote::{quote, ToTokens as _};
-use syn::punctuated::Punctuated;
-use syn::{parse_quote, token, Token, Type, TypeTuple};
-
-#[test]
-fn test_mut_self() {
-    syn::parse_str::<Type>("fn(mut self)").unwrap();
-    syn::parse_str::<Type>("fn(mut self,)").unwrap();
-    syn::parse_str::<Type>("fn(mut self: ())").unwrap();
-    syn::parse_str::<Type>("fn(mut self: ...)").unwrap_err();
-    syn::parse_str::<Type>("fn(mut self: mut self)").unwrap_err();
-    syn::parse_str::<Type>("fn(mut self::T)").unwrap_err();
-}
-
-#[test]
-fn test_macro_variable_type() {
-    // mimics the token stream corresponding to `$ty<T>`
-    let tokens = TokenStream::from_iter(vec![
-        TokenTree::Group(Group::new(Delimiter::None, quote! { ty })),
-        TokenTree::Punct(Punct::new('<', Spacing::Alone)),
-        TokenTree::Ident(Ident::new("T", Span::call_site())),
-        TokenTree::Punct(Punct::new('>', Spacing::Alone)),
-    ]);
-
-    snapshot!(tokens as Type, @r###"
-    Type::Path {
-        path: Path {
-            segments: [
-                PathSegment {
-                    ident: "ty",
-                    arguments: PathArguments::AngleBracketed {
-                        args: [
-                            GenericArgument::Type(Type::Path {
-                                path: Path {
-                                    segments: [
-                                        PathSegment {
-                                            ident: "T",
-                                        },
-                                    ],
-                                },
-                            }),
-                        ],
-                    },
-                },
-            ],
-        },
-    }
-    "###);
-
-    // mimics the token stream corresponding to `$ty::<T>`
-    let tokens = TokenStream::from_iter(vec![
-        TokenTree::Group(Group::new(Delimiter::None, quote! { ty })),
-        TokenTree::Punct(Punct::new(':', Spacing::Joint)),
-        TokenTree::Punct(Punct::new(':', Spacing::Alone)),
-        TokenTree::Punct(Punct::new('<', Spacing::Alone)),
-        TokenTree::Ident(Ident::new("T", Span::call_site())),
-        TokenTree::Punct(Punct::new('>', Spacing::Alone)),
-    ]);
-
-    snapshot!(tokens as Type, @r###"
-    Type::Path {
-        path: Path {
-            segments: [
-                PathSegment {
-                    ident: "ty",
-                    arguments: PathArguments::AngleBracketed {
-                        colon2_token: Some,
-                        args: [
-                            GenericArgument::Type(Type::Path {
-                                path: Path {
-                                    segments: [
-                                        PathSegment {
-                                            ident: "T",
-                                        },
-                                    ],
-                                },
-                            }),
-                        ],
-                    },
-                },
-            ],
-        },
-    }
-    "###);
-}
-
-#[test]
-fn test_group_angle_brackets() {
-    // mimics the token stream corresponding to `Option<$ty>`
-    let tokens = TokenStream::from_iter(vec![
-        TokenTree::Ident(Ident::new("Option", Span::call_site())),
-        TokenTree::Punct(Punct::new('<', Spacing::Alone)),
-        TokenTree::Group(Group::new(Delimiter::None, quote! { Vec<u8> })),
-        TokenTree::Punct(Punct::new('>', Spacing::Alone)),
-    ]);
-
-    snapshot!(tokens as Type, @r###"
-    Type::Path {
-        path: Path {
-            segments: [
-                PathSegment {
-                    ident: "Option",
-                    arguments: PathArguments::AngleBracketed {
-                        args: [
-                            GenericArgument::Type(Type::Group {
-                                elem: Type::Path {
-                                    path: Path {
-                                        segments: [
-                                            PathSegment {
-                                                ident: "Vec",
-                                                arguments: PathArguments::AngleBracketed {
-                                                    args: [
-                                                        GenericArgument::Type(Type::Path {
-                                                            path: Path {
-                                                                segments: [
-                                                                    PathSegment {
-                                                                        ident: "u8",
-                                                                    },
-                                                                ],
-                                                            },
-                                                        }),
-                                                    ],
-                                                },
-                                            },
-                                        ],
-                                    },
-                                },
-                            }),
-                        ],
-                    },
-                },
-            ],
-        },
-    }
-    "###);
-}
-
-#[test]
-fn test_group_colons() {
-    // mimics the token stream corresponding to `$ty::Item`
-    let tokens = TokenStream::from_iter(vec![
-        TokenTree::Group(Group::new(Delimiter::None, quote! { Vec<u8> })),
-        TokenTree::Punct(Punct::new(':', Spacing::Joint)),
-        TokenTree::Punct(Punct::new(':', Spacing::Alone)),
-        TokenTree::Ident(Ident::new("Item", Span::call_site())),
-    ]);
-
-    snapshot!(tokens as Type, @r###"
-    Type::Path {
-        path: Path {
-            segments: [
-                PathSegment {
-                    ident: "Vec",
-                    arguments: PathArguments::AngleBracketed {
-                        args: [
-                            GenericArgument::Type(Type::Path {
-                                path: Path {
-                                    segments: [
-                                        PathSegment {
-                                            ident: "u8",
-                                        },
-                                    ],
-                                },
-                            }),
-                        ],
-                    },
-                },
-                Token![::],
-                PathSegment {
-                    ident: "Item",
-                },
-            ],
-        },
-    }
-    "###);
-
-    let tokens = TokenStream::from_iter(vec![
-        TokenTree::Group(Group::new(Delimiter::None, quote! { [T] })),
-        TokenTree::Punct(Punct::new(':', Spacing::Joint)),
-        TokenTree::Punct(Punct::new(':', Spacing::Alone)),
-        TokenTree::Ident(Ident::new("Element", Span::call_site())),
-    ]);
-
-    snapshot!(tokens as Type, @r###"
-    Type::Path {
-        qself: Some(QSelf {
-            ty: Type::Slice {
-                elem: Type::Path {
-                    path: Path {
-                        segments: [
-                            PathSegment {
-                                ident: "T",
-                            },
-                        ],
-                    },
-                },
-            },
-            position: 0,
-        }),
-        path: Path {
-            leading_colon: Some,
-            segments: [
-                PathSegment {
-                    ident: "Element",
-                },
-            ],
-        },
-    }
-    "###);
-}
-
-#[test]
-fn test_trait_object() {
-    let tokens = quote!(dyn for<'a> Trait<'a> + 'static);
-    snapshot!(tokens as Type, @r###"
-    Type::TraitObject {
-        dyn_token: Some,
-        bounds: [
-            TypeParamBound::Trait(TraitBound {
-                lifetimes: Some(BoundLifetimes {
-                    lifetimes: [
-                        GenericParam::Lifetime(LifetimeParam {
-                            lifetime: Lifetime {
-                                ident: "a",
-                            },
-                        }),
-                    ],
-                }),
-                path: Path {
-                    segments: [
-                        PathSegment {
-                            ident: "Trait",
-                            arguments: PathArguments::AngleBracketed {
-                                args: [
-                                    GenericArgument::Lifetime(Lifetime {
-                                        ident: "a",
-                                    }),
-                                ],
-                            },
-                        },
-                    ],
-                },
-            }),
-            Token![+],
-            TypeParamBound::Lifetime {
-                ident: "static",
-            },
-        ],
-    }
-    "###);
-
-    let tokens = quote!(dyn 'a + Trait);
-    snapshot!(tokens as Type, @r###"
-    Type::TraitObject {
-        dyn_token: Some,
-        bounds: [
-            TypeParamBound::Lifetime {
-                ident: "a",
-            },
-            Token![+],
-            TypeParamBound::Trait(TraitBound {
-                path: Path {
-                    segments: [
-                        PathSegment {
-                            ident: "Trait",
-                        },
-                    ],
-                },
-            }),
-        ],
-    }
-    "###);
-
-    // None of the following are valid Rust types.
-    syn::parse_str::<Type>("for<'a> dyn Trait<'a>").unwrap_err();
-    syn::parse_str::<Type>("dyn for<'a> 'a + Trait").unwrap_err();
-}
-
-#[test]
-fn test_trailing_plus() {
-    #[rustfmt::skip]
-    let tokens = quote!(impl Trait +);
-    snapshot!(tokens as Type, @r###"
-    Type::ImplTrait {
-        bounds: [
-            TypeParamBound::Trait(TraitBound {
-                path: Path {
-                    segments: [
-                        PathSegment {
-                            ident: "Trait",
-                        },
-                    ],
-                },
-            }),
-            Token![+],
-        ],
-    }
-    "###);
-
-    #[rustfmt::skip]
-    let tokens = quote!(dyn Trait +);
-    snapshot!(tokens as Type, @r###"
-    Type::TraitObject {
-        dyn_token: Some,
-        bounds: [
-            TypeParamBound::Trait(TraitBound {
-                path: Path {
-                    segments: [
-                        PathSegment {
-                            ident: "Trait",
-                        },
-                    ],
-                },
-            }),
-            Token![+],
-        ],
-    }
-    "###);
-
-    #[rustfmt::skip]
-    let tokens = quote!(Trait +);
-    snapshot!(tokens as Type, @r###"
-    Type::TraitObject {
-        bounds: [
-            TypeParamBound::Trait(TraitBound {
-                path: Path {
-                    segments: [
-                        PathSegment {
-                            ident: "Trait",
-                        },
-                    ],
-                },
-            }),
-            Token![+],
-        ],
-    }
-    "###);
-}
-
-#[test]
-fn test_tuple_comma() {
-    let mut expr = TypeTuple {
-        paren_token: token::Paren::default(),
-        elems: Punctuated::new(),
-    };
-    snapshot!(expr.to_token_stream() as Type, @"Type::Tuple");
-
-    expr.elems.push_value(parse_quote!(_));
-    // Must not parse to Type::Paren
-    snapshot!(expr.to_token_stream() as Type, @r###"
-    Type::Tuple {
-        elems: [
-            Type::Infer,
-            Token![,],
-        ],
-    }
-    "###);
-
-    expr.elems.push_punct(<Token![,]>::default());
-    snapshot!(expr.to_token_stream() as Type, @r###"
-    Type::Tuple {
-        elems: [
-            Type::Infer,
-            Token![,],
-        ],
-    }
-    "###);
-
-    expr.elems.push_value(parse_quote!(_));
-    snapshot!(expr.to_token_stream() as Type, @r###"
-    Type::Tuple {
-        elems: [
-            Type::Infer,
-            Token![,],
-            Type::Infer,
-        ],
-    }
-    "###);
-
-    expr.elems.push_punct(<Token![,]>::default());
-    snapshot!(expr.to_token_stream() as Type, @r###"
-    Type::Tuple {
-        elems: [
-            Type::Infer,
-            Token![,],
-            Type::Infer,
-            Token![,],
-        ],
-    }
-    "###);
-}