html-to-markdown 2.23.4 → 2.24.1

data/rust-vendor/zerocopy-derive/src/enum.rs

@@ -1,456 +0,0 @@
-// Copyright 2024 The Fuchsia Authors
-//
-// Licensed under a BSD-style license <LICENSE-BSD>, Apache License, Version 2.0
-// <LICENSE-APACHE or https://www.apache.org/licenses/LICENSE-2.0>, or the MIT
-// license <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your option.
-// This file may not be copied, modified, or distributed except according to
-// those terms.
-
-use proc_macro2::TokenStream;
-use quote::quote;
-use syn::{
-    parse_quote, spanned::Spanned as _, DataEnum, DeriveInput, Error, Fields, Generics, Ident,
-    Index, Path,
-};
-
-use crate::{
-    derive_has_field_struct_union, derive_try_from_bytes_inner, repr::EnumRepr, DataExt,
-    FieldBounds, ImplBlockBuilder, Trait,
-};
-
-/// Generates a tag enum for the given enum. This generates an enum with the
-/// same non-align `repr`s, variants, and corresponding discriminants, but none
-/// of the fields.
-pub(crate) fn generate_tag_enum(repr: &EnumRepr, data: &DataEnum) -> TokenStream {
-    let variants = data.variants.iter().map(|v| {
-        let ident = &v.ident;
-        if let Some((eq, discriminant)) = &v.discriminant {
-            quote! { #ident #eq #discriminant }
-        } else {
-            quote! { #ident }
-        }
-    });
-
-    // Don't include any `repr(align)` when generating the tag enum, as that
-    // could add padding after the tag but before any variants, which is not the
-    // correct behavior.
-    let repr = match repr {
-        EnumRepr::Transparent(span) => quote::quote_spanned! { *span => #[repr(transparent)] },
-        EnumRepr::Compound(c, _) => quote! { #c },
-    };
-
-    quote! {
-        #repr
-        #[allow(dead_code, non_camel_case_types)]
-        enum ___ZerocopyTag {
-            #(#variants,)*
-        }
-
-        // SAFETY: `___ZerocopyTag` has no fields, and so it does not permit
-        // interior mutation.
-        unsafe impl ::zerocopy::Immutable for ___ZerocopyTag {
-            fn only_derive_is_allowed_to_implement_this_trait() {}
-        }
-    }
-}
-
-fn tag_ident(variant_ident: &Ident) -> Ident {
-    ident!(("___ZEROCOPY_TAG_{}", variant_ident), variant_ident.span())
-}
-
-/// Generates a constant for the tag associated with each variant of the enum.
-/// When we match on the enum's tag, each arm matches one of these constants. We
-/// have to use constants here because:
-///
-/// - The type that we're matching on is not the type of the tag, it's an
-///   integer of the same size as the tag type and with the same bit patterns.
-/// - We can't read the enum tag as an enum because the bytes may not represent
-///   a valid variant.
-/// - Patterns do not currently support const expressions, so we have to assign
-///   these constants to names rather than use them inline in the `match`
-///   statement.
-fn generate_tag_consts(data: &DataEnum) -> TokenStream {
-    let tags = data.variants.iter().map(|v| {
-        let variant_ident = &v.ident;
-        let tag_ident = tag_ident(variant_ident);
-
-        quote! {
-            // This casts the enum variant to its discriminant, and then
-            // converts the discriminant to the target integral type via a
-            // numeric cast [1].
-            //
-            // Because these are the same size, this is defined to be a no-op
-            // and therefore is a lossless conversion [2].
-            //
-            // [1] Per https://doc.rust-lang.org/1.81.0/reference/expressions/operator-expr.html#enum-cast:
-            //
-            //   Casts an enum to its discriminant.
-            //
-            // [2] Per https://doc.rust-lang.org/1.81.0/reference/expressions/operator-expr.html#numeric-cast:
-            //
-            //   Casting between two integers of the same size (e.g. i32 -> u32)
-            //   is a no-op.
-            #[allow(non_upper_case_globals)]
-            const #tag_ident: ___ZerocopyTagPrimitive =
-                ___ZerocopyTag::#variant_ident as ___ZerocopyTagPrimitive;
-        }
-    });
-
-    quote! {
-        #(#tags)*
-    }
-}
-
-fn variant_struct_ident(variant_ident: &Ident) -> Ident {
-    ident!(("___ZerocopyVariantStruct_{}", variant_ident), variant_ident.span())
-}
-
-/// Generates variant structs for the given enum variant.
-///
-/// These are structs associated with each variant of an enum. They are
-/// `repr(C)` tuple structs with the same fields as the variant after a
-/// `MaybeUninit<___ZerocopyInnerTag>`.
-///
-/// In order to unify the generated types for `repr(C)` and `repr(int)` enums,
-/// we use a "fused" representation with fields for both an inner tag and an
-/// outer tag. Depending on the repr, we will set one of these tags to the tag
-/// type and the other to `()`. This lets us generate the same code but put the
-/// tags in different locations.
-fn generate_variant_structs(
-    enum_name: &Ident,
-    generics: &Generics,
-    data: &DataEnum,
-    zerocopy_crate: &Path,
-) -> TokenStream {
-    let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
-
-    // All variant structs have a `PhantomData<MyEnum<...>>` field because we
-    // don't know which generic parameters each variant will use, and unused
-    // generic parameters are a compile error.
-    let phantom_ty = quote! {
-        core_reexport::marker::PhantomData<#enum_name #ty_generics>
-    };
-
-    let variant_structs = data.variants.iter().filter_map(|variant| {
-        // We don't generate variant structs for unit variants because we only
-        // need to check the tag. This helps cut down our generated code a bit.
-        if matches!(variant.fields, Fields::Unit) {
-            return None;
-        }
-
-        let variant_struct_ident = variant_struct_ident(&variant.ident);
-        let field_types = variant.fields.iter().map(|f| &f.ty);
-
-        let variant_struct = parse_quote! {
-            #[repr(C)]
-            #[allow(non_snake_case)]
-            struct #variant_struct_ident #impl_generics (
-                core_reexport::mem::MaybeUninit<___ZerocopyInnerTag>,
-                #(#field_types,)*
-                #phantom_ty,
-            ) #where_clause;
-        };
-
-        // We do this rather than emitting `#[derive(::zerocopy::TryFromBytes)]`
-        // because that is not hygienic, and this is also more performant.
-        let try_from_bytes_impl =
-            derive_try_from_bytes_inner(&variant_struct, Trait::TryFromBytes, zerocopy_crate)
-                .expect("derive_try_from_bytes_inner should not fail on synthesized type");
-
-        Some(quote! {
-            #variant_struct
-            #try_from_bytes_impl
-        })
-    });
-
-    quote! {
-        #(#variant_structs)*
-    }
-}
-
-fn variants_union_field_ident(ident: &Ident) -> Ident {
-    // Field names are prefixed with `__field_` to prevent name collision
-    // with the `__nonempty` field.
-    ident!(("__field_{}", ident), ident.span())
-}
-
-fn generate_variants_union(
-    generics: &Generics,
-    data: &DataEnum,
-    zerocopy_crate: &Path,
-) -> TokenStream {
-    let (_, ty_generics, _) = generics.split_for_impl();
-
-    let fields = data.variants.iter().filter_map(|variant| {
-        // We don't generate variant structs for unit variants because we only
-        // need to check the tag. This helps cut down our generated code a bit.
-        if matches!(variant.fields, Fields::Unit) {
-            return None;
-        }
-
-        let field_name = variants_union_field_ident(&variant.ident);
-        let variant_struct_ident = variant_struct_ident(&variant.ident);
-
-        Some(quote! {
-            #field_name: core_reexport::mem::ManuallyDrop<
-                #variant_struct_ident #ty_generics
-            >,
-        })
-    });
-
-    let variants_union = parse_quote! {
-        #[repr(C)]
-        #[allow(non_snake_case)]
-        union ___ZerocopyVariants #generics {
-            #(#fields)*
-            // Enums can have variants with no fields, but unions must
-            // have at least one field. So we just add a trailing unit
-            // to ensure that this union always has at least one field.
-            // Because this union is `repr(C)`, this unit type does not
-            // affect the layout.
-            __nonempty: (),
-        }
-    };
-
-    let has_field =
-        derive_has_field_struct_union(&variants_union, &variants_union.data, zerocopy_crate);
-
-    quote! {
-        #variants_union
-        #has_field
-    }
-}
-
-/// Generates an implementation of `is_bit_valid` for an arbitrary enum.
-///
-/// The general process is:
-///
-/// 1. Generate a tag enum. This is an enum with the same repr, variants, and
-///    corresponding discriminants as the original enum, but without any fields
-///    on the variants. This gives us access to an enum where the variants have
-///    the same discriminants as the one we're writing `is_bit_valid` for.
-/// 2. Make constants from the variants of the tag enum. We need these because
-///    we can't put const exprs in match arms.
-/// 3. Generate variant structs. These are structs which have the same fields as
-///    each variant of the enum, and are `#[repr(C)]` with an optional "inner
-///    tag".
-/// 4. Generate a variants union, with one field for each variant struct type.
-/// 5. And finally, our raw enum is a `#[repr(C)]` struct of an "outer tag" and
-///    the variants union.
-///
-/// See these reference links for fully-worked example decompositions.
-///
-/// - `repr(C)`: <https://doc.rust-lang.org/reference/type-layout.html#reprc-enums-with-fields>
-/// - `repr(int)`: <https://doc.rust-lang.org/reference/type-layout.html#primitive-representation-of-enums-with-fields>
-/// - `repr(C, int)`: <https://doc.rust-lang.org/reference/type-layout.html#combining-primitive-representations-of-enums-with-fields-and-reprc>
-pub(crate) fn derive_is_bit_valid(
-    ast: &DeriveInput,
-    enum_ident: &Ident,
-    repr: &EnumRepr,
-    generics: &Generics,
-    data: &DataEnum,
-    zerocopy_crate: &Path,
-) -> Result<TokenStream, Error> {
-    let trait_path = Trait::TryFromBytes.crate_path(zerocopy_crate);
-    let tag_enum = generate_tag_enum(repr, data);
-    let tag_consts = generate_tag_consts(data);
-
-    let (outer_tag_type, inner_tag_type) = if repr.is_c() {
-        (quote! { ___ZerocopyTag }, quote! { () })
-    } else if repr.is_primitive() {
-        (quote! { () }, quote! { ___ZerocopyTag })
-    } else {
-        return Err(Error::new(
-            ast.span(),
-            "must have #[repr(C)] or #[repr(Int)] attribute in order to guarantee this type's memory layout",
-        ));
-    };
-
-    let variant_structs = generate_variant_structs(enum_ident, generics, data, zerocopy_crate);
-    let variants_union = generate_variants_union(generics, data, zerocopy_crate);
-
-    let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
-
-    let has_fields = data.variants().into_iter().flat_map(|(variant, fields)| {
-        let variant_ident = &variant.unwrap().ident;
-        let variants_union_field_ident = variants_union_field_ident(variant_ident);
-        let field: Box<syn::Type> = parse_quote!(());
-        fields.into_iter().enumerate().map(move |(idx, (vis, ident, ty))| {
-            // Rust does not presently support explicit visibility modifiers on
-            // enum fields, but we guard against the possibility to ensure this
-            // derive remains sound.
-            assert!(matches!(vis, syn::Visibility::Inherited));
-            let variant_struct_field_index = Index::from(idx + 1);
-            let (_, ty_generics, _) = generics.split_for_impl();
-            ImplBlockBuilder::new(
-                ast,
-                data,
-                Trait::HasField {
-                    variant_id: parse_quote!({ #zerocopy_crate::ident_id!(#variant_ident) }),
-                    // Since Rust does not presently support explicit visibility
-                    // modifiers on enum fields, any public type is suitable
-                    // here; we use `()`.
-                    field: field.clone(),
-                    field_id: parse_quote!({ #zerocopy_crate::ident_id!(#ident) }),
-                },
-                FieldBounds::None,
-                zerocopy_crate,
-            )
-            .inner_extras(quote! {
-                type Type = #ty;
-
-                #[inline(always)]
-                fn project(slf: #zerocopy_crate::pointer::PtrInner<'_, Self>) -> *mut Self::Type {
-                    use #zerocopy_crate::pointer::cast::{CastSized, Projection};
-
-                    slf.project::<___ZerocopyRawEnum #ty_generics, CastSized>()
-                        .project::<_, Projection<_, { #zerocopy_crate::STRUCT_VARIANT_ID }, { #zerocopy_crate::ident_id!(variants) }>>()
-                        .project::<_, Projection<_, { #zerocopy_crate::UNION_VARIANT_ID }, { #zerocopy_crate::ident_id!(#variants_union_field_ident) }>>()
-                        .project::<_, Projection<_, { #zerocopy_crate::STRUCT_VARIANT_ID }, { #zerocopy_crate::ident_id!(value) }>>()
-                        .project::<_, Projection<_, { #zerocopy_crate::STRUCT_VARIANT_ID }, { #zerocopy_crate::ident_id!(#variant_struct_field_index) }>>()
-                        .as_ptr()
-                }
-            })
-            .build()
-        })
-    });
-
-    let match_arms = data.variants.iter().map(|variant| {
-        let tag_ident = tag_ident(&variant.ident);
-        let variant_struct_ident = variant_struct_ident(&variant.ident);
-        let variants_union_field_ident = variants_union_field_ident(&variant.ident);
-
-        if matches!(variant.fields, Fields::Unit) {
-            // Unit variants don't need any further validation beyond checking
-            // the tag.
-            quote! {
-                #tag_ident => true
-            }
-        } else {
-            quote! {
-                #tag_ident => {
-                    // SAFETY: Since we know that the tag is `#tag_ident`, we
-                    // know that no other `&`s exist which refer to this enum
-                    // as any other variant.
-                    let variant_md = unsafe { variants.cast_unchecked::<
-                        core_reexport::mem::ManuallyDrop<#variant_struct_ident #ty_generics>,
-                        #zerocopy_crate::pointer::cast::Projection<
-                            _,
-                            { #zerocopy_crate::UNION_VARIANT_ID },
-                            { #zerocopy_crate::ident_id!(#variants_union_field_ident) }
-                        >
-                    >() };
-                    let variant = variant_md.cast::<
-                        #variant_struct_ident #ty_generics,
-                        #zerocopy_crate::pointer::cast::CastSized,
-                        #zerocopy_crate::pointer::BecauseInvariantsEq
-                    >();
-                    <
-                        #variant_struct_ident #ty_generics as #trait_path
-                    >::is_bit_valid(variant)
-                }
-            }
-        }
-    });
-
-    let raw_enum: DeriveInput = parse_quote! {
-        #[repr(C)]
-        struct ___ZerocopyRawEnum #generics {
-            tag: ___ZerocopyOuterTag,
-            variants: ___ZerocopyVariants #ty_generics,
-        }
-    };
-
-    let self_ident = &ast.ident;
-    let invariants_eq_impl = quote! {
-        // SAFETY: `___ZerocopyRawEnum` is designed to have the same layout,
-        // validity, and invariants as `Self`.
-        unsafe impl #impl_generics #zerocopy_crate::pointer::InvariantsEq<___ZerocopyRawEnum #ty_generics> for #self_ident #ty_generics #where_clause {}
-    };
-
-    let raw_enum_projections =
-        derive_has_field_struct_union(&raw_enum, &raw_enum.data, zerocopy_crate);
-
-    let raw_enum = quote! {
-        #raw_enum
-        #invariants_eq_impl
-        #raw_enum_projections
-    };
-
-    Ok(quote! {
-        // SAFETY: We use `is_bit_valid` to validate that the bit pattern of the
-        // enum's tag corresponds to one of the enum's discriminants. Then, we
-        // check the bit validity of each field of the corresponding variant.
-        // Thus, this is a sound implementation of `is_bit_valid`.
-        fn is_bit_valid<___ZerocopyAliasing>(
-            candidate: #zerocopy_crate::Maybe<'_, Self, ___ZerocopyAliasing>,
-        ) -> #zerocopy_crate::util::macro_util::core_reexport::primitive::bool
-        where
-            ___ZerocopyAliasing: #zerocopy_crate::pointer::invariant::Reference,
-        {
-            use #zerocopy_crate::util::macro_util::core_reexport;
-
-            #tag_enum
-
-            type ___ZerocopyTagPrimitive = #zerocopy_crate::util::macro_util::SizeToTag<
-                { core_reexport::mem::size_of::<___ZerocopyTag>() },
-            >;
-
-            #tag_consts
-
-            type ___ZerocopyOuterTag = #outer_tag_type;
-            type ___ZerocopyInnerTag = #inner_tag_type;
-
-            // SAFETY: `___ZerocopyRawEnum` is designed to match the layout of
-            // the `Self` enum, which has a `___ZerocopyTag` tag as its first
-            // field.
-            //
-            // `project` is implemented using a cast which preserves or shrinks
-            // the set of referent bytes and preserves provenance.
-            unsafe impl #generics #zerocopy_crate::HasField<(), { #zerocopy_crate::STRUCT_VARIANT_ID }, { #zerocopy_crate::ident_id!(tag) }> for ___ZerocopyRawEnum #ty_generics {
-                fn only_derive_is_allowed_to_implement_this_trait() {}
-
-                type Type = ___ZerocopyTag;
-
-                #[inline(always)]
-                fn project(slf: #zerocopy_crate::pointer::PtrInner<'_, Self>) -> *mut Self::Type {
-                    slf.as_ptr().cast()
-                }
-            }
-
-            #variant_structs
-
-            #variants_union
-
-            #raw_enum
-
-            #(#has_fields)*
-
-            let mut raw_enum = candidate.cast::<
-                ___ZerocopyRawEnum #ty_generics,
-                #zerocopy_crate::pointer::cast::CastSized,
-                #zerocopy_crate::pointer::BecauseInvariantsEq
-            >();
-
-            let tag = {
-                let tag_ptr = raw_enum.reborrow().project::<
-                    (),
-                    { #zerocopy_crate::ident_id!(tag) }
-                >().cast::<
-                    ___ZerocopyTagPrimitive,
-                    #zerocopy_crate::pointer::cast::CastSized,
-                    _
-                >();
-                tag_ptr.recall_validity::<_, (_, (_, _))>().read_unaligned::<#zerocopy_crate::BecauseImmutable>()
-            };
-
-            let variants = raw_enum.project::<_, { #zerocopy_crate::ident_id!(variants) }>();
-
-            #[allow(non_upper_case_globals)]
-            match tag {
-                #(#match_arms,)*
-                _ => false,
-            }
-        }
-    })
-}

data/rust-vendor/zerocopy-derive/src/ext.rs

@@ -1,123 +0,0 @@
-// Copyright 2019 The Fuchsia Authors
-//
-// Licensed under a BSD-style license <LICENSE-BSD>, Apache License, Version 2.0
-// <LICENSE-APACHE or https://www.apache.org/licenses/LICENSE-2.0>, or the MIT
-// license <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your option.
-// This file may not be copied, modified, or distributed except according to
-// those terms.
-
-use proc_macro2::{Span, TokenStream};
-use quote::ToTokens;
-use syn::{Data, DataEnum, DataStruct, DataUnion, Field, Ident, Index, Type, Variant, Visibility};
-
-pub(crate) trait DataExt {
-    /// Extracts the names and types of all fields. For enums, extracts the
-    /// names and types of fields from each variant. For tuple structs, the
-    /// names are the indices used to index into the struct (ie, `0`, `1`, etc).
-    ///
-    /// FIXME: Extracting field names for enums doesn't really make sense. Types
-    /// makes sense because we don't care about where they live - we just care
-    /// about transitive ownership. But for field names, we'd only use them when
-    /// generating is_bit_valid, which cares about where they live.
-    fn fields(&self) -> Vec<(&Visibility, TokenStream, &Type)>;
-
-    fn variants(&self) -> Vec<(Option<&Variant>, Vec<(&Visibility, TokenStream, &Type)>)>;
-
-    fn tag(&self) -> Option<Ident>;
-}
-
-impl DataExt for Data {
-    fn fields(&self) -> Vec<(&Visibility, TokenStream, &Type)> {
-        match self {
-            Data::Struct(strc) => strc.fields(),
-            Data::Enum(enm) => enm.fields(),
-            Data::Union(un) => un.fields(),
-        }
-    }
-
-    fn variants(&self) -> Vec<(Option<&Variant>, Vec<(&Visibility, TokenStream, &Type)>)> {
-        match self {
-            Data::Struct(strc) => strc.variants(),
-            Data::Enum(enm) => enm.variants(),
-            Data::Union(un) => un.variants(),
-        }
-    }
-
-    fn tag(&self) -> Option<Ident> {
-        match self {
-            Data::Struct(strc) => strc.tag(),
-            Data::Enum(enm) => enm.tag(),
-            Data::Union(un) => un.tag(),
-        }
-    }
-}
-
-impl DataExt for DataStruct {
-    fn fields(&self) -> Vec<(&Visibility, TokenStream, &Type)> {
-        map_fields(&self.fields)
-    }
-
-    fn variants(&self) -> Vec<(Option<&Variant>, Vec<(&Visibility, TokenStream, &Type)>)> {
-        vec![(None, self.fields())]
-    }
-
-    fn tag(&self) -> Option<Ident> {
-        None
-    }
-}
-
-impl DataExt for DataEnum {
-    fn fields(&self) -> Vec<(&Visibility, TokenStream, &Type)> {
-        map_fields(self.variants.iter().flat_map(|var| &var.fields))
-    }
-
-    fn variants(&self) -> Vec<(Option<&Variant>, Vec<(&Visibility, TokenStream, &Type)>)> {
-        self.variants.iter().map(|var| (Some(var), map_fields(&var.fields))).collect()
-    }
-
-    fn tag(&self) -> Option<Ident> {
-        Some(Ident::new("___ZerocopyTag", Span::call_site()))
-    }
-}
-
-impl DataExt for DataUnion {
-    fn fields(&self) -> Vec<(&Visibility, TokenStream, &Type)> {
-        map_fields(&self.fields.named)
-    }
-
-    fn variants(&self) -> Vec<(Option<&Variant>, Vec<(&Visibility, TokenStream, &Type)>)> {
-        vec![(None, self.fields())]
-    }
-
-    fn tag(&self) -> Option<Ident> {
-        None
-    }
-}
-
-fn map_fields<'a>(
-    fields: impl 'a + IntoIterator<Item = &'a Field>,
-) -> Vec<(&'a Visibility, TokenStream, &'a Type)> {
-    fields
-        .into_iter()
-        .enumerate()
-        .map(|(idx, f)| {
-            (
-                &f.vis,
-                f.ident
-                    .as_ref()
-                    .map(ToTokens::to_token_stream)
-                    .unwrap_or_else(|| Index::from(idx).to_token_stream()),
-                &f.ty,
-            )
-        })
-        .collect()
-}
-
-pub(crate) fn to_ident_str(t: &impl ToString) -> String {
-    let s = t.to_string();
-    if let Some(stripped) = s.strip_prefix("r#") {
-        stripped.to_string()
-    } else {
-        s
-    }
-}