Better error message for trying to call an associated function as a method.

[emberian]

For example:

// module shade.rs
pub trait ShaderParam<L> {
    fn create_link<S: ParameterSink>(&mut S) -> Result<L, ParameterSideError<'static>>;
    fn upload<U: Uploader>(&self, &L, &mut U);
}

// module lib.rs
    pub fn bundle_program<L, T: shade::ShaderParam<L>>(&mut self, prog: ProgramHandle, data: T)
            -> Result<shade::ShaderBundle<L, T>, shade::ParameterLinkError<'static>> {
        self.dispatcher.demand(|res| !res.programs[prog].is_pending());
        let mut sink = match self.dispatcher.resource.programs[prog] {
            Loaded(ref m) => shade::MetaSink::new(m),
            _ => return Err(shade::ErrorBadProgram),
        };
        let link = match data.create_link(&mut sink) {
            Ok(l) => l,
            Err(e) => return Err(shade::ErrorProgramInfo(e)),
        };
        match sink.complete() {
            Ok(_) => Ok(BundleInternal::new(prog, data, link)),
            Err(e) => Err(shade::ErrorShaderParam(e)),
        }
    }

Reports that there is no method create_link, which is accurate, but unhelpful. It could check if there is an associated function of the same name and suggest it instead.

[huonw]

What error message are you seeing? (Could you give a standalone example?)

E.g. the following does suggest the other functions:

struct Foo;
impl Foo {
    fn bar() {}
}

trait Baz {
    fn qux() -> Self;
}
impl Baz for Foo {
    fn qux() -> Foo { Foo }
}

fn main() {
    Foo.bar();

    Foo.qux();
}

<anon>:14:9: 14:14 error: type `Foo` does not implement any method in scope named `bar`
<anon>:14     Foo.bar();
                  ^~~~~
<anon>:14:14: 14:14 note: found defined static methods, maybe a `self` is missing?
<anon>:3:5: 3:16 note: candidate #1 is `Foo::bar`
<anon>:3     fn bar() {}
             ^~~~~~~~~~~
<anon>:16:9: 16:14 error: type `Foo` does not implement any method in scope named `qux`
<anon>:16     Foo.qux();
                  ^~~~~
<anon>:16:14: 16:14 note: found defined static methods, maybe a `self` is missing?
<anon>:7:5: 7:21 note: candidate #1 is `Baz::qux`
<anon>:7     fn qux() -> Self;
             ^~~~~~~~~~~~~~~~
error: aborting due to 2 previous errors

http://is.gd/6l5DRc

[kvark]

@huonw Here comes the snippet:

trait Foo<L> {
    fn foo() -> L;
}

pub fn bar<L, T: Foo<L>>(data: T) -> L {
    data.foo()
}

fn main() {}

[kaseyc]

Can I take this?

[pcwalton]

@kaseyc Feel free!

[kaseyc]

I think I've found the problem. but I'm not sure how to solve it.
First, a more straightforward snippet:

trait Foo {
    fn foo();
}

pub fn bar<T: Foo>(data: T) {
    data.foo()
}

fn main() {}

which gives:

test.rs:11:10: 11:15 error: type `T` does not implement any method in scope named `foo`
test.rs:11     data.foo()
                    ^~~~~
error: aborting due to previous error

The problem is that there is no actual instantiation of the trait. By changing the snippet to be:

trait Foo {
    fn foo();
}

struct A;
impl Foo for A {
    fn foo() {}
}

pub fn bar<T: Foo>(data: T) {
    data.foo()
}

fn main() {}

rustc now prints:

test.rs:11:10: 11:15 error: type `T` does not implement any method in scope named `foo`
test.rs:11     data.foo()
                    ^~~~~
test.rs:11:15: 11:15 note: found defined static methods, maybe a `self` is missing?
test.rs:2:5: 2:13 note: candidate #1 is `Foo::foo`
test.rs:2     fn foo();
              ^~~~~~~~
error: aborting due to previous error

The push_extension_candidate method, which is what finds the static method in the second snippet searches for it in the trait impls (which are added to the context by check_implementation in typeck/coherence.rs) . In order for rustc to be able to suggest the static method, the typechecker would need some way of searching for candidates in the traits themselves rather than in their implementations, which should probably be done by someone with a better understanding of rustc and the typechecker than myself.

Thanks

[fhahn]

I had a look at this issue and it seems fixed.

For @kaseyc 's snippet

trait Foo {
    fn foo();
}

pub fn bar<T: Foo>(data: T) {
    data.foo()
}

fn main() {}

rustc now prints

foo.rs:6:10: 6:15 error: type `T` does not implement any method in scope named `foo`
foo.rs:6     data.foo()
                      ^~~~~
foo.rs:6:15: 6:15 note: found defined static methods, maybe a `self` is missing?
foo.rs:2:5: 2:13 note: candidate #1 is defined in the trait `Foo`
foo.rs:2     fn foo();

which contains the hint about the static method in Foo.

[steveklabnik]

Agreed!