Reflections on enum

[Davier]

The goal of this discussion is to design reflection on enum types. Ideally, enums would at least support every case that the other types currently support.

Nomenclature

I will try to use the same names as in serde.

// This enum has 4 "variants" (also called `EnumItem` in the [Rust Reference](https://doc.rust-lang.org/reference/items/enumerations.html))
enum TestEnum {
    A,                         // "unit" variant
    B(String),                 // "new type" variant
    C(usize, bool),            // "tuple" variant
    D { d1: usize, d2: bool }, // "struct" variant
}

Each variant is identified by a unique number called its discriminant. Discriminants are not indices, they may not be continuous and can even be set explicitly if all variants are unit variants (that is, in C-like enums).

Features

Let's start with a wish-list of features:

1. get the current variant, its name (e.g. TestEnum::A), and its discriminant
2. list the name and discriminant of all possible variants
3. support C-like enums with explicit discriminants
4. extend Reflect::reflect_ref()
5. extend #[derive(Reflect)]
6. serialize and deserialize
7. set current value to another variant (constructing it with Default if supported)
8. DynamicEnums

Does this look complete/reasonable?

MVP

I propose as a first step to implement features 1 to 4. This means enums could manually implement the Enum trait to get basic reflection. The other features can be built on it later, which gives us time to bikeshed on design them. I will present a possible API and associated design questions.

Enum trait

Here is a first shot at the main trait that is the equivalent of the Struct trait.

pub trait Enum: Reflect {
    type Discriminant;
    /// Get the current variant
    fn variant(&self) -> EnumVariant<'_>;
    /// Get the name of the current variant
    fn variant_name(&self) -> &str;
    /// Get the discriminant of the current variant
    fn variant_discriminant(&self) -> Discriminant;
    /// Iterate all possible variants
    fn iter_variants(&self) -> impl Iterator<Item=Discriminant>;
    /// Get the number of possible variants
    fn variant_count(&self) -> usize;
    /// Get the specified variant if it's the correct one
    fn try_variant_at(&self, discriminant: Discriminant) -> Option<EnumVariant<'_>>;
    /// Get the name of the specified variant
    fn name_at(&self, discriminant: Discriminant) -> &str;
    /// Get the discriminant of a variant from its name
    fn get_discriminant_from_name(&self, name: &str) -> Result<Discriminant, _>;
    /// Get an integer representation of the specified discriminant
    fn get_discriminant_as_usize(discriminant: Discriminant) -> usize;
}

Is it missing any feature? Can you think of better names?

EnumVariant

This is an enum that contains and describes the current variant. Following the Serde data model, it defines 4 types of variants. It is conceptually similar to enum ReflectRef for Reflect.

