`#[cast_to]` on trait impl block doesn't work when trait has associated types

[yume-chan]

When a target trait has associated types, #[cast_to] attr causes compile errors when being used on the impl block:

use std::any::Any;

use intertrait::{cast::CastBox, cast_to};

trait MyTrait {
    type Output;

    fn create(&self) -> Self::Output;
}

struct Foo;

#[cast_to]
impl MyTrait for Foo {
    type Output = i32;

    fn create(&self) -> Self::Output {
        42
    }
}

cargo build output:

error[E0191]: the value of the associated type `Output` (from trait `MyTrait`) must be specified
  --> src\main.rs:26:10
   |
18 |         type Output;
   |         ------------ `Output` defined here
...
26 |     impl MyTrait for Foo {
   |          ^^^^^^^ help: specify the associated type: `MyTrait<Output = Type>`

---

But it works when attaches to struct block with associated types manually added:

#![feature(option_result_unwrap_unchecked)]

use std::any::Any;

use intertrait::{cast::CastBox, cast_to};

trait MyTrait {
    type Output;

    fn create(&self) -> Self::Output;
}

#[cast_to(MyTrait<Output = i32>)]
struct Foo;

impl MyTrait for Foo {
    type Output = i32;

    fn create(&self) -> Self::Output {
        42
    }
}

fn main() {
    let value: Box<dyn Any> = Box::new(Foo);
    let casted = unsafe { value.cast::<dyn MyTrait<Output = i32>>().unwrap_unchecked() };
    println!("{:?}", casted.create());
}

cargo run output:

   Compiling rust-test v0.1.0 (D:\dev\rust-test)
    Finished dev [unoptimized + debuginfo] target(s) in 1.02s
     Running `target\debug\rust-test.exe`
42

---

I'm using another macro to generate the trait impl block, so I prefer to also generate the #[cast_to] attr.

dependencies:

[dependencies]
intertrait = "0.2.1"
linkme = "0.2.0"

[dynaxis]

I never considered associated types in trait when writing the relevant proc macro. I'll fix it and release a new version in a week. Thanks for reporting the issue.

[dynaxis]

@yume-chan because of how intertrait works, it can't support your use case. intertrait works by generating code required to do its job using its proc macro, as you know. But if you have an associated type open in a trait and the proc macro is attached to the trait, it means the proc macro can't generate code, adjacent to it, for every possible type that can be bound to the associated type.

Actually I think I considered the limitation while writing intertrailt, but forgot to mention it in the doc.

In the end, the required code need to be generated, and all the open symbols must be bound at the time the code is generated.

If you have any better idea on how to better deal with this kind of situation, please feel free to suggest it. Thanks.

[yume-chan]

An object can only be casted to trait objects with associated types it has implemented.

In my example, Foo can only be convert to MyTrait<Output = i32>, trying converting it to MyTrait<Output = f64> is expected to fail.

As my example shows, use #[cast_to(MyTrait<Output = i32>)] on struct declaration block already works, and castable_to!(Foo => MyTrait<Output = i32>); also works (I'm generating this as a workaround from my proc macro).

Since #[cast_to] attribute on a trait implementation block can find out what associated types the struct implements, I expect it to generate the same code as above two.

[dynaxis]

@yume-chan oh, now I can understand your point correctly. Sorry for not catching your point immediately. I'll come back to you after trying to remedy the problem soon. Thanks.

[dynaxis]

@yume-chan PR #5 is merged and fixes this bug. I'll prepare a new release shortly.

[dynaxis]

0.2.2 is just released w/ the fix.