use crate::{
generate::{
BuilderStruct, OverrideStruct, VariantField,
util::{self, AppendDoc, Doc, Document},
},
parse::{self, IdentPool, OriginStruct},
};
use proc_macro2::TokenStream;
use quote::{ToTokens, format_ident, quote};
use std::rc::Rc;
use syn::{Ident, parse_quote, Type};
#[derive(Debug, Copy, Clone)]
pub(crate) struct ConfigVariant;
#[cfg_attr(feature = "syn-debug", derive(Debug))]
#[derive(Clone)]
pub(crate) struct ConfigStruct {
fields: Vec<ConfigField>,
origin: Rc<OriginStruct>,
override_struct: Rc<OverrideStruct>,
builder_struct: Rc<BuilderStruct>,
}
impl ConfigStruct {
pub(crate) fn new(origin: Rc<OriginStruct>, override_struct: Rc<OverrideStruct>, builder_struct: Rc<BuilderStruct>) -> Self {
let fields = origin.fields
.iter().cloned()
.map(ConfigField::new)
.collect();
Self {
fields,
origin,
override_struct,
builder_struct,
}
}
pub(crate) fn ids(&self) -> &IdentPool {
self.origin.ids()
}
pub(crate) fn ident(&self) -> &Rc<Ident> {
self.ids().origin_ident()
}
}
impl ConfigStruct {
fn new_fn_tokens(&self) -> TokenStream {
let mut params = Vec::new();
let mut fields = Vec::new();
if self.override_struct.has_required_fields() {
let override_ty = self.override_struct.ty();
params.push(quote!(override_conf: #override_ty));
}
for field in &self.fields {
let ident = &field.ident();
let assign =
if field.attrs().override_required {
let mut inner = quote!(override_conf.#ident.clone());
if let Some(ref _mapped_ty) = field.attrs().override_from {
if let Some(ref mapped_via) = field.attrs().override_via {
inner = quote!(<#mapped_via>::from(#inner));
}
inner = quote!(#inner.into());
}
if field.origin.is_optional() {
inner = quote!(Some(#inner));
}
inner
}
else if field.origin.is_required() {
params.push(field.origin.as_fn_param_tokens());
ident.to_token_stream()
}
else {
field.origin.default().unwrap().to_token_stream()
};
let cfg_attrs = field.cfg_tokens();
fields.push(quote! {
#cfg_attrs
#ident: #assign
});
}
quote! {
#[must_use]
#[allow(clippy::redundant_field_names)]
pub(crate) fn new(#(#params),*) -> Self {
Self {
#(#fields),*
}
}
}
}
fn builder_fn_tokens(&self) -> TokenStream {
let mut params = Vec::new();
let mut idents = Vec::new();
if self.override_struct.has_required_fields() {
let override_ty = self.override_struct.ty();
params.push(quote!(override_conf: #override_ty));
idents.push(quote!(override_conf));
}
for field in &self.origin.fields {
if !field.attrs.override_required && field.is_required() {
params.push(field.as_fn_param_tokens());
let ident = &field.ident;
let cfg_attrs = field.passthrough_attrs().cfg_tokens();
idents.push(quote! {
#cfg_attrs
#ident
});
}
}
let builder_ty = self.builder_struct.ty();
quote! {
#[must_use]
pub fn builder(#(#params),*) -> #builder_ty {
<#builder_ty>::new(#(#idents),*)
}
}
}
fn getter_fns_tokens(&self) -> TokenStream {
self.fields
.iter()
.filter(|f| !f.attrs().skip_config_getter())
.map(ConfigField::getter_tokens)
.collect()
}
fn merge_fn_tokens(&self) -> TokenStream {
let override_ty = &self.override_struct.ty();
let conf_var_ident = format_ident!("override_conf");
let fields: Vec<_> = self.fields
.iter()
.filter(|f| !f.attrs().skip_override_field())
.map(|f| f.merge_override_tokens(&conf_var_ident))
.collect();
quote! {
pub fn merge_with_override(&mut self, #conf_var_ident: #override_ty) {
#(#fields)*
}
}
}
fn impl_tokens(&self) -> TokenStream {
let ident = self.ident();
let cfg_attrs = self.origin.cfg_tokens();
let doc_cfg_attrs = self.origin.doc_cfg_tokens();
let new_fn = self.new_fn_tokens();
let builder_fn = self.builder_fn_tokens();
let getter_fns = self.getter_fns_tokens();
let merge_fns = self.merge_fn_tokens();
let (
impl_generics,
ty_generics,
where_clause,
) = self.origin.generics.split_for_impl();
quote! {
#cfg_attrs
#doc_cfg_attrs
#[automatically_derived]
impl #impl_generics #ident #ty_generics #where_clause {
#new_fn
#builder_fn
#getter_fns
#merge_fns
}
}
}
fn default_impl_tokens(&self) -> TokenStream {
let cfg_attrs = self.origin.cfg_tokens();
let doc_cfg_attrs = self.origin.doc_cfg_tokens();
util::bare_default_impl_tokens(self.ident(), &self.origin.generics, &cfg_attrs, &doc_cfg_attrs)
}
fn add_impl_tokens(&self) -> TokenStream {
let ident = self.ident();
let cfg_attrs = self.origin.cfg_tokens();
let doc_cfg_attrs = self.origin.doc_cfg_tokens();
let override_ty = &self.override_struct.ty();
let (
impl_generics,
ty_generics,
where_clause,
) = self.origin.generics.split_for_impl();
quote! {
#cfg_attrs
#doc_cfg_attrs
#[automatically_derived]
impl #impl_generics ::std::ops::Add<#override_ty> for #ident #ty_generics #where_clause {
type Output = Self;
fn add(self, other: #override_ty) -> Self {
let mut merged = self;
merged.merge_with_override(other);
merged
}
}
}
}
}
impl ToTokens for ConfigStruct {
fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
tokens.extend(self.impl_tokens());
if !self.override_struct.has_required_fields()
&& !self.origin.has_required_fields() {
tokens.extend(self.default_impl_tokens());
}
tokens.extend(self.add_impl_tokens());
}
}
pub(crate) type ConfigField = VariantField<ConfigVariant>;
impl ConfigField {
fn getter_ret_ty(&self) -> Type {
if self.attrs().copy {
return self.origin.ty.clone();
}
let ty = &self.origin.ty;
if let Some(inner_ty) = parse::util::unwrap_option(ty) {
if parse::util::is_string(inner_ty) {
parse_quote!(Option<&str>)
} else {
parse_quote!(Option<&#inner_ty>)
}
} else {
if parse::util::is_string(ty) {
parse_quote!(&str)
} else {
parse_quote!(&#ty)
}
}
}
fn getter_ret_expr(&self) -> TokenStream {
let ident = self.ident();
let inner = quote!(self.#ident);
if self.attrs().copy {
return inner;
}
let ty = &self.origin.ty;
if let Some(inner_ty) = parse::util::unwrap_option(ty) {
if parse::util::is_string(inner_ty) {
quote!(#inner.as_ref().map(|s| s.as_str()))
} else {
quote!(#inner.as_ref())
}
} else {
if parse::util::is_string(ty) {
quote!(#inner.as_str())
} else {
quote!(&#inner)
}
}
}
}
impl ConfigField {
}
impl ConfigField {
pub(crate) fn getter_docs(&self) -> AppendDoc {
self.append_docs()
+ Doc::new().separator()
+ self.doc_default_val()
}
}
impl ConfigField {
pub(super) fn getter_tokens(&self) -> TokenStream {
let ident = self.ident();
let docs = self.getter_docs();
let ty = self.getter_ret_ty();
let ret = self.getter_ret_expr();
let cfg_attrs = self.cfg_tokens();
let doc_cfg_attrs = self.doc_cfg_tokens();
quote! {
#docs
#cfg_attrs
#doc_cfg_attrs
#[must_use]
pub fn #ident(&self) -> #ty {
#ret
}
}
}
pub(super) fn merge_override_tokens(&self, override_var_ident: &Ident) -> TokenStream {
let ident = self.ident();
let temp_assign = quote!(let val = #override_var_ident.#ident.clone(););
let mut assign = if let Some(_from_ty) = &self.attrs().override_from {
let mut inner = quote!(val);
if let Some(via_ty) = &self.attrs().override_via {
inner = quote!(<#via_ty>::from(#inner));
}
quote!(#inner.into())
} else {
quote!(val)
};
if self.origin.is_option {
assign = quote!(Some(#assign));
}
let unsetter = self.origin.unset_ident().map(|unset_ident| {
let default = self.origin.default().unwrap();
quote! {
if #override_var_ident.#unset_ident {
self.#ident = #default
} else
}
});
let mut setter = quote! {
{
self.#ident = #assign;
}
};
if !self.attrs().override_required {
setter = quote! {
if let Some(val) = val #setter
}
}
let cfg_attrs = self.origin.passthrough_attrs().cfg_tokens();
quote! {
#cfg_attrs
{
#temp_assign
#unsetter
#setter
}
}
}
}