Refactor of AST parsing

schemars_derive/src/ast/from_serde.rs

@@ -0,0 +1,76 @@
+use super::*;
+use crate::attr::get_with_from_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,
+            original: serde.original,
+        })
+    }
+}
+
+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 {
+            Self::SerdeType::Enum(variants) => {
+                Self::Enum(Variant::vec_from_serde(errors, variants)?)
+            }
+            Self::SerdeType::Struct(style, fields) => {
+                Self::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,
+            with: get_with_from_attrs(&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,
+            with: get_with_from_attrs(&serde.original.attrs, errors)?,
+        })
+    }
+}

schemars_derive/src/ast/mod.rs

@@ -0,0 +1,63 @@
+mod from_serde;
+
+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: &'a syn::Generics,
+    pub original: &'a syn::DeriveInput,
+}
+
+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 with: Option<syn::Type>,
+}
+
+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 with: Option<syn::Type>,
+}
+
+impl<'a> Container<'a> {
+    pub fn from_ast(item: &'a syn::DeriveInput) -> Result<Container<'a>, Vec<syn::Error>> {
+        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) -> String {
+        self.serde_attrs.name().deserialize_name()
+    }
+}
+
+impl<'a> Variant<'a> {
+    pub fn name(&self) -> String {
+        self.serde_attrs.name().deserialize_name()
+    }
+}
+
+impl<'a> Field<'a> {
+    pub fn name(&self) -> String {
+        self.serde_attrs.name().deserialize_name()
+    }
+}