code_ownership 2.1.4 → 2.2.1

data/ext/cargo-vendor/serde_derive-1.0.228/src/internals/ctxt.rs

@@ -1,68 +0,0 @@
-use quote::ToTokens;
-use std::cell::RefCell;
-use std::fmt::Display;
-use std::thread;
-
-/// A type to collect errors together and format them.
-///
-/// Dropping this object will cause a panic. It must be consumed using `check`.
-///
-/// References can be shared since this type uses run-time exclusive mut checking.
-#[derive(Default)]
-pub struct Ctxt {
-    // The contents will be set to `None` during checking. This is so that checking can be
-    // enforced.
-    errors: RefCell<Option<Vec<syn::Error>>>,
-}
-
-impl Ctxt {
-    /// Create a new context object.
-    ///
-    /// This object contains no errors, but will still trigger a panic if it is not `check`ed.
-    pub fn new() -> Self {
-        Ctxt {
-            errors: RefCell::new(Some(Vec::new())),
-        }
-    }
-
-    /// Add an error to the context object with a tokenenizable object.
-    ///
-    /// The object is used for spanning in error messages.
-    pub fn error_spanned_by<A: ToTokens, T: Display>(&self, obj: A, msg: T) {
-        self.errors
-            .borrow_mut()
-            .as_mut()
-            .unwrap()
-            // Curb monomorphization from generating too many identical methods.
-            .push(syn::Error::new_spanned(obj.into_token_stream(), msg));
-    }
-
-    /// Add one of Syn's parse errors.
-    pub fn syn_error(&self, err: syn::Error) {
-        self.errors.borrow_mut().as_mut().unwrap().push(err);
-    }
-
-    /// Consume this object, producing a formatted error string if there are errors.
-    pub fn check(self) -> syn::Result<()> {
-        let mut errors = self.errors.borrow_mut().take().unwrap().into_iter();
-
-        let mut combined = match errors.next() {
-            Some(first) => first,
-            None => return Ok(()),
-        };
-
-        for rest in errors {
-            combined.combine(rest);
-        }
-
-        Err(combined)
-    }
-}
-
-impl Drop for Ctxt {
-    fn drop(&mut self) {
-        if !thread::panicking() && self.errors.borrow().is_some() {
-            panic!("forgot to check for errors");
-        }
-    }
-}

data/ext/cargo-vendor/serde_derive-1.0.228/src/internals/receiver.rs

