//! Macros for generating C-ABI-compatible collection types (`Vec`, `Option`, `Result`)

//! used throughout the codebase for FFI interop. Each macro produces `#[repr(C)]` types

//! with a destructor model: `DefaultRust` (library-owned), `NoDestructor` (`&'static`),

//! `External` (caller-provided destructor fn), and `AlreadyDestroyed` (post-drop guard).

#[macro_export]

macro_rules! impl_vec {

    ($struct_type:ident, $struct_name:ident, $destructor_name:ident, $destructor_type_name:ident, $slice_name:ident, $option_type:ident) => {

        pub type $destructor_type_name = extern "C" fn(*mut $struct_name);

        /// C-compatible slice type for $struct_name.

        /// This is a non-owning view into a Vec's data.

        #[repr(C)]

        #[derive(Debug, Copy, Clone)]

        pub struct $slice_name {

            pub ptr: *const $struct_type,

            pub len: usize,

        }

        impl $slice_name {

            /// Creates an empty slice.

            #[inline(always)]

            /// Returns the number of elements in the slice.

            #[inline(always)]

            /// Returns true if the slice is empty.

            #[inline(always)]

            /// Returns a pointer to the slice's data.

            #[inline(always)]

            /// Converts the C-slice to a Rust slice.

            #[inline(always)]

                } else {

                }

            /// Returns a reference to the element at the given index, or None if out of bounds.

            #[inline(always)]

            /// Returns an iterator over the elements.

            #[inline]

        }

        unsafe impl Send for $slice_name {}

        unsafe impl Sync for $slice_name {}

        #[repr(C)]

        pub struct $struct_name {

            ptr: *const $struct_type,

            len: usize,

            cap: usize,

            destructor: $destructor_name,

        }

        #[derive(Debug, Copy, Clone)]

        #[repr(C, u8)]

        pub enum $destructor_name {

            DefaultRust,

            NoDestructor,

            External($destructor_type_name),

            /// Destructor was already run — prevents double-free.

            /// Set by Drop impl after destruction.

            AlreadyDestroyed,

        }

        unsafe impl Send for $struct_name {}

        unsafe impl Sync for $struct_name {}

        impl $struct_name {

            #[inline(always)]

                // lets hope the optimizer catches this

            #[inline]

            #[inline(always)]

            #[inline(always)]

            #[inline]

            #[inline(always)]

            #[inline(always)]

            #[inline(always)]

            /// Returns a reference to the element at the given index (Rust-only, inline).

            #[inline(always)]

            /// C-API compatible get function. Returns a copy of the element at the given index.

            /// Returns None if the index is out of bounds.

            #[inline]

            {

            #[allow(dead_code)]

            #[inline(always)]

            /// Returns the vec as a Rust slice (Rust-only, not C-API compatible).

            #[inline(always)]

            /// Returns a C-compatible slice of the entire Vec.

            #[inline(always)]

            /// Returns a C-compatible slice of a range within the Vec.

            /// If the range is out of bounds, it is clamped to the valid range.

            #[inline]

                } else {

                }

            /// Returns a pointer to the Vec's data.

            /// Use `len()` to get the number of elements.

            #[inline(always)]

        }

        impl AsRef<[$struct_type]> for $struct_name {

                } else {

                }

        }

        impl Default for $struct_name {

        }

        impl core::iter::FromIterator<$struct_type> for $struct_name {

            {

        }

        impl From<alloc::vec::Vec<$struct_type>> for $struct_name {

        }

        impl From<&'static [$struct_type]> for $struct_name {

        }

        impl Drop for $struct_name {

                    $destructor_name::DefaultRust => {

                        // Defensive: a library-owned Vec only owns an allocation

                        // when `ptr` is non-null and `cap != 0`. A zeroed / moved-

                        // from FFI husk (e.g. a struct field a C++ wrapper move-

                        // cleared, leaving destructor == DefaultRust [tag 0] with a

                        // null ptr but a stale len) would otherwise hit

                        // `Vec::from_raw_parts(null, len, _)` and deref 0x0 on drop.

                        // Skip when there is nothing to free. (Empty Vecs have

                        // cap == 0; valid non-empty Vecs are unaffected.)

                    }

                }

        }

    };

}

