/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at
https://mozilla.org/MPL/2.0/. */
use darling::util::Override;
use crate::cg;
use proc_macro2::{Span, TokenStream};
use quote::{ToTokens, TokenStreamExt};
use syn::{self, Data, Ident, Path, WhereClause};
use synstructure::{BindingInfo, Structure, VariantInfo};
fn derive_bitflags(input: &syn::DeriveInput, bitflags: &CssBitflagAttrs) -> TokenStream {
let name = &input.ident;
let mut body = TokenStream::new();
for (rust_name, css_name) in bitflags.single_flags() {
let rust_ident = Ident::new(&rust_name, Span::call_site());
body.append_all(quote! {
if *self == Self::#rust_ident {
return dest.write_str(#css_name);
}
});
}
body.append_all(quote! {
let mut has_any = false;
});
if bitflags.overlapping_bits {
body.append_all(quote! {
let mut serialized = Self::empty();
});
}
for (rust_name, css_name) in bitflags.mixed_flags() {
let rust_ident = Ident::new(&rust_name, Span::call_site());
let serialize = quote! {
if has_any {
dest.write_char(' ')?;
}
has_any = true;
dest.write_str(#css_name)?;
};
if bitflags.overlapping_bits {
body.append_all(quote! {
if self.contains(Self::#rust_ident) && !serialized.intersects(Self::#rust_ident) {
#serialize
serialized.insert(Self::#rust_ident);
}
});
} else {
body.append_all(quote! {
if self.intersects(Self::#rust_ident) {
#serialize
}
});
}
}
body.append_all(quote! {
Ok(())
});
quote! {
impl style_traits::ToCss for #name {
#[allow(unused_variables)]
#[inline]
fn to_css<W>(
&self,
dest: &mut style_traits::CssWriter<W>,
) -> std::fmt::Result
where
W: std::fmt::Write,
{
#body
}
}
}
}
pub fn derive(mut input: syn::DeriveInput) -> TokenStream {
let mut where_clause = input.generics.where_clause.take();
for param in input.generics.type_params() {
cg::add_predicate(&mut where_clause, parse_quote!(#param: style_traits::ToCss));
}
let input_attrs = cg::parse_input_attrs::<CssInputAttrs>(&input);
if matches!(input.data, Data::Enum(..)) || input_attrs.bitflags.is_some() {
assert!(
input_attrs.function.is_none(),
"#[css(function)] is not allowed on enums or bitflags"
);
assert!(
!input_attrs.comma,
"#[css(comma)] is not allowed on enums or bitflags"
);
}
if let Some(ref bitflags) = input_attrs.bitflags {
assert!(
!input_attrs.derive_debug,
"Bitflags can derive debug on their own"
);
assert!(where_clause.is_none(), "Generic bitflags?");
return derive_bitflags(&input, bitflags);
}
let match_body = {
let s = Structure::new(&input);
s.each_variant(|variant| derive_variant_arm(variant, &mut where_clause))
};
input.generics.where_clause = where_clause;
let name = &input.ident;
let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
let mut impls = quote! {
impl #impl_generics style_traits::ToCss for #name #ty_generics #where_clause {
#[allow(unused_variables)]
#[inline]
fn to_css<W>(
&self,
dest: &mut style_traits::CssWriter<W>,
) -> std::fmt::Result
where
W: std::fmt::Write,
{
match *self {
#match_body
}
}
}
};
if input_attrs.derive_debug {
impls.append_all(quote! {
impl #impl_generics std::fmt::Debug for #name #ty_generics #where_clause {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
style_traits::ToCss::to_css(
self,
&mut style_traits::CssWriter::new(f),
)
}
}
});
}
impls
}
fn derive_variant_arm(variant: &VariantInfo, generics: &mut Option<WhereClause>) -> TokenStream {
let bindings = variant.bindings();
let identifier = cg::to_css_identifier(&variant.ast().ident.to_string());
let ast = variant.ast();
let variant_attrs = cg::parse_variant_attrs_from_ast::<CssVariantAttrs>(&ast);
let separator = if variant_attrs.comma { ", " } else { " " };
if variant_attrs.skip {
return quote!(Ok(()));
}
if variant_attrs.dimension {
assert_eq!(bindings.len(), 1);
assert!(
variant_attrs.function.is_none() && variant_attrs.keyword.is_none(),
"That makes no sense"
);
}
let mut expr = if let Some(keyword) = variant_attrs.keyword {
assert!(bindings.is_empty());
quote! {
std::fmt::Write::write_str(dest, #keyword)
}
} else if !bindings.is_empty() {
derive_variant_fields_expr(bindings, generics, separator)
} else {
quote! {
std::fmt::Write::write_str(dest, #identifier)
}
};
if variant_attrs.dimension {
expr = quote! {
#expr?;
std::fmt::Write::write_str(dest, #identifier)
}
} else if let Some(function) = variant_attrs.function {
let mut identifier = function.explicit().map_or(identifier, |name| name);
identifier.push('(');
expr = quote! {
std::fmt::Write::write_str(dest, #identifier)?;
#expr?;
std::fmt::Write::write_str(dest, ")")
}
}
expr
}
fn derive_variant_fields_expr(
bindings: &[BindingInfo],
where_clause: &mut Option<WhereClause>,
separator: &str,
) -> TokenStream {
let mut iter = bindings
.iter()
.filter_map(|binding| {
let attrs = cg::parse_field_attrs::<CssFieldAttrs>(&binding.ast());
if attrs.skip {
return None;
}
Some((binding, attrs))
})
.peekable();
let (first, attrs) = match iter.next() {
Some(pair) => pair,
None => return quote! { Ok(()) },
};
if attrs.field_bound {
let ty = &first.ast().ty;
// TODO(emilio): IntoIterator might not be enough for every type of
// iterable thing (like ArcSlice<> or what not). We might want to expose
// an `item = "T"` attribute to handle that in the future.
let predicate = if attrs.iterable {
parse_quote!(<#ty as IntoIterator>::Item: style_traits::ToCss)
} else {
parse_quote!(#ty: style_traits::ToCss)
};
cg::add_predicate(where_clause, predicate);
}
if !attrs.iterable && iter.peek().is_none() {
let mut expr = quote! { style_traits::ToCss::to_css(#first, dest) };
if let Some(condition) = attrs.skip_if {
expr = quote! {
if !#condition(#first) {
#expr
}
}
}
if let Some(condition) = attrs.contextual_skip_if {
expr = quote! {
if !#condition(#(#bindings), *) {
#expr
}
}
}
return expr;
}
let mut expr = derive_single_field_expr(first, attrs, where_clause, bindings);
for (binding, attrs) in iter {
derive_single_field_expr(binding, attrs, where_clause, bindings).to_tokens(&mut exp
r)
}
quote! {{
let mut writer = style_traits::values::SequenceWriter::new(dest, #separator);
#expr
Ok(())
}}
}
fn derive_single_field_expr(
field: &BindingInfo,
attrs: CssFieldAttrs,
where_clause: &mut Option<WhereClause>,
bindings: &[BindingInfo],
) -> TokenStream {
let mut expr = if attrs.iterable {
if let Some(if_empty) = attrs.if_empty {
return quote! {
{
let mut iter = #field.iter().peekable();
if iter.peek().is_none() {
writer.raw_item(#if_empty)?;
} else {
for item in iter {
writer.item(&item)?;
}
}
}
};
}
quote! {
for item in #field.iter() {
writer.item(&item)?;
}
}
} else if attrs.represents_keyword {
let ident = field
.ast()
.ident
.as_ref()
.expect("Unnamed field with represents_keyword?");
let ident = cg::to_css_identifier(&ident.to_string()).replace("_", "-");
quote! {
if *#field {
writer.raw_item(#ident)?;
}
}
} else {
if attrs.field_bound {
let ty = &field.ast().ty;
cg::add_predicate(where_clause, parse_quote!(#ty: style_traits::ToCss));
}
quote! { writer.item(#field)?; }
};
if let Some(condition) = attrs.skip_if {
expr = quote! {
if !#condition(#field) {
#expr
}
}
}
if let Some(condition) = attrs.contextual_skip_if {
expr = quote! {
if !#condition(#(#bindings), *) {
#expr
}
}
}
expr
}
#[derive(Default, FromMeta)]
#[darling(default)]
pub struct CssBitflagAttrs {
/// Flags that can only go on their own, comma-separated.
pub single: Option<String>,
/// Flags that can go mixed with each other, comma-separated.
pub mixed: Option<String>,
/// Extra validation of the resulting mixed flags.
pub validate_mixed: Option<Path>,
/// Whether there are overlapping bits we need to take care of when
/// serializing.
pub overlapping_bits: bool,
}
impl CssBitflagAttrs {
/// Returns a vector of (rust_name, css_name) of a given flag list.
fn names(s: &Option<String>) -> Vec<(String, String)> {
let s = match s {
Some(s) => s,
None => return vec![],
};
s.split(',')
.map(|css_name| (cg::to_scream_case(css_name), css_name.to_owned()))
.collect()
}
pub fn single_flags(&self) -> Vec<(String, String)> {
Self::names(&self.single)
}
pub fn mixed_flags(&self) -> Vec<(String, String)> {
Self::names(&self.mixed)
}
}
#[derive(Default, FromDeriveInput)]
#[darling(attributes(css), default)]
pub struct CssInputAttrs {
pub derive_debug: bool,
// Here because structs variants are also their whole type definition.
pub function: Option<Override<String>>,
// Here because structs variants are also their whole type definition.
pub comma: bool,
pub bitflags: Option<CssBitflagAttrs>,
}
#[derive(Default, FromVariant)]
#[darling(attributes(css), default)]
pub struct CssVariantAttrs {
pub function: Option<Override<String>>,
// Here because structs variants are also their whole type definition.
pub derive_debug: bool,
pub comma: bool,
pub bitflags: Option<CssBitflagAttrs>,
pub dimension: bool,
pub keyword: Option<String>,
pub skip: bool,
}
#[derive(Default, FromField)]
#[darling(attributes(css), default)]
pub struct CssFieldAttrs {
pub if_empty: Option<String>,
pub field_bound: bool,
pub iterable: bool,
pub skip: bool,
pub represents_keyword: bool,
pub contextual_skip_if: Option<Path>,
pub skip_if: Option<Path>,
}
