chore: checkpoint before Python removal

vendor/schemars_derive/src/ast/from_serde.rs

@@ -0,0 +1,79 @@
+use super::*;
+use crate::attr::Attrs;
+use serde_derive_internals::ast as serde_ast;
+use serde_derive_internals::Ctxt;
+
+pub trait FromSerde: Sized {
+    type SerdeType;
+
+    fn from_serde(errors: &Ctxt, serde: Self::SerdeType) -> Result<Self, ()>;
+
+    fn vec_from_serde(errors: &Ctxt, serdes: Vec<Self::SerdeType>) -> Result<Vec<Self>, ()> {
+        let mut result = Vec::with_capacity(serdes.len());
+        for s in serdes {
+            result.push(Self::from_serde(errors, s)?)
+        }
+        Ok(result)
+    }
+}
+
+impl<'a> FromSerde for Container<'a> {
+    type SerdeType = serde_ast::Container<'a>;
+
+    fn from_serde(errors: &Ctxt, serde: Self::SerdeType) -> Result<Self, ()> {
+        Ok(Self {
+            ident: serde.ident,
+            serde_attrs: serde.attrs,
+            data: Data::from_serde(errors, serde.data)?,
+            generics: serde.generics.clone(),
+            original: serde.original,
+            // FIXME this allows with/schema_with attribute on containers
+            attrs: Attrs::new(&serde.original.attrs, errors),
+        })
+    }
+}
+
+impl<'a> FromSerde for Data<'a> {
+    type SerdeType = serde_ast::Data<'a>;
+
+    fn from_serde(errors: &Ctxt, serde: Self::SerdeType) -> Result<Self, ()> {
+        Ok(match serde {
+            serde_ast::Data::Enum(variants) => {
+                Data::Enum(Variant::vec_from_serde(errors, variants)?)
+            }
+            serde_ast::Data::Struct(style, fields) => {
+                Data::Struct(style, Field::vec_from_serde(errors, fields)?)
+            }
+        })
+    }
+}
+
+impl<'a> FromSerde for Variant<'a> {
+    type SerdeType = serde_ast::Variant<'a>;
+
+    fn from_serde(errors: &Ctxt, serde: Self::SerdeType) -> Result<Self, ()> {
+        Ok(Self {
+            ident: serde.ident,
+            serde_attrs: serde.attrs,
+            style: serde.style,
+            fields: Field::vec_from_serde(errors, serde.fields)?,
+            original: serde.original,
+            attrs: Attrs::new(&serde.original.attrs, errors),
+        })
+    }
+}
+
+impl<'a> FromSerde for Field<'a> {
+    type SerdeType = serde_ast::Field<'a>;
+
+    fn from_serde(errors: &Ctxt, serde: Self::SerdeType) -> Result<Self, ()> {
+        Ok(Self {
+            member: serde.member,
+            serde_attrs: serde.attrs,
+            ty: serde.ty,
+            original: serde.original,
+            attrs: Attrs::new(&serde.original.attrs, errors),
+            validation_attrs: ValidationAttrs::new(&serde.original.attrs, errors),
+        })
+    }
+}

vendor/schemars_derive/src/ast/mod.rs

@@ -0,0 +1,80 @@
+mod from_serde;
+
+use crate::attr::{Attrs, ValidationAttrs};
+use from_serde::FromSerde;
+use serde_derive_internals::ast as serde_ast;
+use serde_derive_internals::{Ctxt, Derive};
+
+pub struct Container<'a> {
+    pub ident: syn::Ident,
+    pub serde_attrs: serde_derive_internals::attr::Container,
+    pub data: Data<'a>,
+    pub generics: syn::Generics,
+    pub original: &'a syn::DeriveInput,
+    pub attrs: Attrs,
+}
+
+pub enum Data<'a> {
+    Enum(Vec<Variant<'a>>),
+    Struct(serde_ast::Style, Vec<Field<'a>>),
+}
+
+pub struct Variant<'a> {
+    pub ident: syn::Ident,
+    pub serde_attrs: serde_derive_internals::attr::Variant,
+    pub style: serde_ast::Style,
+    pub fields: Vec<Field<'a>>,
+    pub original: &'a syn::Variant,
+    pub attrs: Attrs,
+}
+
+pub struct Field<'a> {
+    pub member: syn::Member,
+    pub serde_attrs: serde_derive_internals::attr::Field,
+    pub ty: &'a syn::Type,
+    pub original: &'a syn::Field,
+    pub attrs: Attrs,
+    pub validation_attrs: ValidationAttrs,
+}
+
+impl<'a> Container<'a> {
+    pub fn from_ast(item: &'a syn::DeriveInput) -> syn::Result<Container<'a>> {
+        let ctxt = Ctxt::new();
+        let result = serde_ast::Container::from_ast(&ctxt, item, Derive::Deserialize)
+            .ok_or(())
+            .and_then(|serde| Self::from_serde(&ctxt, serde));
+
+        ctxt.check()
+            .map(|_| result.expect("from_ast set no errors on Ctxt, so should have returned Ok"))
+    }
+
+    pub fn name(&self) -> &str {
+        self.serde_attrs.name().deserialize_name()
+    }
+
+    pub fn transparent_field(&'a self) -> Option<&'a Field> {
+        if self.serde_attrs.transparent() {
+            if let Data::Struct(_, fields) = &self.data {
+                return Some(&fields[0]);
+            }
+        }
+
+        None
+    }
+}
+
+impl<'a> Variant<'a> {
+    pub fn name(&self) -> &str {
+        self.serde_attrs.name().deserialize_name()
+    }
+
+    pub fn is_unit(&self) -> bool {
+        matches!(self.style, serde_ast::Style::Unit)
+    }
+}
+
+impl<'a> Field<'a> {
+    pub fn name(&self) -> &str {
+        self.serde_attrs.name().deserialize_name()
+    }
+}