/// Implement the `From` trait for any type.

/// Example usage:

/// ```no_run,ignore

/// enum MyError<'a> {

///     Bar(BarError<'a>),

///     Foo(FooError<'a>)

/// }

///

/// impl_from!(BarError<'a>, MyError::Bar);

/// impl_from!(FooError<'a>, MyError::Foo);

/// ```

macro_rules! impl_from {

    // From a type with a lifetime to a type which also has a lifetime

    ($a:ident < $c:lifetime > , $b:ident:: $enum_type:ident) => {

        impl<$c> From<$a<$c>> for $b<$c> {

        }

    };

    // From a type without a lifetime to a type with a lifetime

    ($a:ident, $b:ident < $c:lifetime > :: $enum_type:ident) => {

        impl<$c> From<$a> for $b<$c> {

        }

    };

    // From a type without a lifetime to a type which also does not have a lifetime

    ($a:ident, $b:ident:: $enum_type:ident) => {

        impl From<$a> for $b {

        }

    };

}

/// Implement `Display` for an enum.

///

/// Example usage:

/// ```no_run,ignore

/// enum Foo<'a> {

///     Bar(&'a str),

///     Baz(i32)

/// }

///

/// impl_display!{ Foo<'a>, {

///     Bar(s) => s,

///     Baz(i) => format!("{}", i)

/// }}

/// ```

#[macro_export]

macro_rules! impl_display {

    // For a type with a lifetime

    ($enum:ident<$lt:lifetime>, {$($variant:pat => $fmt_string:expr),+$(,)* }) => {

        impl<$lt> ::core::fmt::Display for $enum<$lt> {

                use self::$enum::*;

                    $(

                    )+

                }

        }

    };

    // For a type without a lifetime

    ($enum:ident, {$($variant:pat => $fmt_string:expr),+$(,)* }) => {

        impl ::core::fmt::Display for $enum {

                use self::$enum::*;

                    $(

                    )+

                }

        }

    };

}

/// Implements `Debug` to use `Display` instead - assumes the that the type has implemented

/// `Display`

#[macro_export]

macro_rules! impl_debug_as_display {

    // For a type with a lifetime

    ($enum:ident < $lt:lifetime >) => {

        impl<$lt> ::core::fmt::Debug for $enum<$lt> {

        }

    };

    // For a type without a lifetime

    ($enum:ident) => {

        impl ::core::fmt::Debug for $enum {

        }

    };

}

#[macro_export]

macro_rules! impl_vec_as_hashmap {

    ($struct_type:ident, $struct_name:ident) => {

        impl $struct_name {

                );

        }

    };

}

/// NOTE: impl_vec_mut can only exist for vectors that are known to be library-allocated!

#[macro_export]

