zerovec_derive/
varule.rs

Help
1// This file is part of ICU4X. For terms of use, please see the file
2// called LICENSE at the top level of the ICU4X source tree
3// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
4
5use crate::utils::{self, FieldInfo};
6use proc_macro2::Span;
7use proc_macro2::TokenStream as TokenStream2;
8use quote::quote;
9use syn::spanned::Spanned;
10use syn::{Data, DeriveInput, Error, Ident};
11
12/// Implementation for derive(VarULE). `custom_varule_validator` validates the last field bytes `last_field_bytes`
13/// if specified, if not, the VarULE implementation will be used.
14pub fn derive_impl(
15    input: &DeriveInput,
16    custom_varule_validator: Option<TokenStream2>,
17) -> TokenStream2 {
18    if !utils::ReprInfo::compute(&input.attrs).cpacked_or_transparent() {
19        return Error::new(
20            input.span(),
21            "derive(VarULE) must be applied to a #[repr(C, packed)] or #[repr(transparent)] type",
22        )
23        .to_compile_error();
24    }
25    if input.generics.type_params().next().is_some()
26        || input.generics.lifetimes().next().is_some()
27        || input.generics.const_params().next().is_some()
28    {
29        return Error::new(
30            input.generics.span(),
31            "derive(VarULE) must be applied to a struct without any generics",
32        )
33        .to_compile_error();
34    }
35    let struc = if let Data::Struct(ref s) = input.data {
36        if s.fields.iter().next().is_none() {
37            return Error::new(
38                input.span(),
39                "derive(VarULE) must be applied to a non-empty struct",
40            )
41            .to_compile_error();
42        }
43        s
44    } else {
45        return Error::new(input.span(), "derive(VarULE) must be applied to a struct")
46            .to_compile_error();
47    };
48
49    let n_fields = struc.fields.len();
50
51    let ule_fields = FieldInfo::make_list(struc.fields.iter().take(n_fields - 1));
52
53    let sizes = ule_fields.iter().map(|f| {
54        let ty = &f.field.ty;
55        quote!(::core::mem::size_of::<#ty>())
56    });
57    let (validators, remaining_offset) = if n_fields > 1 {
58        // generate ULE validators
59        crate::ule::generate_ule_validators(&ule_fields)
60    } else {
61        // no ULE subfields
62        (
63            quote!(
64                const ZERO: usize = 0;
65            ),
66            Ident::new("ZERO", Span::call_site()),
67        )
68    };
69
70    let unsized_field = &struc
71        .fields
72        .iter()
73        .next_back()
74        .expect("Already verified that struct is not empty")
75        .ty;
76
77    let name = &input.ident;
78    let ule_size = Ident::new(
79        &format!("__IMPL_VarULE_FOR_{name}_ULE_SIZE"),
80        Span::call_site(),
81    );
82
83    let last_field_validator = if let Some(custom_varule_validator) = custom_varule_validator {
84        custom_varule_validator
85    } else {
86        quote!(<#unsized_field as zerovec::ule::VarULE>::validate_byte_slice(last_field_bytes)?;)
87    };
88
89    // Safety (based on the safety checklist on the ULE trait):
90    //  1. #name does not include any uninitialized or padding bytes
91    //     (achieved by enforcing #[repr(transparent)] or #[repr(packed)] on a struct of only ULE types)
92    //  2. #name is aligned to 1 byte.
93    //     (achieved by enforcing #[repr(transparent)] or #[repr(packed)] on a struct of only ULE types)
94    //  3. The impl of `validate_byte_slice()` returns an error if any byte is not valid.
95    //  4. The impl of `validate_byte_slice()` returns an error if the slice cannot be used in its entirety
96    //  5. The impl of `from_byte_slice_unchecked()` returns a reference to the same data.
97    //  6. The other VarULE methods use the default impl
98    //  7. [This impl does not enforce the non-safety equality constraint, it is up to the user to do so, ideally via a custom derive]
99    quote! {
100        // The size of the ULE section of this type
101        const #ule_size: usize = 0 #(+ #sizes)*;
102        unsafe impl zerovec::ule::VarULE for #name {
103            #[inline]
104            fn validate_byte_slice(bytes: &[u8]) -> Result<(), zerovec::ZeroVecError> {
105
106                if bytes.len() < #ule_size {
107                    return Err(zerovec::ZeroVecError::parse::<Self>());
108                }
109                #validators
110                debug_assert_eq!(#remaining_offset, #ule_size);
111                #[allow(clippy::indexing_slicing)] // TODO explain
112                let last_field_bytes = &bytes[#remaining_offset..];
113                #last_field_validator
114                Ok(())
115            }
116            #[inline]
117            unsafe fn from_byte_slice_unchecked(bytes: &[u8]) -> &Self {
118                // just the unsized part
119                #[allow(clippy::indexing_slicing)] // TODO explain
120                let unsized_bytes = &bytes[#ule_size..];
121                let unsized_ref = <#unsized_field as zerovec::ule::VarULE>::from_byte_slice_unchecked(unsized_bytes);
122                // We should use the pointer metadata APIs here when they are stable: https://github.com/rust-lang/rust/issues/81513
123                // For now we rely on all DST metadata being a usize to extract it via a fake slice pointer
124                let (_ptr, metadata): (usize, usize) = ::core::mem::transmute(unsized_ref);
125                let entire_struct_as_slice: *const [u8] = ::core::slice::from_raw_parts(bytes.as_ptr(), metadata);
126                &*(entire_struct_as_slice as *const Self)
127            }
128        }
129    }
130}
zerovec_derive/varule.rs

zerovec_derive/
varule.rs
