From ba12a344c6f08d29bc5d35626d66d8daef65738e Mon Sep 17 00:00:00 2001 From: Anthony Ramine Date: Sun, 11 Mar 2018 14:53:33 +0100 Subject: [PATCH] Opt out of bounds on type params for #[derive(ToAnimatedZero)] --- components/style/values/generics/svg.rs | 1 + components/style_derive/cg.rs | 141 +------------------- components/style_derive/lib.rs | 2 +- components/style_derive/to_animated_zero.rs | 42 +++--- 4 files changed, 29 insertions(+), 157 deletions(-) diff --git a/components/style/values/generics/svg.rs b/components/style/values/generics/svg.rs index e6c24bfaf8e..83f1790056c 100644 --- a/components/style/values/generics/svg.rs +++ b/components/style/values/generics/svg.rs @@ -35,6 +35,7 @@ pub struct SVGPaint { #[derive(Animate, Clone, ComputeSquaredDistance, Debug, MallocSizeOf, PartialEq)] #[derive(ToAnimatedValue, ToAnimatedZero, ToComputedValue, ToCss)] #[distance(no_bound(UrlPaintServer))] +#[zero(no_bound(UrlPaintServer))] pub enum SVGPaintKind { /// `none` #[animation(error)] diff --git a/components/style_derive/cg.rs b/components/style_derive/cg.rs index 694973103ce..ff391c79180 100644 --- a/components/style_derive/cg.rs +++ b/components/style_derive/cg.rs @@ -3,83 +3,14 @@ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ use darling::{FromDeriveInput, FromField, FromVariant}; -use quote::{ToTokens, Tokens}; -use std::collections::HashSet; +use quote::Tokens; use syn::{self, AngleBracketedGenericArguments, Binding, DeriveInput, Field}; -use syn::{GenericArgument, GenericParam, Ident, ImplGenerics, Path}; -use syn::{PathArguments, PathSegment, QSelf, Type, TypeArray, TypeGenerics}; +use syn::{GenericArgument, GenericParam, Ident, Path}; +use syn::{PathArguments, PathSegment, QSelf, Type, TypeArray}; use syn::{TypeParam, TypeParen, TypePath, TypeSlice, TypeTuple}; use syn::{Variant, WherePredicate}; -use syn::visit::{self, Visit}; use synstructure::{self, BindingInfo, BindStyle, VariantAst, VariantInfo}; -pub struct WhereClause<'input, 'path> { - pub inner: Option, - pub params: Vec<&'input TypeParam>, - trait_path: &'path Path, - trait_output: Option, - bounded_types: HashSet, -} - -impl<'input, 'path> ToTokens for WhereClause<'input, 'path> { - fn to_tokens(&self, tokens: &mut Tokens) { - self.inner.to_tokens(tokens); - } -} - -impl<'input, 'path> WhereClause<'input, 'path> { - pub fn add_trait_bound(&mut self, ty: &Type) { - let trait_path = self.trait_path; - let mut found = self.trait_output.map(|_| HashSet::new()); - if self.bounded_types.contains(&ty) { - return; - } - if !is_parameterized(&ty, &self.params, found.as_mut()) { - return; - } - self.bounded_types.insert(ty.clone()); - - let output = if let Some(output) = self.trait_output { - output - } else { - add_predicate(&mut self.inner, where_predicate(ty.clone(), trait_path, None)); - return; - }; - - if let Type::Path(syn::TypePath { ref path, .. }) = *ty { - if path_to_ident(path).is_some() { - add_predicate(&mut self.inner, where_predicate(ty.clone(), trait_path, None)); - return; - } - } - - let output_type = map_type_params(ty, &self.params, &mut |ident| { - parse_quote!(<#ident as ::#trait_path>::#output) - }); - - let pred = where_predicate( - ty.clone(), - trait_path, - Some((output, output_type)), - ); - - add_predicate(&mut self.inner, pred); - - if let Some(found) = found { - for ident in found { - let ty = Type::Path(syn::TypePath { qself: None, path: ident.into() }); - if !self.bounded_types.contains(&ty) { - self.bounded_types.insert(ty.clone()); - add_predicate( - &mut self.inner, - where_predicate(ty, trait_path, None), - ); - }; - } - } - } -} - pub fn add_predicate( where_clause: &mut Option, pred: WherePredicate, @@ -139,36 +70,6 @@ pub fn fmap_trait_output( segment.into() } -pub fn is_parameterized( - ty: &Type, - params: &[&TypeParam], - found: Option<&mut HashSet>, -) -> bool { - struct IsParameterized<'a, 'b> { - params: &'a [&'a TypeParam], - has_free: bool, - found: Option<&'b mut HashSet>, - } - - impl<'a, 'b, 'ast> Visit<'ast> for IsParameterized<'a, 'b> { - fn visit_path(&mut self, path: &'ast Path) { - if let Some(ident) = path_to_ident(path) { - if self.params.iter().any(|param| param.ident == ident) { - self.has_free = true; - if let Some(ref mut found) = self.found { - found.insert(ident.clone()); - } - } - } - visit::visit_path(self, path); - } - } - - let mut visitor = IsParameterized { params, has_free: false, found }; - visitor.visit_type(ty); - visitor.has_free -} - pub fn map_type_params(ty: &Type, params: &[&TypeParam], f: &mut F) -> Type where F: FnMut(&Ident) -> Type, @@ -314,33 +215,6 @@ pub fn ref_pattern<'a>( (v.pat(), v.bindings().iter().cloned().collect()) } -pub fn trait_parts<'input, 'path>( - input: &'input DeriveInput, - trait_path: &'path Path, -) -> (ImplGenerics<'input>, TypeGenerics<'input>, WhereClause<'input, 'path>) { - let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl(); - let where_clause = WhereClause { - inner: where_clause.cloned(), - params: input.generics.type_params().into_iter().collect::>(), - trait_path, - trait_output: None, - bounded_types: HashSet::new() - }; - (impl_generics, ty_generics, where_clause) -} - -fn trait_ref(path: &Path, output: Option<(Ident, Type)>) -> Path { - let segments = path.segments.iter().collect::>(); - let (name, parent) = segments.split_last().unwrap(); - - let last_segment: PathSegment = if let Some((param, ty)) = output { - parse_quote!(#name<#param = #ty>) - } else { - parse_quote!(#name) - }; - parse_quote!(::#(#parent::)*#last_segment) -} - pub fn value<'a>( variant: &'a VariantInfo, prefix: &str, @@ -351,15 +225,6 @@ pub fn value<'a>( (v.pat(), v.bindings().iter().cloned().collect()) } -pub fn where_predicate( - bounded_ty: Type, - trait_path: &Path, - trait_output: Option<(Ident, Type)>, -) -> WherePredicate { - let trait_ref = trait_ref(trait_path, trait_output); - parse_quote!(#bounded_ty: #trait_ref) -} - /// Transforms "FooBar" to "foo-bar". /// /// If the first Camel segment is "Moz", "Webkit", or "Servo", the result string diff --git a/components/style_derive/lib.rs b/components/style_derive/lib.rs index e414a3bd3f2..e9d799fe9a9 100644 --- a/components/style_derive/lib.rs +++ b/components/style_derive/lib.rs @@ -45,7 +45,7 @@ pub fn derive_parse(stream: TokenStream) -> TokenStream { parse::derive(input).into() } -#[proc_macro_derive(ToAnimatedZero, attributes(animation))] +#[proc_macro_derive(ToAnimatedZero, attributes(animation, zero))] pub fn derive_to_animated_zero(stream: TokenStream) -> TokenStream { let input = syn::parse(stream).unwrap(); to_animated_zero::derive(input).into() diff --git a/components/style_derive/to_animated_zero.rs b/components/style_derive/to_animated_zero.rs index 8094e46874d..53194280240 100644 --- a/components/style_derive/to_animated_zero.rs +++ b/components/style_derive/to_animated_zero.rs @@ -4,18 +4,25 @@ use animate::{AnimationVariantAttrs, AnimationFieldAttrs}; use cg; +use darling::util::IdentList; use quote; use syn; use synstructure; -pub fn derive(input: syn::DeriveInput) -> quote::Tokens { - let name = &input.ident; - let trait_path = parse_quote!(values::animated::ToAnimatedZero); - let (impl_generics, ty_generics, mut where_clause) = - cg::trait_parts(&input, &trait_path); +pub fn derive(mut input: syn::DeriveInput) -> quote::Tokens { + let input_attrs = cg::parse_input_attrs::(&input); + let no_bound = input_attrs.no_bound.unwrap_or_default(); + let mut where_clause = input.generics.where_clause.take(); + for param in input.generics.type_params() { + if !no_bound.contains(¶m.ident) { + cg::add_predicate( + &mut where_clause, + parse_quote!(#param: ::values::animated::ToAnimatedZero), + ); + } + } - let s = synstructure::Structure::new(&input); - let to_body = s.each_variant(|variant| { + let to_body = synstructure::Structure::new(&input).each_variant(|variant| { let attrs = cg::parse_variant_attrs::(&variant.ast()); if attrs.error { return Some(quote! { Err(()) }); @@ -26,21 +33,10 @@ pub fn derive(input: syn::DeriveInput) -> quote::Tokens { computations.append_all(bindings_pairs.map(|(binding, mapped_binding)| { let field_attrs = cg::parse_field_attrs::(&binding.ast()); if field_attrs.constant { - if cg::is_parameterized(&binding.ast().ty, &where_clause.params, None) { - cg::add_predicate( - &mut where_clause.inner, - cg::where_predicate( - binding.ast().ty.clone(), - &parse_quote!(std::clone::Clone), - None, - ), - ); - } quote! { let #mapped_binding = ::std::clone::Clone::clone(#binding); } } else { - where_clause.add_trait_bound(&binding.ast().ty); quote! { let #mapped_binding = ::values::animated::ToAnimatedZero::to_animated_zero(#binding)?; @@ -50,6 +46,10 @@ pub fn derive(input: syn::DeriveInput) -> quote::Tokens { computations.append_all(quote! { Ok(#mapped) }); Some(computations) }); + input.generics.where_clause = where_clause; + + let name = &input.ident; + let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl(); quote! { impl #impl_generics ::values::animated::ToAnimatedZero for #name #ty_generics #where_clause { @@ -63,3 +63,9 @@ pub fn derive(input: syn::DeriveInput) -> quote::Tokens { } } } + +#[darling(attributes(zero), default)] +#[derive(Default, FromDeriveInput)] +struct ZeroInputAttrs { + no_bound: Option, +}