macro_rules! impl_vec_mut {

    ($struct_type:ident, $struct_name:ident) => {

        impl AsMut<[$struct_type]> for $struct_name {

        }

        impl From<$struct_name> for alloc::vec::Vec<$struct_type> {

            #[allow(unused_mut)]

        }

        impl core::iter::Extend<$struct_type> for $struct_name {

        }

        impl $struct_name {

            #[inline]

            #[inline]

            #[inline]

                // code is copied from the rust stdlib, since it's not possible to

                // create a temporary Vec here. Doing that would create two

                // space for the new element

            #[inline]

                } else {

                    unsafe {

                    }

                }

            #[inline]

            #[inline]

            #[inline]

                // Nothing we can really do about these checks :(

                // Cannot overflow, because `cap <= isize::MAX`, and type of `cap` is `usize`.

                // `double_cap` guarantees exponential growth.

            #[inline]

                } else {

                    // We have an allocated chunk of memory, so we can bypass runtime

                    // checks to get our current layout.

                    unsafe {

                    }

                }

            #[inline]

                } else {

                }

            #[inline]

                // NOTE: we don't early branch on ZSTs here because we want this

                // to actually catch "asking for more than usize::MAX" in that case.

                // If we make it past the first branch then we are guaranteed to

                // panic.

                // Don't actually need any more capacity.

                // Wrapping in case they give a bad `used_cap`

                        }

                    }

                };

                    Err(true /* Overflow */) => {

                    }

                    Err(false /* AllocError(_) */) => {

                    }

                }

            /// Appends elements to `Self` from other buffer.

            #[inline]

                );

                // This is safe because:

                //

                // * the slice passed to `drop_in_place` is valid; the `len > self.len` case avoids

                //   creating an invalid slice, and

                // * the `len` of the vector is shrunk before calling `drop_in_place`, such that no

                //   value will be dropped twice in case `drop_in_place` were to panic once (if it

                //   panics twice, the program aborts).

                unsafe {

                    );

                }

            {

                {

                    }

                }

        }

    };

}

#[macro_export]

macro_rules! impl_vec_debug {

    ($struct_type:ident, $struct_name:ident) => {

        impl core::fmt::Debug for $struct_name {

        }

    };

}

#[macro_export]

macro_rules! impl_vec_partialord {

    ($struct_type:ident, $struct_name:ident) => {

        impl PartialOrd for $struct_name {

        }

    };

}

#[macro_export]

macro_rules! impl_vec_ord {

    ($struct_type:ident, $struct_name:ident) => {

        impl Ord for $struct_name {

        }

    };

}

#[macro_export]

macro_rules! impl_vec_clone {

    ($struct_type:ident, $struct_name:ident, $destructor_name:ident) => {

        impl $struct_name {

            // Creates a `Vec` from a `Cow<'static, [T]>` - useful to avoid allocating in the case

            // of &'static memory

            #[inline(always)]

                    }

                }

            /// Creates a Vec containing a single element

            #[inline(always)]

            /// Copies elements from a C array pointer into a new Vec.

            /// 

            /// # Safety

            /// - `ptr` must be valid for reading `len` elements

            /// - The memory must be properly aligned for `$struct_type`

            /// - The elements are cloned, so `$struct_type` must implement `Clone`

            #[inline]

            /// NOTE: CLONES the memory if the memory is external or &'static

            /// Moves the memory out if the memory is library-allocated

            #[inline(always)]

                    $destructor_name::External(_) | $destructor_name::DefaultRust => {

                    }

                }

            /// NOTE: CLONES the memory if the memory is external or &'static

            /// Moves the memory out if the memory is library-allocated

            #[inline(always)]

                    $destructor_name::NoDestructor | $destructor_name::External(_) | $destructor_name::AlreadyDestroyed => {

                    }

                    $destructor_name::DefaultRust => {

                            )

                        };

                    }

                }

        }

        impl Clone for $struct_name {

        }

    };

}

#[macro_export]

macro_rules! impl_vec_partialeq {

    ($struct_type:ident, $struct_name:ident) => {

        impl PartialEq for $struct_name {

        }

    };

}

#[macro_export]

macro_rules! impl_vec_eq {

    ($struct_type:ident, $struct_name:ident) => {

        impl Eq for $struct_name {}

    };

}

#[macro_export]

macro_rules! impl_vec_hash {

    ($struct_type:ident, $struct_name:ident) => {

        impl core::hash::Hash for $struct_name {

            {

        }

    };

}

#[macro_export]

macro_rules! impl_option_inner {

    ($struct_type:ident, $struct_name:ident) => {

        impl From<$struct_name> for Option<$struct_type> {

                }

        }

        impl From<Option<$struct_type>> for $struct_name {

                }

        }

        impl Default for $struct_name {

        }

        impl $struct_name {

                }

                }

                }

                }

                }

            {

                }

        }

    };

}

