Problem with `self` when inheriting generic traits.

[brendanzab]

extern mod std;
use std::cmp::FuzzyEq;

trait Float: FuzzyEq<Self> {
    static pure fn two_pi() -> Self;
}

impl f32: Float {
    static pure fn two_pi() -> f32 { 6.28318530717958647692528676655900576_f32 }
}

struct Radians<T>(T);

impl<T:Copy Float> Radians<T> {
    static pure fn full_turn() -> Radians<T> { Radians(Float::two_pi())    }
}

fn main() {}

src/float.rs:16:55: 16:68 error: mismatched types: expected `@FuzzyEq<'a>` but found `@FuzzyEq<self>` (expected type parameter but found self)
src/float.rs:16     static pure fn full_turn() -> Radians<T> { Radians(Float::two_pi())    }
                                                                       ^~~~~~~~~~~~~
error: aborting due to previous error

Update: changed to capitalized Self
Update: Use FuzzyEq trait from std::cmp

[brendanzab]

If this can be fixed this would allow us define Num with trait constraints from ops::core. ie:

trait Num: Add<self,self>
           Sub<self,self>
           Mul<self,self>
           Div<self,self>
           Modulo<self,self>
           Neg<self>
           Ord Eq { ... }

[brendanzab]

@catamorphism (nag nag)

[brendanzab]

I did a search for "mismatched types: expecting", and it seems to be pointing to librustc/middle/typeck/check/_match.rs. Dunno if that's of any help.

[brendanzab]

There also seems to be one at librustc/middle/typeck/check/mod.rs

    fn report_mismatched_types(sp: span, e: ty::t, a: ty::t,
                               err: &ty::type_err) {
        // Don't report an error if expected is ty_err
        let resolved_expected =
            self.resolve_type_vars_if_possible(e);
        let mk_msg = match ty::get(resolved_expected).sty {
            ty::ty_err => return,
            _ => {
                // if I leave out : ~str, it infers &str and complains
                |actual: ~str| {
                    fmt!("mismatched types: expected `%s` but found `%s`",
                         self.ty_to_str(resolved_expected), actual)
                }
            }
        };
        self.type_error_message(sp, mk_msg, a, Some(err));
    }

[catamorphism]

I think this is failing because typeck isn't applying substs properly when checking the inherited trait. If I comment out the : FuzzyEq<Self>, it compiles. Investigating more.

[brendanzab]

Cheers, the help is most appreciated.

[catamorphism]

So far I've figured out that the self type doesn't get substituted correctly when checking the inherited trait, but simplistically applying the substs from the self type (T as bound by the Radians impl in this case) doesn't work either. Basically, the typechecker says "self isn't T" because the knowledge that T gets instantiated with self here gets lost somewhere.

I don't understand the code well enough to know what to do, though; still digging.

[catamorphism]

After talking to @nikomatsakis , I think this will be easier to fix after fixing #4678, so I'm going to consider this blocked on #4678.

[brendanzab]

Referencing this pull: #4910

[nikomatsakis]

I am doing some refactoring so as to make object types and the rest sound and correctly implemented. This is needed to prepare for my rewritten and expanded borrow checker. I have a feeling this refactoring will solve this issue, or at least make it much clearer what's going on.

[catamorphism]

Not critical for 0.6; de-milestoning.