Missing lifetime when doing from_ref

[vnghia]

Hi thank you for this wonderful crate. One thing I notice is this does not work well with type with lifetime. For example this code does not work.

pub struct Source {
	pub name: String,
}

#[derive(o2o)]
pub struct Destination<'a> {
	#[from((&~).into())]
	pub name: Cow<'a, str>
}

// Generated code
impl<'a> ::core::convert::From<&Source> for Destination<'a> {
    fn from(value: &Source) -> Destination<'a> {
        Data {
            name: (&value.name).into(),
        }
    }
}

[Artem-Romanenia]

Hi, thank you for reporting this! Will be looking into it, hopefully sooner than later.

[vnghia]

Hey @Artem-Romanenia, I think we have to discuss about the syntax here. The syntax Struct::<T> seems to be not standard and can not be parsed by syn. Can we switch to Struct<T> ?

I still can not wrap my head around how to distinguish between Struct<T> where T is a generic and Struct<f32> where this is a concrete type. If that is too hard, I will probably just add lifetime generic instead of all generic.

[Artem-Romanenia]

Hi @vnghia, I'm not quite sure what you mean by this

I think we have to discuss about the syntax here. The syntax Struct::<T> seems to be not standard and can not be parsed by syn. Can we switch to Struct<T> ?

I suspect you are dealing with the following scenario

struct Entity<T> {
    field: T,
}

#[derive(o2o::o2o)]
#[map(Entity::<i16>)]
struct EntityDto {
    field: i16,
}

In this case, I think o2o doesn't care how it is spelled, it can be written as

struct Entity<T> {
    field: T,
}

#[derive(o2o::o2o)]
#[map(Entity<i16>)] // <- No turbofish here
struct EntityDto {
    field: i16,
}

and they will both expand in the same code. Honestly, I'm quite confused by rusts's turbofish in the first place 😄, but they just both happen to work.

I still can not wrap my head around how to distinguish between Struct where T is a generic and Struct where this is a concrete type. If that is too hard, I will probably just add lifetime generic instead of all generic.

So, previously, I used to think that mapping regular struct EntityDto to open generic struct Entity<T> didn't make any sense, but I've just managed to come up with this example:

struct Entity<T> {
    field: T,
}

struct EntityDto {
    field: i16,
}

fn test<T>(t: Entity<T>) -> i16 {
    // Do something with t
    42
}

impl<T> From<Entity<T>> for EntityDto {
    fn from(value: Entity<T>) -> Self {
        EntityDto {
            field: test(value)
        }
    }
}

Now I think it makes some sense, but it is still hard to imagine some poor soul ever wanting to do this.

So, I guess, for now let o2o bother only with mapping between regular EntityDto and closed generic Entity<i32> (which I think is already supported).

If anybody ever needs to map EntityDto and Entity<T>, and they want it hard enough to bother to create an issue on github, I'll think of some way to support this... Perhaps it would be a syntax like

#[derive(o2o::o2o)]
#[from_owned(Entity<T>| generic_impl_params(T))]
struct EntityDto {
    #[from(test(@))]
    field: i16,
}

[Artem-Romanenia]

Hi! New behavior regarding lifetimes is available in v.0.4.10.

Thanks again for the issue and for the pr!