Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-08-03 12:40:06 +01:00
Code Issues Projects Releases Packages Wiki Activity

Auto merge of #20258 - servo:derive-all-the-things, r=emilio

Browse source 
Continue to improve style_derive

<!-- Reviewable:start -->
This change is [<img src="https://reviewable.io/review_button.svg" height="34" align="absmiddle" alt="Reviewable"/>](https://reviewable.io/reviews/servo/servo/20258)
<!-- Reviewable:end -->
This commit is contained in:
bors-servo 2018-03-09 17:29:05 -05:00 • committed by GitHub
commit 909ebff184
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
8 changed files with 80 additions and 84 deletions
Download patch file Download diff file Expand all files Collapse all files

3
components/style/values/computed/mod.rs
View file

@ -293,8 +293,7 @@ impl<'a, 'cx, 'cx_a: 'cx, S: ToComputedValue + 'a> Iterator for ComputedVecIter<
///
/// This trait is derivable with `#[derive(ToComputedValue)]`. The derived
/// implementation just calls `ToComputedValue::to_computed_value` on each field
/// of the passed value, or `Clone::clone` if the field is annotated with
/// `#[compute(clone)]`. The deriving code assumes that if the type isn't
/// of the passed value. The deriving code assumes that if the type isn't
/// generic, then the trait can be implemented as simple `Clone::clone` calls,
/// this means that a manual implementation with `ComputedValue = Self` is bogus
/// if it returns anything else than a clone.

2
components/style/values/computed/percentage.rs
View file

@ -11,7 +11,7 @@ use values::{CSSFloat, serialize_percentage};
/// A computed percentage.
#[cfg_attr(feature = "servo", derive(Deserialize, Serialize))]
#[derive(Animate, Clone, ComputeSquaredDistance, Copy, Debug, Default, MallocSizeOf)]
#[derive(PartialEq, PartialOrd, ToAnimatedZero)]
#[derive(PartialEq, PartialOrd, ToAnimatedZero, ToComputedValue)]
pub struct Percentage(pub CSSFloat);
impl Percentage {

3
components/style/values/generics/grid.rs
View file

@ -388,7 +388,6 @@ pub struct TrackRepeat<L, I> {
/// If there's no `<line-names>`, then it's represented by an empty vector.
/// For N `<track-size>` values, there will be N+1 `<line-names>`, and so this vector's
/// length is always one value more than that of the `<track-size>`.
#[compute(clone)]
pub line_names: Box<[Box<[CustomIdent]>]>,
/// `<track-size>` values.
pub track_sizes: Vec<TrackSize<L>>,
@ -667,7 +666,7 @@ pub enum GridTemplateComponent<L, I> {
/// `none` value.
None,
/// The grid `<track-list>`
TrackList(TrackList<L, I>),
TrackList(#[compute(field_bound)] TrackList<L, I>),
/// A `subgrid <line-name-list>?`
Subgrid(LineNameList),
}

2
components/style/values/generics/image.rs
View file

@ -42,10 +42,8 @@ pub struct Gradient<LineDirection, Length, LengthOrPercentage, Position, Color,
/// The color stops and interpolation hints.
pub items: Vec<GradientItem<Color, LengthOrPercentage>>,
/// True if this is a repeating gradient.
#[compute(clone)]
pub repeating: bool,
/// Compatibility mode.
#[compute(clone)]
pub compat_mode: CompatMode,
}

5
components/style/values/generics/transform.rs
View file

@ -247,7 +247,6 @@ pub enum TransformOperation<Angle, Number, Length, Integer, LengthOrPercentage>
#[allow(missing_docs)]
#[css(comma, function = "interpolatematrix")]
InterpolateMatrix {
#[compute(ignore_bound)]
from_list: Transform<
TransformOperation<
Angle,
@ -257,7 +256,6 @@ pub enum TransformOperation<Angle, Number, Length, Integer, LengthOrPercentage>
LengthOrPercentage,
>,
>,
#[compute(ignore_bound)]
to_list: Transform<
TransformOperation<
Angle,
@ -267,14 +265,12 @@ pub enum TransformOperation<Angle, Number, Length, Integer, LengthOrPercentage>
LengthOrPercentage,
>,
>,
#[compute(clone)]
progress: computed::Percentage,
},
/// A intermediate type for accumulation of mismatched transform lists.
#[allow(missing_docs)]
#[css(comma, function = "accumulatematrix")]
AccumulateMatrix {
#[compute(ignore_bound)]
from_list: Transform<
TransformOperation<
Angle,
@ -284,7 +280,6 @@ pub enum TransformOperation<Angle, Number, Length, Integer, LengthOrPercentage>
LengthOrPercentage,
>,
>,
#[compute(ignore_bound)]
to_list: Transform<
TransformOperation<
Angle,

29
components/style_derive/cg.rs
View file

@ -54,8 +54,7 @@ impl<'input, 'path> WhereClause<'input, 'path> {
}
let output_type = map_type_params(ty, &self.params, &mut |ident| {
let ty = Type::Path(syn::TypePath { qself: None, path: ident.clone().into() });
fmap_output_type(ty, trait_path, output)
parse_quote!(<#ident as ::#trait_path>::#output)
});
let pred = where_predicate(
@ -111,22 +110,12 @@ where
})
}
fn fmap_output_type(
ty: Type,
pub fn fmap_trait_output(
input: &DeriveInput,
trait_path: &Path,
trait_output: Ident,
) -> Type {
parse_quote!(<#ty as ::#trait_path>::#trait_output)
}
pub fn fmap_trait_parts<'input, 'path>(
input: &'input DeriveInput,
trait_path: &'path Path,
trait_output: Ident,
) -> (ImplGenerics<'input>, TypeGenerics<'input>, WhereClause<'input, 'path>, Path) {
let (impl_generics, ty_generics, mut where_clause) = trait_parts(input, trait_path);
where_clause.trait_output = Some(trait_output);
let output_ty = PathSegment {
) -> Path {
let segment = PathSegment {
ident: input.ident.clone(),
arguments: PathArguments::AngleBracketed(AngleBracketedGenericArguments {
args: input.generics.params.iter().map(|arg| {
@ -135,11 +124,7 @@ pub fn fmap_trait_parts<'input, 'path>(
&GenericParam::Type(ref data) => {
let ident = data.ident;
GenericArgument::Type(
fmap_output_type(
parse_quote!(#ident),
trait_path,
trait_output
)
parse_quote!(<#ident as ::#trait_path>::#trait_output),
)
},
ref arg => panic!("arguments {:?} cannot be mapped yet", arg)
@ -151,7 +136,7 @@ pub fn fmap_trait_parts<'input, 'path>(
})
};
(impl_generics, ty_generics, where_clause, output_ty.into())
segment.into()
}
pub fn is_parameterized(

25
components/style_derive/to_animated_value.rs
View file

@ -4,23 +4,34 @@
use cg;
use quote;
use syn::{self, Ident};
use syn::DeriveInput;
use synstructure::BindStyle;
pub fn derive(input: syn::DeriveInput) -> quote::Tokens {
let name = &input.ident;
let trait_path = parse_quote!(values::animated::ToAnimatedValue);
let (impl_generics, ty_generics, mut where_clause, animated_value_type) =
cg::fmap_trait_parts(&input, &trait_path, Ident::from("AnimatedValue"));
pub fn derive(mut input: DeriveInput) -> quote::Tokens {
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: ::values::animated::ToAnimatedValue),
);
}
let to_body = cg::fmap_match(&input, BindStyle::Move, |binding| {
where_clause.add_trait_bound(&binding.ast().ty);
quote!(::values::animated::ToAnimatedValue::to_animated_value(#binding))
});
let from_body = cg::fmap_match(&input, BindStyle::Move, |binding| {
quote!(::values::animated::ToAnimatedValue::from_animated_value(#binding))
});
input.generics.where_clause = where_clause;
let name = &input.ident;
let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
let animated_value_type = cg::fmap_trait_output(
&input,
&parse_quote!(values::animated::ToAnimatedValue),
"AnimatedValue".into(),
);
quote! {
impl #impl_generics ::values::animated::ToAnimatedValue for #name #ty_generics #where_clause {
type AnimatedValue = #animated_value_type;

95
components/style_derive/to_computed_value.rs
View file

@ -4,21 +4,59 @@
use cg;
use quote::Tokens;
use syn::{Ident, DeriveInput};
use syn::DeriveInput;
use synstructure::BindStyle;
pub fn derive(input: DeriveInput) -> Tokens {
let name = &input.ident;
let trait_path = parse_quote!(values::computed::ToComputedValue);
let (impl_generics, ty_generics, mut where_clause, computed_value_type) =
cg::fmap_trait_parts(&input, &trait_path, Ident::from("ComputedValue"));
pub fn derive(mut input: DeriveInput) -> Tokens {
let mut where_clause = input.generics.where_clause.take();
let (to_body, from_body) = {
let params = input.generics.type_params().collect::<Vec<_>>();
for param in &params {
cg::add_predicate(
&mut where_clause,
parse_quote!(#param: ::values::computed::ToComputedValue),
);
}
if input.generics.params.is_empty() {
let to_body = cg::fmap_match(&input, BindStyle::Ref, |binding| {
let attrs = cg::parse_field_attrs::<ComputedValueAttrs>(&binding.ast());
if attrs.field_bound {
let ty = &binding.ast().ty;
let output_type = cg::map_type_params(ty, &params, &mut |ident| {
parse_quote!(<#ident as ::values::computed::ToComputedValue>::ComputedValue)
});
cg::add_predicate(
&mut where_clause,
parse_quote!(
#ty: ::values::computed::ToComputedValue<ComputedValue = #output_type>
),
);
}
quote! {
::values::computed::ToComputedValue::to_computed_value(#binding, context)
}
});
let from_body = cg::fmap_match(&input, BindStyle::Ref, |binding| {
quote! {
::values::computed::ToComputedValue::from_computed_value(#binding)
}
});
(to_body, from_body)
};
input.generics.where_clause = where_clause;
let name = &input.ident;
let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
if input.generics.type_params().next().is_none() {
return quote! {
impl #impl_generics ::values::computed::ToComputedValue for #name #ty_generics
#where_clause
{
type ComputedValue = #computed_value_type;
type ComputedValue = Self;
#[inline]
fn to_computed_value(
@ -36,39 +74,11 @@ pub fn derive(input: DeriveInput) -> Tokens {
}
}
let to_body = cg::fmap_match(&input, BindStyle::Ref, |binding| {
let attrs = cg::parse_field_attrs::<ComputedValueAttrs>(&binding.ast());
if attrs.clone {
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! { ::std::clone::Clone::clone(#binding) }
} else {
if !attrs.ignore_bound {
where_clause.add_trait_bound(&binding.ast().ty);
}
quote! {
::values::computed::ToComputedValue::to_computed_value(#binding, context)
}
}
});
let from_body = cg::fmap_match(&input, BindStyle::Ref, |binding| {
let attrs = cg::parse_field_attrs::<ComputedValueAttrs>(&binding.ast());
if attrs.clone {
quote! { ::std::clone::Clone::clone(#binding) }
} else {
quote! {
::values::computed::ToComputedValue::from_computed_value(#binding)
}
}
});
let computed_value_type = cg::fmap_trait_output(
&input,
&parse_quote!(values::computed::ToComputedValue),
"ComputedValue".into(),
);
quote! {
impl #impl_generics ::values::computed::ToComputedValue for #name #ty_generics #where_clause {
@ -95,6 +105,5 @@ pub fn derive(input: DeriveInput) -> Tokens {
#[darling(attributes(compute), default)]
#[derive(Default, FromField)]
struct ComputedValueAttrs {
clone: bool,
ignore_bound: bool,
field_bound: bool,
}