@@ -1,293 +0,0 @@
-use crate::internals::respan::respan;
-use proc_macro2::Span;
-use quote::ToTokens;
-use std::mem;
-use syn::{
-    parse_quote, Data, DeriveInput, Expr, ExprPath, GenericArgument, GenericParam, Generics, Macro,
-    Path, PathArguments, QSelf, ReturnType, Token, Type, TypeParamBound, TypePath, WherePredicate,
-};
-
-pub fn replace_receiver(input: &mut DeriveInput) {
-    let self_ty = {
-        let ident = &input.ident;
-        let ty_generics = input.generics.split_for_impl().1;
-        parse_quote!(#ident #ty_generics)
-    };
-    let mut visitor = ReplaceReceiver(&self_ty);
-    visitor.visit_generics_mut(&mut input.generics);
-    visitor.visit_data_mut(&mut input.data);
-}
-
-struct ReplaceReceiver<'a>(&'a TypePath);
-
-impl ReplaceReceiver<'_> {
-    fn self_ty(&self, span: Span) -> TypePath {
-        let tokens = self.0.to_token_stream();
-        let respanned = respan(tokens, span);
-        syn::parse2(respanned).unwrap()
-    }
-
-    fn self_to_qself(&self, qself: &mut Option<QSelf>, path: &mut Path) {
-        if path.leading_colon.is_some() || path.segments[0].ident != "Self" {
-            return;
-        }
-
-        if path.segments.len() == 1 {
-            self.self_to_expr_path(path);
-            return;
-        }
-
-        let span = path.segments[0].ident.span();
-        *qself = Some(QSelf {
-            lt_token: Token![<](span),
-            ty: Box::new(Type::Path(self.self_ty(span))),
-            position: 0,
-            as_token: None,
-            gt_token: Token![>](span),
-        });
-
-        path.leading_colon = Some(**path.segments.pairs().next().unwrap().punct().unwrap());
-
-        let segments = mem::take(&mut path.segments);
-        path.segments = segments.into_pairs().skip(1).collect();
-    }
-
-    fn self_to_expr_path(&self, path: &mut Path) {
-        let self_ty = self.self_ty(path.segments[0].ident.span());
-        let variant = mem::replace(path, self_ty.path);
-        for segment in &mut path.segments {
-            if let PathArguments::AngleBracketed(bracketed) = &mut segment.arguments {
-                if bracketed.colon2_token.is_none() && !bracketed.args.is_empty() {
-                    bracketed.colon2_token = Some(<Token![::]>::default());
-                }
-            }
-        }
-        if variant.segments.len() > 1 {
-            path.segments.push_punct(<Token![::]>::default());
-            path.segments.extend(variant.segments.into_pairs().skip(1));
-        }
-    }
-}
-
-impl ReplaceReceiver<'_> {
-    // `Self` -> `Receiver`
-    fn visit_type_mut(&mut self, ty: &mut Type) {
-        let span = if let Type::Path(node) = ty {
-            if node.qself.is_none() && node.path.is_ident("Self") {
-                node.path.segments[0].ident.span()
-            } else {
-                self.visit_type_path_mut(node);
-                return;
-            }
-        } else {
-            self.visit_type_mut_impl(ty);
-            return;
-        };
-        *ty = Type::Path(self.self_ty(span));
-    }
-
-    // `Self::Assoc` -> `<Receiver>::Assoc`
-    fn visit_type_path_mut(&mut self, ty: &mut TypePath) {
-        if ty.qself.is_none() {
-            self.self_to_qself(&mut ty.qself, &mut ty.path);
-        }
-        self.visit_type_path_mut_impl(ty);
-    }
-
-    // `Self::method` -> `<Receiver>::method`
-    fn visit_expr_path_mut(&mut self, expr: &mut ExprPath) {
-        if expr.qself.is_none() {
-            self.self_to_qself(&mut expr.qself, &mut expr.path);
-        }
-        self.visit_expr_path_mut_impl(expr);
-    }
-
-    // Everything below is simply traversing the syntax tree.
-
-    fn visit_type_mut_impl(&mut self, ty: &mut Type) {
-        match ty {
-            #![cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
-            Type::Array(ty) => {
-                self.visit_type_mut(&mut ty.elem);
-                self.visit_expr_mut(&mut ty.len);
-            }
-            Type::BareFn(ty) => {
-                for arg in &mut ty.inputs {
-                    self.visit_type_mut(&mut arg.ty);
-                }
-                self.visit_return_type_mut(&mut ty.output);
-            }
-            Type::Group(ty) => self.visit_type_mut(&mut ty.elem),
-            Type::ImplTrait(ty) => {
-                for bound in &mut ty.bounds {
-                    self.visit_type_param_bound_mut(bound);
-                }
-            }
-            Type::Macro(ty) => self.visit_macro_mut(&mut ty.mac),
-            Type::Paren(ty) => self.visit_type_mut(&mut ty.elem),
-            Type::Path(ty) => {
-                if let Some(qself) = &mut ty.qself {
-                    self.visit_type_mut(&mut qself.ty);
-                }
-                self.visit_path_mut(&mut ty.path);
-            }
-            Type::Ptr(ty) => self.visit_type_mut(&mut ty.elem),
-            Type::Reference(ty) => self.visit_type_mut(&mut ty.elem),
-            Type::Slice(ty) => self.visit_type_mut(&mut ty.elem),
-            Type::TraitObject(ty) => {
-                for bound in &mut ty.bounds {
-                    self.visit_type_param_bound_mut(bound);
-                }
-            }
-            Type::Tuple(ty) => {
-                for elem in &mut ty.elems {
-                    self.visit_type_mut(elem);
-                }
-            }
-
-            Type::Infer(_) | Type::Never(_) | Type::Verbatim(_) => {}
-
-            _ => {}
-        }
-    }
-
-    fn visit_type_path_mut_impl(&mut self, ty: &mut TypePath) {
-        if let Some(qself) = &mut ty.qself {
-            self.visit_type_mut(&mut qself.ty);
-        }
-        self.visit_path_mut(&mut ty.path);
-    }
-
-    fn visit_expr_path_mut_impl(&mut self, expr: &mut ExprPath) {
-        if let Some(qself) = &mut expr.qself {
-            self.visit_type_mut(&mut qself.ty);
-        }
-        self.visit_path_mut(&mut expr.path);
-    }
-
-    fn visit_path_mut(&mut self, path: &mut Path) {
-        for segment in &mut path.segments {
-            self.visit_path_arguments_mut(&mut segment.arguments);
-        }
-    }
-
-    fn visit_path_arguments_mut(&mut self, arguments: &mut PathArguments) {
-        match arguments {
-            PathArguments::None => {}
-            PathArguments::AngleBracketed(arguments) => {
-                for arg in &mut arguments.args {
-                    match arg {
-                        #![cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
-                        GenericArgument::Type(arg) => self.visit_type_mut(arg),
-                        GenericArgument::AssocType(arg) => self.visit_type_mut(&mut arg.ty),
-                        GenericArgument::Lifetime(_)
-                        | GenericArgument::Const(_)
-                        | GenericArgument::AssocConst(_)
-                        | GenericArgument::Constraint(_) => {}
-                        _ => {}
-                    }
-                }
-            }
-            PathArguments::Parenthesized(arguments) => {
-                for argument in &mut arguments.inputs {
-                    self.visit_type_mut(argument);
-                }
-                self.visit_return_type_mut(&mut arguments.output);
-            }
-        }
-    }
-
-    fn visit_return_type_mut(&mut self, return_type: &mut ReturnType) {
-        match return_type {
-            ReturnType::Default => {}
-            ReturnType::Type(_, output) => self.visit_type_mut(output),
-        }
-    }
-
-    fn visit_type_param_bound_mut(&mut self, bound: &mut TypeParamBound) {
-        match bound {
-            #![cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
-            TypeParamBound::Trait(bound) => self.visit_path_mut(&mut bound.path),
-            TypeParamBound::Lifetime(_)
-            | TypeParamBound::PreciseCapture(_)
-            | TypeParamBound::Verbatim(_) => {}
-            _ => {}
-        }
-    }
-
-    fn visit_generics_mut(&mut self, generics: &mut Generics) {
-        for param in &mut generics.params {
-            match param {
-                GenericParam::Type(param) => {
-                    for bound in &mut param.bounds {
-                        self.visit_type_param_bound_mut(bound);
-                    }
-                }
-                GenericParam::Lifetime(_) | GenericParam::Const(_) => {}
-            }
-        }
-        if let Some(where_clause) = &mut generics.where_clause {
-            for predicate in &mut where_clause.predicates {
-                match predicate {
-                    #![cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
-                    WherePredicate::Type(predicate) => {
-                        self.visit_type_mut(&mut predicate.bounded_ty);
-                        for bound in &mut predicate.bounds {
-                            self.visit_type_param_bound_mut(bound);
-                        }
-                    }
-                    WherePredicate::Lifetime(_) => {}
-                    _ => {}
-                }
-            }
-        }
-    }
-
-    fn visit_data_mut(&mut self, data: &mut Data) {
-        match data {
-            Data::Struct(data) => {
-                for field in &mut data.fields {
-                    self.visit_type_mut(&mut field.ty);
-                }
-            }
-            Data::Enum(data) => {
-                for variant in &mut data.variants {
-                    for field in &mut variant.fields {
-                        self.visit_type_mut(&mut field.ty);
-                    }
-                }
-            }
-            Data::Union(_) => {}
-        }
-    }
-
-    fn visit_expr_mut(&mut self, expr: &mut Expr) {
-        match expr {
-            Expr::Binary(expr) => {
-                self.visit_expr_mut(&mut expr.left);
-                self.visit_expr_mut(&mut expr.right);
-            }
-            Expr::Call(expr) => {
-                self.visit_expr_mut(&mut expr.func);
-                for arg in &mut expr.args {
-                    self.visit_expr_mut(arg);
-                }
-            }
-            Expr::Cast(expr) => {
-                self.visit_expr_mut(&mut expr.expr);
-                self.visit_type_mut(&mut expr.ty);
-            }
-            Expr::Field(expr) => self.visit_expr_mut(&mut expr.base),
-            Expr::Index(expr) => {
-                self.visit_expr_mut(&mut expr.expr);
-                self.visit_expr_mut(&mut expr.index);
-            }
-            Expr::Paren(expr) => self.visit_expr_mut(&mut expr.expr),
-            Expr::Path(expr) => self.visit_expr_path_mut(expr),
-            Expr::Unary(expr) => self.visit_expr_mut(&mut expr.expr),
-            _ => {}
-        }
-    }
-
-    fn visit_macro_mut(&mut self, _mac: &mut Macro) {}
-}

