From 26a029d407be480d791972afb5975cf62c9360a6 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Fri, 19 Apr 2024 02:47:55 +0200 Subject: Adding upstream version 124.0.1. Signed-off-by: Daniel Baumann --- servo/components/style_derive/to_css.rs | 396 ++++++++++++++++++++++++++++++++ 1 file changed, 396 insertions(+) create mode 100644 servo/components/style_derive/to_css.rs (limited to 'servo/components/style_derive/to_css.rs') diff --git a/servo/components/style_derive/to_css.rs b/servo/components/style_derive/to_css.rs new file mode 100644 index 0000000000..aa33536648 --- /dev/null +++ b/servo/components/style_derive/to_css.rs @@ -0,0 +1,396 @@ +/* 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 derive_common::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( + &self, + dest: &mut style_traits::CssWriter, + ) -> 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::(&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( + &self, + dest: &mut style_traits::CssWriter, + ) -> 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) -> 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::(&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, + separator: &str, +) -> TokenStream { + let mut iter = bindings + .iter() + .filter_map(|binding| { + let attrs = cg::parse_field_attrs::(&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 expr) + } + + 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, + 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, + /// Flags that can go mixed with each other, comma-separated. + pub mixed: Option, + /// Extra validation of the resulting mixed flags. + pub validate_mixed: Option, + /// 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) -> 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>, + // Here because structs variants are also their whole type definition. + pub comma: bool, + pub bitflags: Option, +} + +#[derive(Default, FromVariant)] +#[darling(attributes(css), default)] +pub struct CssVariantAttrs { + pub function: Option>, + // Here because structs variants are also their whole type definition. + pub derive_debug: bool, + pub comma: bool, + pub bitflags: Option, + pub dimension: bool, + pub keyword: Option, + pub skip: bool, +} + +#[derive(Default, FromField)] +#[darling(attributes(css), default)] +pub struct CssFieldAttrs { + pub if_empty: Option, + pub field_bound: bool, + pub iterable: bool, + pub skip: bool, + pub represents_keyword: bool, + pub contextual_skip_if: Option, + pub skip_if: Option, +} -- cgit v1.2.3