Deleted vendor folder

1 files changed, 0 insertions, 452 deletions

diff --git a/vendor/syn/src/stmt.rs b/vendor/syn/src/stmt.rs
deleted file mode 100644
index b6d0664..0000000
--- a/vendor/syn/src/stmt.rs
+++ /dev/null
@@ -1,452 +0,0 @@
-use super::*;
-
-ast_struct! {
-    /// A braced block containing Rust statements.
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct Block {
-        pub brace_token: token::Brace,
-        /// Statements in a block
-        pub stmts: Vec<Stmt>,
-    }
-}
-
-ast_enum! {
-    /// A statement, usually ending in a semicolon.
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub enum Stmt {
-        /// A local (let) binding.
-        Local(Local),
-
-        /// An item definition.
-        Item(Item),
-
-        /// Expression, with or without trailing semicolon.
-        Expr(Expr, Option<Token![;]>),
-
-        /// A macro invocation in statement position.
-        ///
-        /// Syntactically it's ambiguous which other kind of statement this
-        /// macro would expand to. It can be any of local variable (`let`),
-        /// item, or expression.
-        Macro(StmtMacro),
-    }
-}
-
-ast_struct! {
-    /// A local `let` binding: `let x: u64 = s.parse()?`.
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct Local {
-        pub attrs: Vec<Attribute>,
-        pub let_token: Token![let],
-        pub pat: Pat,
-        pub init: Option<LocalInit>,
-        pub semi_token: Token![;],
-    }
-}
-
-ast_struct! {
-    /// The expression assigned in a local `let` binding, including optional
-    /// diverging `else` block.
-    ///
-    /// `LocalInit` represents `= s.parse()?` in `let x: u64 = s.parse()?` and
-    /// `= r else { return }` in `let Ok(x) = r else { return }`.
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct LocalInit {
-        pub eq_token: Token![=],
-        pub expr: Box<Expr>,
-        pub diverge: Option<(Token![else], Box<Expr>)>,
-    }
-}
-
-ast_struct! {
-    /// A macro invocation in statement position.
-    ///
-    /// Syntactically it's ambiguous which other kind of statement this macro
-    /// would expand to. It can be any of local variable (`let`), item, or
-    /// expression.
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
-    pub struct StmtMacro {
-        pub attrs: Vec<Attribute>,
-        pub mac: Macro,
-        pub semi_token: Option<Token![;]>,
-    }
-}
-
-#[cfg(feature = "parsing")]
-pub(crate) mod parsing {
-    use super::*;
-    use crate::parse::discouraged::Speculative as _;
-    use crate::parse::{Parse, ParseStream, Result};
-    use proc_macro2::TokenStream;
-
-    struct AllowNoSemi(bool);
-
-    impl Block {
-        /// Parse the body of a block as zero or more statements, possibly
-        /// including one trailing expression.
-        ///
-        /// # Example
-        ///
-        /// ```
-        /// use syn::{braced, token, Attribute, Block, Ident, Result, Stmt, Token};
-        /// use syn::parse::{Parse, ParseStream};
-        ///
-        /// // Parse a function with no generics or parameter list.
-        /// //
-        /// //     fn playground {
-        /// //         let mut x = 1;
-        /// //         x += 1;
-        /// //         println!("{}", x);
-        /// //     }
-        /// struct MiniFunction {
-        ///     attrs: Vec<Attribute>,
-        ///     fn_token: Token![fn],
-        ///     name: Ident,
-        ///     brace_token: token::Brace,
-        ///     stmts: Vec<Stmt>,
-        /// }
-        ///
-        /// impl Parse for MiniFunction {
-        ///     fn parse(input: ParseStream) -> Result<Self> {
-        ///         let outer_attrs = input.call(Attribute::parse_outer)?;
-        ///         let fn_token: Token![fn] = input.parse()?;
-        ///         let name: Ident = input.parse()?;
-        ///
-        ///         let content;
-        ///         let brace_token = braced!(content in input);
-        ///         let inner_attrs = content.call(Attribute::parse_inner)?;
-        ///         let stmts = content.call(Block::parse_within)?;
-        ///
-        ///         Ok(MiniFunction {
-        ///             attrs: {
-        ///                 let mut attrs = outer_attrs;
-        ///                 attrs.extend(inner_attrs);
-        ///                 attrs
-        ///             },
-        ///             fn_token,
-        ///             name,
-        ///             brace_token,
-        ///             stmts,
-        ///         })
-        ///     }
-        /// }
-        /// ```
-        #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-        pub fn parse_within(input: ParseStream) -> Result<Vec<Stmt>> {
-            let mut stmts = Vec::new();
-            loop {
-                while let semi @ Some(_) = input.parse()? {
-                    stmts.push(Stmt::Expr(Expr::Verbatim(TokenStream::new()), semi));
-                }
-                if input.is_empty() {
-                    break;
-                }
-                let stmt = parse_stmt(input, AllowNoSemi(true))?;
-                let requires_semicolon = match &stmt {
-                    Stmt::Expr(stmt, None) => expr::requires_terminator(stmt),
-                    Stmt::Macro(stmt) => {
-                        stmt.semi_token.is_none() && !stmt.mac.delimiter.is_brace()
-                    }
-                    Stmt::Local(_) | Stmt::Item(_) | Stmt::Expr(_, Some(_)) => false,
-                };
-                stmts.push(stmt);
-                if input.is_empty() {
-                    break;
-                } else if requires_semicolon {
-                    return Err(input.error("unexpected token, expected `;`"));
-                }
-            }
-            Ok(stmts)
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for Block {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let content;
-            Ok(Block {
-                brace_token: braced!(content in input),
-                stmts: content.call(Block::parse_within)?,
-            })
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
-    impl Parse for Stmt {
-        fn parse(input: ParseStream) -> Result<Self> {
-            let allow_nosemi = AllowNoSemi(false);
-            parse_stmt(input, allow_nosemi)
-        }
-    }
-
-    fn parse_stmt(input: ParseStream, allow_nosemi: AllowNoSemi) -> Result<Stmt> {
-        let begin = input.fork();
-        let attrs = input.call(Attribute::parse_outer)?;
-
-        // brace-style macros; paren and bracket macros get parsed as
-        // expression statements.
-        let ahead = input.fork();
-        let mut is_item_macro = false;
-        if let Ok(path) = ahead.call(Path::parse_mod_style) {
-            if ahead.peek(Token![!]) {
-                if ahead.peek2(Ident) || ahead.peek2(Token![try]) {
-                    is_item_macro = true;
-                } else if ahead.peek2(token::Brace)
-                    && !(ahead.peek3(Token![.]) || ahead.peek3(Token![?]))
-                {
-                    input.advance_to(&ahead);
-                    return stmt_mac(input, attrs, path).map(Stmt::Macro);
-                }
-            }
-        }
-
-        if input.peek(Token![let]) && !input.peek(token::Group) {
-            stmt_local(input, attrs).map(Stmt::Local)
-        } else if input.peek(Token![pub])
-            || input.peek(Token![crate]) && !input.peek2(Token![::])
-            || input.peek(Token![extern])
-            || input.peek(Token![use])
-            || input.peek(Token![static])
-                && (input.peek2(Token![mut])
-                    || input.peek2(Ident)
-                        && !(input.peek2(Token![async])
-                            && (input.peek3(Token![move]) || input.peek3(Token![|]))))
-            || input.peek(Token![const])
-                && !(input.peek2(token::Brace)
-                    || input.peek2(Token![static])
-                    || input.peek2(Token![async])
-                        && !(input.peek3(Token![unsafe])
-                            || input.peek3(Token![extern])
-                            || input.peek3(Token![fn]))
-                    || input.peek2(Token![move])
-                    || input.peek2(Token![|]))
-            || input.peek(Token![unsafe]) && !input.peek2(token::Brace)
-            || input.peek(Token![async])
-                && (input.peek2(Token![unsafe])
-                    || input.peek2(Token![extern])
-                    || input.peek2(Token![fn]))
-            || input.peek(Token![fn])
-            || input.peek(Token![mod])
-            || input.peek(Token![type])
-            || input.peek(Token![struct])
-            || input.peek(Token![enum])
-            || input.peek(Token![union]) && input.peek2(Ident)
-            || input.peek(Token![auto]) && input.peek2(Token![trait])
-            || input.peek(Token![trait])
-            || input.peek(Token![default])
-                && (input.peek2(Token![unsafe]) || input.peek2(Token![impl]))
-            || input.peek(Token![impl])
-            || input.peek(Token![macro])
-            || is_item_macro
-        {
-            let item = item::parsing::parse_rest_of_item(begin, attrs, input)?;
-            Ok(Stmt::Item(item))
-        } else {
-            stmt_expr(input, allow_nosemi, attrs)
-        }
-    }
-
-    fn stmt_mac(input: ParseStream, attrs: Vec<Attribute>, path: Path) -> Result<StmtMacro> {
-        let bang_token: Token![!] = input.parse()?;
-        let (delimiter, tokens) = mac::parse_delimiter(input)?;
-        let semi_token: Option<Token![;]> = input.parse()?;
-
-        Ok(StmtMacro {
-            attrs,
-            mac: Macro {
-                path,
-                bang_token,
-                delimiter,
-                tokens,
-            },
-            semi_token,
-        })
-    }
-
-    fn stmt_local(input: ParseStream, attrs: Vec<Attribute>) -> Result<Local> {
-        let let_token: Token![let] = input.parse()?;
-
-        let mut pat = Pat::parse_single(input)?;
-        if input.peek(Token![:]) {
-            let colon_token: Token![:] = input.parse()?;
-            let ty: Type = input.parse()?;
-            pat = Pat::Type(PatType {
-                attrs: Vec::new(),
-                pat: Box::new(pat),
-                colon_token,
-                ty: Box::new(ty),
-            });
-        }
-
-        let init = if let Some(eq_token) = input.parse()? {
-            let eq_token: Token![=] = eq_token;
-            let expr: Expr = input.parse()?;
-
-            let diverge = if let Some(else_token) = input.parse()? {
-                let else_token: Token![else] = else_token;
-                let diverge = ExprBlock {
-                    attrs: Vec::new(),
-                    label: None,
-                    block: input.parse()?,
-                };
-                Some((else_token, Box::new(Expr::Block(diverge))))
-            } else {
-                None
-            };
-
-            Some(LocalInit {
-                eq_token,
-                expr: Box::new(expr),
-                diverge,
-            })
-        } else {
-            None
-        };
-
-        let semi_token: Token![;] = input.parse()?;
-
-        Ok(Local {
-            attrs,
-            let_token,
-            pat,
-            init,
-            semi_token,
-        })
-    }
-
-    fn stmt_expr(
-        input: ParseStream,
-        allow_nosemi: AllowNoSemi,
-        mut attrs: Vec<Attribute>,
-    ) -> Result<Stmt> {
-        let mut e = expr::parsing::expr_early(input)?;
-
-        let mut attr_target = &mut e;
-        loop {
-            attr_target = match attr_target {
-                Expr::Assign(e) => &mut e.left,
-                Expr::Binary(e) => &mut e.left,
-                Expr::Cast(e) => &mut e.expr,
-                Expr::Array(_)
-                | Expr::Async(_)
-                | Expr::Await(_)
-                | Expr::Block(_)
-                | Expr::Break(_)
-                | Expr::Call(_)
-                | Expr::Closure(_)
-                | Expr::Const(_)
-                | Expr::Continue(_)
-                | Expr::Field(_)
-                | Expr::ForLoop(_)
-                | Expr::Group(_)
-                | Expr::If(_)
-                | Expr::Index(_)
-                | Expr::Infer(_)
-                | Expr::Let(_)
-                | Expr::Lit(_)
-                | Expr::Loop(_)
-                | Expr::Macro(_)
-                | Expr::Match(_)
-                | Expr::MethodCall(_)
-                | Expr::Paren(_)
-                | Expr::Path(_)
-                | Expr::Range(_)
-                | Expr::Reference(_)
-                | Expr::Repeat(_)
-                | Expr::Return(_)
-                | Expr::Struct(_)
-                | Expr::Try(_)
-                | Expr::TryBlock(_)
-                | Expr::Tuple(_)
-                | Expr::Unary(_)
-                | Expr::Unsafe(_)
-                | Expr::While(_)
-                | Expr::Yield(_)
-                | Expr::Verbatim(_) => break,
-            };
-        }
-        attrs.extend(attr_target.replace_attrs(Vec::new()));
-        attr_target.replace_attrs(attrs);
-
-        let semi_token: Option<Token![;]> = input.parse()?;
-
-        match e {
-            Expr::Macro(ExprMacro { attrs, mac })
-                if semi_token.is_some() || mac.delimiter.is_brace() =>
-            {
-                return Ok(Stmt::Macro(StmtMacro {
-                    attrs,
-                    mac,
-                    semi_token,
-                }));
-            }
-            _ => {}
-        }
-
-        if semi_token.is_some() {
-            Ok(Stmt::Expr(e, semi_token))
-        } else if allow_nosemi.0 || !expr::requires_terminator(&e) {
-            Ok(Stmt::Expr(e, None))
-        } else {
-            Err(input.error("expected semicolon"))
-        }
-    }
-}
-
-#[cfg(feature = "printing")]
-mod printing {
-    use super::*;
-    use proc_macro2::TokenStream;
-    use quote::{ToTokens, TokenStreamExt};
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for Block {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            self.brace_token.surround(tokens, |tokens| {
-                tokens.append_all(&self.stmts);
-            });
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for Stmt {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            match self {
-                Stmt::Local(local) => local.to_tokens(tokens),
-                Stmt::Item(item) => item.to_tokens(tokens),
-                Stmt::Expr(expr, semi) => {
-                    expr.to_tokens(tokens);
-                    semi.to_tokens(tokens);
-                }
-                Stmt::Macro(mac) => mac.to_tokens(tokens),
-            }
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for Local {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            expr::printing::outer_attrs_to_tokens(&self.attrs, tokens);
-            self.let_token.to_tokens(tokens);
-            self.pat.to_tokens(tokens);
-            if let Some(init) = &self.init {
-                init.eq_token.to_tokens(tokens);
-                init.expr.to_tokens(tokens);
-                if let Some((else_token, diverge)) = &init.diverge {
-                    else_token.to_tokens(tokens);
-                    diverge.to_tokens(tokens);
-                }
-            }
-            self.semi_token.to_tokens(tokens);
-        }
-    }
-
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
-    impl ToTokens for StmtMacro {
-        fn to_tokens(&self, tokens: &mut TokenStream) {
-            expr::printing::outer_attrs_to_tokens(&self.attrs, tokens);
-            self.mac.to_tokens(tokens);
-            self.semi_token.to_tokens(tokens);
-        }
-    }
-}