data/ext/cargo-vendor/serde_derive-1.0.228/src/lib.rs

@@ -1,127 +0,0 @@
-//! This crate provides Serde's two derive macros.
-//!
-//! ```edition2021
-//! # use serde_derive::{Deserialize, Serialize};
-//! #
-//! #[derive(Serialize, Deserialize)]
-//! # struct S;
-//! #
-//! # fn main() {}
-//! ```
-//!
-//! Please refer to [https://serde.rs/derive.html] for how to set this up.
-//!
-//! [https://serde.rs/derive.html]: https://serde.rs/derive.html
-
-#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.228")]
-#![cfg_attr(not(check_cfg), allow(unexpected_cfgs))]
-// Ignored clippy lints
-#![allow(
-    // clippy false positive: https://github.com/rust-lang/rust-clippy/issues/7054
-    clippy::branches_sharing_code,
-    clippy::cognitive_complexity,
-    // clippy bug: https://github.com/rust-lang/rust-clippy/issues/7575
-    clippy::collapsible_match,
-    clippy::derive_partial_eq_without_eq,
-    clippy::enum_variant_names,
-    // clippy bug: https://github.com/rust-lang/rust-clippy/issues/6797
-    clippy::manual_map,
-    clippy::match_like_matches_macro,
-    clippy::needless_lifetimes,
-    clippy::needless_pass_by_value,
-    clippy::too_many_arguments,
-    clippy::trivially_copy_pass_by_ref,
-    clippy::used_underscore_binding,
-    clippy::wildcard_in_or_patterns,
-    // clippy bug: https://github.com/rust-lang/rust-clippy/issues/5704
-    clippy::unnested_or_patterns,
-)]
-// Ignored clippy_pedantic lints
-#![allow(
-    clippy::cast_possible_truncation,
-    clippy::checked_conversions,
-    clippy::doc_markdown,
-    clippy::elidable_lifetime_names,
-    clippy::enum_glob_use,
-    clippy::indexing_slicing,
-    clippy::items_after_statements,
-    clippy::let_underscore_untyped,
-    clippy::manual_assert,
-    clippy::map_err_ignore,
-    clippy::match_same_arms,
-    // clippy bug: https://github.com/rust-lang/rust-clippy/issues/6984
-    clippy::match_wildcard_for_single_variants,
-    clippy::module_name_repetitions,
-    clippy::must_use_candidate,
-    clippy::similar_names,
-    clippy::single_match_else,
-    clippy::struct_excessive_bools,
-    clippy::too_many_lines,
-    clippy::uninlined_format_args,
-    clippy::unseparated_literal_suffix,
-    clippy::unused_self,
-    clippy::use_self,
-    clippy::wildcard_imports
-)]
-#![cfg_attr(all(test, exhaustive), feature(non_exhaustive_omitted_patterns_lint))]
-#![allow(unknown_lints, mismatched_lifetime_syntaxes)]
-
-extern crate proc_macro2;
-extern crate quote;
-extern crate syn;
-
-extern crate proc_macro;
-
-mod internals;
-
-use proc_macro::TokenStream;
-use proc_macro2::{Ident, Span};
-use quote::{ToTokens, TokenStreamExt as _};
-use syn::parse_macro_input;
-use syn::DeriveInput;
-
-#[macro_use]
-mod bound;
-#[macro_use]
-mod fragment;
-
-mod de;
-mod deprecated;
-mod dummy;
-mod pretend;
-mod ser;
-mod this;
-
-#[allow(non_camel_case_types)]
-struct private;
-
-impl private {
-    fn ident(&self) -> Ident {
-        Ident::new(
-            concat!("__private", env!("CARGO_PKG_VERSION_PATCH")),
-            Span::call_site(),
-        )
-    }
-}
-
-impl ToTokens for private {
-    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
-        tokens.append(self.ident());
-    }
-}
-
-#[proc_macro_derive(Serialize, attributes(serde))]
-pub fn derive_serialize(input: TokenStream) -> TokenStream {
-    let mut input = parse_macro_input!(input as DeriveInput);
-    ser::expand_derive_serialize(&mut input)
-        .unwrap_or_else(syn::Error::into_compile_error)
-        .into()
-}
-
-#[proc_macro_derive(Deserialize, attributes(serde))]
-pub fn derive_deserialize(input: TokenStream) -> TokenStream {
-    let mut input = parse_macro_input!(input as DeriveInput);
-    de::expand_derive_deserialize(&mut input)
-        .unwrap_or_else(syn::Error::into_compile_error)
-        .into()
-}

