Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Add support for derive Into<Target> #164

Open
wants to merge 7 commits into
base: main
Choose a base branch
from

Conversation

vic1707
Copy link

@vic1707 vic1707 commented Feb 12, 2025

Fixes #163

Currently a WIP, the implementation works but isn't pretty nor clean.
Refactor in progress, mostly moving code around, adding the feature gate, add tests, remove the 'convert' as a default feature
etc...

If you already have suggestions @taiki-e I'll gladly read them !
Especially around the manual use of derive_utils::EnumImpl, I think derive_utils doesn't handle generic traits for now right ?

@taiki-e
Copy link
Owner

taiki-e commented Feb 12, 2025

I think derive_utils doesn't handle generic traits for now right ?

It is supported. I think it just needs to do the same thing as any other core::convert traits:

https://github.com/taiki-e/auto_enums/blob/main/src/derive/core/convert.rs

@vic1707
Copy link
Author

vic1707 commented Feb 12, 2025

You're right, I was too focused on doing
#[auto_enum(Into<u64>)]
instead of
#[auto_enum(Into)]
and making the impl generic.

I tried that approach with great success regarding codegen. but no success regarding compilation
With said approach

#[auto_enum(Into)]
fn a(x: u8) -> impl Into<u64> {
    match x {
        0 => 8_u8,
        1 => 16_u16,
        2 => 32_u32,
        _ => false
    }
}

generates

fn a(x: u8) -> impl Into<u64> {
    #[allow(non_camel_case_types)]
    enum __Enum6219237852123227426<__Variant0, __Variant1, __Variant2, __Variant3> {     
        __Variant0(__Variant0),
        __Variant1(__Variant1),
        __Variant2(__Variant2),
        __Variant3(__Variant3),
    }
    #[automatically_derived]
    impl<__Variant0, __Variant1, __Variant2, __Variant3, __T> ::core::convert::Into<__T>
    for __Enum6219237852123227426<__Variant0, __Variant1, __Variant2, __Variant3>        
    where
        __Variant0: ::core::convert::Into<__T>,
        __Variant1: ::core::convert::Into<__T>,
        __Variant2: ::core::convert::Into<__T>,
        __Variant3: ::core::convert::Into<__T>,
    {
        #[inline]
        fn into(self) -> __T {
            match self {
                __Enum6219237852123227426::__Variant0(x) => {
                    <__Variant0 as ::core::convert::Into<__T>>::into(x)
                }
                __Enum6219237852123227426::__Variant1(x) => {
                    <__Variant1 as ::core::convert::Into<__T>>::into(x)
                }
                __Enum6219237852123227426::__Variant2(x) => {
                    <__Variant2 as ::core::convert::Into<__T>>::into(x)
                }
                __Enum6219237852123227426::__Variant3(x) => {
                    <__Variant3 as ::core::convert::Into<__T>>::into(x)
                }
            }
        }
    }
    match x {
        0 => __Enum6219237852123227426::__Variant0(8_u8),
        1 => __Enum6219237852123227426::__Variant1(16_u16),
        2 => __Enum6219237852123227426::__Variant2(32_u32),
        _ => __Enum6219237852123227426::__Variant3(false),
    }
}

Which triggers a compile error

error[E0119]: conflicting implementations of trait `std::convert::Into<_>` for type `a::__Enum6219237852123227426<_, _, _, _>`
  --> examples\t.rs:10:1
   |
10 | #[auto_enum(Into)]
   | ^^^^^^^^^^^^^^^^^^
   |
   = note: conflicting implementation in crate `core`:
           - impl<T, U> std::convert::Into<U> for T
             where U: std::convert::From<T>;
   = note: this error originates in the attribute macro `::auto_enums::enum_derive` (in Nightly builds, run with -Z macro-backtrace for more info)

Because the enum itself could replace __T
Therefore I think we will still need to take the target type as input to generate a specific impl 🤔
Another idea I have would be to generate a From implementation instead but we would need much more code I think.

On a nicer note this experimentation gave me hope for a TryFrom generation 🙃

used code gen
pub(crate) mod into {
    use crate::derive::prelude::*;

    pub(crate) const NAME: &[&str] = &["Into"];

    pub(crate) fn derive(_cx: &Context, data: &Data) -> Result<TokenStream> {
        Ok(derive_trait(data, &parse_quote!(::core::convert::Into), None, parse_quote! {
            trait Into<__T> {
                #[inline]
                fn into(self) -> __T;
            }
        }))
    }
}

@vic1707 vic1707 force-pushed the add-into-derive branch 3 times, most recently from 89732f8 to 7a1ac6a Compare February 14, 2025 13:26
@vic1707 vic1707 closed this Feb 14, 2025
@vic1707 vic1707 reopened this Feb 14, 2025
@vic1707 vic1707 force-pushed the add-into-derive branch 5 times, most recently from beeab47 to 6d9f3ee Compare February 14, 2025 14:33
@vic1707 vic1707 marked this pull request as ready for review February 14, 2025 15:36
@vic1707
Copy link
Author

vic1707 commented Feb 14, 2025

Still need to update the changelog and see if i missed some docs but the implementation looks good to me
let me know if it looks good too you too @taiki-e 🙃

@vic1707
Copy link
Author

vic1707 commented Feb 18, 2025

Out of curiosity I tried a From implementation

fn a(x: u8) -> impl Into<u64> {
	enum __Enum6219237852123227426<
		__Variant0,
		__Variant1,
		__Variant2,
		__Variant3,
	> {
		__Variant0(__Variant0),
		__Variant1(__Variant1),
		__Variant2(__Variant2),
		__Variant3(__Variant3),
	}
	impl<__Variant0, __Variant1, __Variant2, __Variant3, __T>
		::core::convert::From<
			__Enum6219237852123227426<
				__Variant0,
				__Variant1,
				__Variant2,
				__Variant3,
			>,
		> for __T
	where
        __T: ::core::convert::From<__Variant0>,
        __T: ::core::convert::From<__Variant1>,
        __T: ::core::convert::From<__Variant2>,
        __T: ::core::convert::From<__Variant3>,
	{
		#[inline]
		fn from(
			enum_value: __Enum6219237852123227426<
				__Variant0,
				__Variant1,
				__Variant2,
				__Variant3,
			>,
		) -> __T {
			match enum_value {
				__Enum6219237852123227426::__Variant0(x) => x.into(),
				__Enum6219237852123227426::__Variant1(x) => x.into(),
				__Enum6219237852123227426::__Variant2(x) => x.into(),
				__Enum6219237852123227426::__Variant3(x) => x.into(),
			}
		}
	}
	match x {
		0 => __Enum6219237852123227426::__Variant0(8_u8),
		1 => __Enum6219237852123227426::__Variant1(16_u16),
		2 => __Enum6219237852123227426::__Variant2(32_u32),
		_ => __Enum6219237852123227426::__Variant3(false),
	}
}

fn main() {
    let a: u64 = a(12).into();
    println!("{a}");
}

But this seems to make rustc go crazy as I never get any compile error but also no program, no compilation, rust-analyzer is also unresponsive xD
Using only 2 variant gives a compile error after a lot of struggling

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Labels
None yet
Projects
None yet
Development

Successfully merging this pull request may close these issues.

Support Into/From trait
2 participants