Get "does not implement any method" if module w/ trait use'd, but not when trait imported

[arienmalec]

The following code fails with " error: type objs::Obj does not implement any method in scope named foo"

mod traits {
    pub trait Foo {
        fn foo(&self) -> u32;
    }

}

mod objs {
    use traits;
    pub struct Obj {
        my_foo: u32,
    }

    impl Obj {
        pub fn with_foo(f: u32) -> Self {
            Obj {my_foo: f}
        }
    }
    impl traits::Foo for Obj {
        fn foo(&self) -> u32 {
            self.my_foo
        }
    }
}


fn main() {
    use traits;
    use objs;
    let o = objs::Obj::with_foo(42);
    println!("{}", o.foo());
}

but works when main is changed to specifically import the trait:

fn main() {
    use traits::{Foo};
    use objs;
    let o = objs::Obj::with_foo(42);
    println!("{}", o.foo());
}

Note that the only difference between these two versions is whether Foo is addressable as Foo or as traits::Foo; in either case the trait has been included in scope; that is, the only difference is changing:

use traits;
to
use traits::{Foo};

[Aatch]

This is expected behaviour. The trait has to be in scope for it to be considered for method resolution. The error message could be more helpful, but that's a separate issue, specifically, #7643.

Closing in favor of that.

[arienmalec]

This is a different issue. In #7643, the module was not use'd. In this case, the modeling containing the trait has been use'd and is therefore in scope. See use traits; in the code that isn't working. The only difference between works and does not work is changing:

use traits;
to
use traits::{Foo}

[arienmalec]

I'd also add that if this behavior is expected, it is inconsistent between library traits and user defined traits. For example, the statement use std::fmt; is sufficient to refer to std::fmt::String

[Aatch]

@arienmalec there is not any inconsistency. use std::fmt will not bring std::fmt::String into scope. Merely use-ing a module is not enough to bring the trait into scope. Note that this only applies when resolving method calls, not any other time.

[arienmalec]

I can call the fmt method implemented through implementing the std::fmt::String trait with a use std::fmt. I don't (or write! doesn't) get an error in that case.