data/ext/cargo-vendor/serde_derive-1.0.228/src/pretend.rs

@@ -1,188 +0,0 @@
-use crate::internals::ast::{Container, Data, Field, Style, Variant};
-use crate::private;
-use proc_macro2::TokenStream;
-use quote::{format_ident, quote};
-
-// Suppress dead_code warnings that would otherwise appear when using a remote
-// derive. Other than this pretend code, a struct annotated with remote derive
-// never has its fields referenced and an enum annotated with remote derive
-// never has its variants constructed.
-//
-//     warning: field is never used: `i`
-//      --> src/main.rs:4:20
-//       |
-//     4 | struct StructDef { i: i32 }
-//       |                    ^^^^^^
-//
-//     warning: variant is never constructed: `V`
-//      --> src/main.rs:8:16
-//       |
-//     8 | enum EnumDef { V }
-//       |                ^
-//
-pub fn pretend_used(cont: &Container, is_packed: bool) -> TokenStream {
-    let pretend_fields = pretend_fields_used(cont, is_packed);
-    let pretend_variants = pretend_variants_used(cont);
-
-    quote! {
-        #pretend_fields
-        #pretend_variants
-    }
-}
-
-// For structs with named fields, expands to:
-//
-//     match None::<&T> {
-//         Some(T { a: __v0, b: __v1 }) => {}
-//         _ => {}
-//     }
-//
-// For packed structs on sufficiently new rustc, expands to:
-//
-//     match None::<&T> {
-//         Some(__v @ T { a: _, b: _ }) => {
-//             let _ = addr_of!(__v.a);
-//             let _ = addr_of!(__v.b);
-//         }
-//         _ => {}
-//     }
-//
-// For packed structs on older rustc, we assume Sized and !Drop, and expand to:
-//
-//     match None::<T> {
-//         Some(T { a: __v0, b: __v1 }) => {}
-//         _ => {}
-//     }
-//
-// For enums, expands to the following but only including struct variants:
-//
-//     match None::<&T> {
-//         Some(T::A { a: __v0 }) => {}
-//         Some(T::B { b: __v0 }) => {}
-//         _ => {}
-//     }
-//
-fn pretend_fields_used(cont: &Container, is_packed: bool) -> TokenStream {
-    match &cont.data {
-        Data::Enum(variants) => pretend_fields_used_enum(cont, variants),
-        Data::Struct(Style::Struct | Style::Tuple | Style::Newtype, fields) => {
-            if is_packed {
-                pretend_fields_used_struct_packed(cont, fields)
-            } else {
-                pretend_fields_used_struct(cont, fields)
-            }
-        }
-        Data::Struct(Style::Unit, _) => quote!(),
-    }
-}
-
-fn pretend_fields_used_struct(cont: &Container, fields: &[Field]) -> TokenStream {
-    let type_ident = &cont.ident;
-    let (_, ty_generics, _) = cont.generics.split_for_impl();
-
-    let members = fields.iter().map(|field| &field.member);
-    let placeholders = (0usize..).map(|i| format_ident!("__v{}", i));
-
-    quote! {
-        match _serde::#private::None::<&#type_ident #ty_generics> {
-            _serde::#private::Some(#type_ident { #(#members: #placeholders),* }) => {}
-            _ => {}
-        }
-    }
-}
-
-fn pretend_fields_used_struct_packed(cont: &Container, fields: &[Field]) -> TokenStream {
-    let type_ident = &cont.ident;
-    let (_, ty_generics, _) = cont.generics.split_for_impl();
-
-    let members = fields.iter().map(|field| &field.member).collect::<Vec<_>>();
-
-    let private2 = private;
-    quote! {
-        match _serde::#private::None::<&#type_ident #ty_generics> {
-            _serde::#private::Some(__v @ #type_ident { #(#members: _),* }) => {
-                #(
-                    let _ = _serde::#private2::ptr::addr_of!(__v.#members);
-                )*
-            }
-            _ => {}
-        }
-    }
-}
-
-fn pretend_fields_used_enum(cont: &Container, variants: &[Variant]) -> TokenStream {
-    let type_ident = &cont.ident;
-    let (_, ty_generics, _) = cont.generics.split_for_impl();
-
-    let patterns = variants
-        .iter()
-        .filter_map(|variant| match variant.style {
-            Style::Struct | Style::Tuple | Style::Newtype => {
-                let variant_ident = &variant.ident;
-                let members = variant.fields.iter().map(|field| &field.member);
-                let placeholders = (0usize..).map(|i| format_ident!("__v{}", i));
-                Some(quote!(#type_ident::#variant_ident { #(#members: #placeholders),* }))
-            }
-            Style::Unit => None,
-        })
-        .collect::<Vec<_>>();
-
-    let private2 = private;
-    quote! {
-        match _serde::#private::None::<&#type_ident #ty_generics> {
-            #(
-                _serde::#private2::Some(#patterns) => {}
-            )*
-            _ => {}
-        }
-    }
-}
-
-// Expands to one of these per enum variant:
-//
-//     match None {
-//         Some((__v0, __v1,)) => {
-//             let _ = E::V { a: __v0, b: __v1 };
-//         }
-//         _ => {}
-//     }
-//
-fn pretend_variants_used(cont: &Container) -> TokenStream {
-    let variants = match &cont.data {
-        Data::Enum(variants) => variants,
-        Data::Struct(_, _) => {
-            return quote!();
-        }
-    };
-
-    let type_ident = &cont.ident;
-    let (_, ty_generics, _) = cont.generics.split_for_impl();
-    let turbofish = ty_generics.as_turbofish();
-
-    let cases = variants.iter().map(|variant| {
-        let variant_ident = &variant.ident;
-        let placeholders = &(0..variant.fields.len())
-            .map(|i| format_ident!("__v{}", i))
-            .collect::<Vec<_>>();
-
-        let pat = match variant.style {
-            Style::Struct => {
-                let members = variant.fields.iter().map(|field| &field.member);
-                quote!({ #(#members: #placeholders),* })
-            }
-            Style::Tuple | Style::Newtype => quote!(( #(#placeholders),* )),
-            Style::Unit => quote!(),
-        };
-
-        quote! {
-            match _serde::#private::None {
-                _serde::#private::Some((#(#placeholders,)*)) => {
-                    let _ = #type_ident::#variant_ident #turbofish #pat;
-                }
-                _ => {}
-            }
-        }
-    });
-
-    quote!(#(#cases)*)
-}