1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

use std::collections::{HashMap, HashSet};

use proc_macro::TokenStream;
use proc_macro2::TokenStream as TokenStream2;
use quote::ToTokens;
use syn::{self, Data, DeriveInput, Fields, Ident, Type};

use meta::{self, DataMetaParser, IdentOrIndex, MetaParser};
use util;

pub fn derive(tokens: TokenStream) -> TokenStream {
    let DeriveInput {
        ident,
        attrs,
        generics,
        data,
        ..
    } = syn::parse(tokens).expect("could not parse tokens");

    let meta: PixelMeta = meta::parse_attributes(attrs);
    let item_meta: PixelItemMeta = meta::parse_data_attributes(data.clone());

    let mut number_of_channels = 0usize;
    let mut field_type: Option<Type> = None;

    let all_fields = match data {
        Data::Struct(struct_item) => match struct_item.fields {
            Fields::Named(fields) => fields.named,
            Fields::Unnamed(fields) => fields.unnamed,
            Fields::Unit => Default::default(),
        },
        Data::Enum(_) => panic!("`Pixel` cannot be derived for enums, because of the discriminant"),
        Data::Union(_) => panic!("`Pixel` cannot be derived for unions"),
    };

    let fields = all_fields
        .into_iter()
        .enumerate()
        .map(|(index, field)| {
            (
                field
                    .ident
                    .map(IdentOrIndex::Ident)
                    .unwrap_or_else(|| IdentOrIndex::Index(index.into())),
                field.ty,
            )
        })
        .filter(|&(ref field, _)| !item_meta.zero_size_fields.contains(field));

    for (field, ty) in fields {
        let ty = item_meta
            .type_substitutes
            .get(&field)
            .cloned()
            .unwrap_or(ty);
        number_of_channels += 1;

        if let Some(field_type) = field_type.clone() {
            if field_type != ty {
                panic!(
                    "expected fields to be of type `{}`, but `{}` is of type `{}`",
                    field_type.into_token_stream(),
                    field.into_token_stream(),
                    ty.into_token_stream()
                );
            }
        } else {
            field_type = Some(ty);
        }
    }

    if !meta.repr_c {
        panic!(
            "a `#[repr(C)]` attribute is required to give `{}` a fixed memory layout",
            ident
        );
    }

    let pixel_trait_path = util::path(&["Pixel"], meta.internal);

    let implementation = if let Some(field_type) = field_type {
        let (impl_generics, type_generics, where_clause) = generics.split_for_impl();

        quote! {
            #[automatically_derived]
            unsafe impl #impl_generics #pixel_trait_path<#field_type> for #ident #type_generics #where_clause {
                const CHANNELS: usize = #number_of_channels;
            }
        }
    } else {
        panic!("`Pixel` can only be derived for structs with one or more fields");
    };

    let result = util::bundle_impl("Pixel", ident, meta.internal, implementation);
    result.into()
}

#[derive(Default)]
struct PixelMeta {
    internal: bool,
    repr_c: bool,
}

impl MetaParser for PixelMeta {
    fn internal(&mut self) {
        self.internal = true;
    }

    fn parse_attribute(&mut self, attribute_name: Ident, attribute_tts: TokenStream2) {
        match &*attribute_name.to_string() {
            "repr" => {
                let items = meta::parse_tuple_attribute(&attribute_name, attribute_tts);
                let contains_c = items.into_iter().find(|item: &Ident| item == "C").is_some();

                if contains_c {
                    self.repr_c = true;
                }
            }
            _ => {}
        }
    }
}

#[derive(Default)]
struct PixelItemMeta {
    zero_size_fields: HashSet<IdentOrIndex>,
    type_substitutes: HashMap<IdentOrIndex, Type>,
}

impl DataMetaParser for PixelItemMeta {
    fn parse_struct_field_attribute(
        &mut self,
        field_name: IdentOrIndex,
        _ty: Type,
        attribute_name: Ident,
        attribute_tts: TokenStream2,
    ) {
        match &*attribute_name.to_string() {
            "palette_unsafe_same_layout_as" => {
                let substitute = meta::parse_equal_attribute(&attribute_name, attribute_tts);
                self.type_substitutes.insert(field_name, substitute);
            }
            "palette_unsafe_zero_sized" => {
                meta::assert_empty_attribute(&attribute_name, attribute_tts);
                self.zero_size_fields.insert(field_name);
            }
            _ => {}
        }
    }
}