pub enum EnumVariant<'a> {
    Unit,
    NewType(&'a dyn Reflect),
    Tuple(&'a dyn Tuple),
    Struct(&'a dyn Struct),
}

An alternative would be to not define NewType and consider them as tuples of 1 element. It's unclear to me why serde makes the difference, the Rust Reference does not.

Discriminant

This is the tricky part. It's possible to get the discriminant of any variant with std::mem::discriminant(&TestEnum::A). It returns an opaque type: std::mem::Discriminant<TestEnum>. Since our Discriminant is an associated type, each implementation can set it to the correct std::mem::Discriminant<T>. That is enough for addressing since it implements Eq and Hash but in order to give an actual integer value (e.g. for serialization), we would like to convert that to an usize (enums can never have a size larger than usize). For that we need to transmute it, however we have to avoid reading any uninitialized memory. A simple implementation of that looks like this:

// Result is unspecified but not unsound if T is not an enum
fn read_discriminant<T>(value: T) -> usize {
    use std::{intrinsics::transmute, mem::{discriminant, size_of, Discriminant}};
    let mut buffer = [0 as u8; size_of::<usize>()];
    let size = size_of::<Discriminant<T>>();
    let discriminant = discriminant(&value); // Warning: size_of_val(discriminant) != size_of::<Discriminant<T>>()
    let discriminant_ptr = &discriminant as *const Discriminant<T> as *const u8;
    for i in 0..size {
        buffer[i] = unsafe { discriminant_ptr.add(i).read() };
    }
    unsafe { transmute(buffer) }
}

There is probably a better way to do it, do tell me if you know it. Also, the compiler may be smart enough to optimize everything.

Other note: I used usize but the real discriminant's type might be signed. As far as I can tell there is no way to know from std::mem::Discriminant<> since it is opaque, but it can only happen in C-like enums with the #[repr(...)] attribute and/or explicit discriminants, so it is possible to detect it in the derive macro. Then, we would have a second associated type that is either usize or isize, and transmute the discriminant to that type.

Conclusion

This MVP seems to be implementable quickly when agreed on. I have not seriously investigated how to implement the other features, but I don't foresee any trouble. I will probably wait until we agree on this first part before detailing them here.

[Davier]

Now that I look back at the part about discriminant, I think I over-thought it. The fact that size_of_val(discriminant(&value)) != size_of::<Discriminant<T>>() should not matter when converting it to usize because this function is monomorphised (it did matter at first when I had a single type-erased discriminant, but I have dismissed that idea since).

[Davier]

This is what I am trying to do (I think taking a ref to the enum would have the same issues as taking refs to the fields like here):

pub enum EnumVariant<'a> {
    Unit,
    NewType(&'a dyn Reflect),
    Tuple(Box<dyn Tuple + 'a>), // error: lifetime parameter must outlive the static lifetime
    Struct(Box<dyn Struct + 'a>), // error: lifetime parameter must outlive the static lifetime
}
#[derive(Reflect, Clone)]
pub enum TestEnum {
    A,
    B(String),
    C(usize, bool),
    D { d1: usize, d2: bool },
}
pub struct TestEnumCRef<'a>(&'a usize, &'a bool);
impl<'a> Reflect for TestEnumCRef<'a> {/* TODO */} // error: lifetime parameter must outlive the static lifetime
impl<'a> Tuple for TestEnumCRef<'a> {/* TODO */} // error: lifetime parameter must outlive the static lifetime
pub struct TestEnumDRef<'a> {
    d1: &'a usize,
    d2: &'a bool,
}
impl<'a> Reflect for TestEnumDRef<'a> {/* TODO */} // error: lifetime parameter must outlive the static lifetime
impl<'a> Struct for TestEnumDRef<'a> {/* TODO */} // error: lifetime parameter must outlive the static lifetime
impl Enum for TestEnum {
    fn variant(&self) -> EnumVariant<'_> {
        match self {
            TestEnum::A => EnumVariant::Unit,
            TestEnum::B(new_type) => EnumVariant::NewType(new_type as &dyn Reflect),
            TestEnum::C(c1, c2) => {
                EnumVariant::Tuple(Box::new(TestEnumCRef(c1, c2)) as Box<dyn Tuple>)
            }
            TestEnum::D { d1, d2 } => {
                EnumVariant::Struct(Box::new(TestEnumDRef { d1, d2 }) as Box<dyn Struct>)
            }
        }
    }
    // [snip]
}

[Davier]

I believe I have a solution :-)
It works without storing a reference to the enum in another struct. The reference to the enum is transmuted to a reference to a transparent type containing it (I think this is always sound?), and that type implements Reflect and Tuple to do the dispatch. So it's sort of solution 4.

#[repr(transparent)]
pub struct TestEnumCWrapper (TestEnum);
impl Reflect for TestEnumCWrapper {/* TODO */}
impl Tuple for TestEnumCWrapper {
    fn field(&self, index: usize) -> Option<&dyn Reflect> {
        let (c1, c2) = match &self.0 {
            TestEnum::A => {unreachable!()}
            TestEnum::B(_) => {unreachable!()}
            TestEnum::C(c1, c2) => {(c1, c2)}
        };
        match index {
            0 => Some(c1),
            1 => Some(c2),
            _ => None,
        } 
    }
    // [snip]
}
impl Enum for TestEnum {
    fn variant(&self) -> EnumVariant<'_> {
        match self {
            TestEnum::A => EnumVariant::Unit,
            TestEnum::B(new_type) => EnumVariant::NewType(new_type as &dyn Reflect),
            TestEnum::C(..) => {
                let wrapper_ref = unsafe{std::mem::transmute::<&Self, &TestEnumCWrapper>(self)};
                EnumVariant::Tuple(wrapper_ref as &dyn Tuple)
            }
            TestEnum::D { d1, d2 } => {
                todo!()
            }
        }
    }
    // [snip]
}

[cart]

Haha I've learned the hard way that transmute is basically never the right solution to a problem. I'll start poking around.

[bjorn3]

In this case the transmute should be fine. It is sinply transmuting from a TestEnum reference to a reference to a TestEnum wrapper that is guaranteed to have the same layout.

[Davier]

#1347 now implements the MVP, and the derive macro. The derive macro is not ready for a proper review yet, but it helps a lot to try out the trait.