#[macro_export]

macro_rules! impl_option {

    ($struct_type:ident, $struct_name:ident, copy = false, clone = false, [$($derive:meta),* ]) => (

        $(#[derive($derive)])*

        #[repr(C, u8)]

        pub enum $struct_name {

            None,

            Some($struct_type)

        }

        impl $struct_name {

                }

        }

        impl_option_inner!($struct_type, $struct_name);

    );

    ($struct_type:ident, $struct_name:ident, copy = false, [$($derive:meta),* ]) => (

        $(#[derive($derive)])*

        #[repr(C, u8)]

        pub enum $struct_name {

            None,

            Some($struct_type)

        }

        impl $struct_name {

                }

        }

        impl_option_inner!($struct_type, $struct_name);

    );

    ($struct_type:ident, $struct_name:ident, [$($derive:meta),* ]) => (

        $(#[derive($derive)])*

        #[repr(C, u8)]

        pub enum $struct_name {

            None,

            Some($struct_type)

        }

        impl $struct_name {

                }

        }

        impl_option_inner!($struct_type, $struct_name);

    );

}

#[macro_export]

macro_rules! impl_result_inner {

    ($ok_struct_type:ident, $err_struct_type:ident, $struct_name:ident) => {

        impl From<$struct_name> for Result<$ok_struct_type, $err_struct_type> {

                }

        }

        impl From<Result<$ok_struct_type, $err_struct_type>> for $struct_name {

                }

        }

        impl $struct_name {

                }

                }

        }

    };

}

#[macro_export]

macro_rules! impl_result {

    ($ok_struct_type:ident, $err_struct_type:ident, $struct_name:ident, copy = false, clone = false, [$($derive:meta),* ]) => (

        $(#[derive($derive)])*

        #[repr(C, u8)]

        pub enum $struct_name {

            Ok($ok_struct_type),

            Err($err_struct_type)

        }

        impl $struct_name {

                }

        }

        impl_result_inner!($ok_struct_type, $err_struct_type, $struct_name);

    );

    ($ok_struct_type:ident, $err_struct_type:ident, $struct_name:ident, copy = false, [$($derive:meta),* ]) => (

        $(#[derive($derive)])*

        #[repr(C, u8)]

        pub enum $struct_name {

            Ok($ok_struct_type),

            Err($err_struct_type)

        }

        impl $struct_name {

                }

        }

        impl_result_inner!($ok_struct_type, $err_struct_type, $struct_name);

    );

    ($ok_struct_type:ident, $err_struct_type:ident,  $struct_name:ident, [$($derive:meta),* ]) => (

        $(#[derive($derive)])*

        #[repr(C, u8)]

        pub enum $struct_name {

            Ok($ok_struct_type),

            Err($err_struct_type)

        }

        impl $struct_name {

            pub fn into_result(&self) -> Result<$ok_struct_type, $err_struct_type> {

                match self {

                    $struct_name::Ok(o) => Ok(*o),

                    $struct_name::Err(e) => Err(*e),

                }

            }

        }

        impl_result_inner!($ok_struct_type, $err_struct_type, $struct_name);

    );

}

macro_rules! impl_color_value_fmt {

    ($struct_name:ty) => {

        impl FormatAsRustCode for $struct_name {

                    stringify!($struct_name),

                )

        }

    };

}

macro_rules! impl_enum_fmt {($enum_name:ident, $($enum_type:ident),+) => (

    impl crate::codegen::format::FormatAsRustCode for $enum_name {

                $(

                    $enum_name::$enum_type => {

                            concat!(stringify!($enum_name), "::", stringify!($enum_type))

                        )

                    },

                )+

            }

    }

)}