suggest `crate::...` for "local" paths in 2018

[nikomatsakis]

The following code, when compiled in Rust 2018, errors out (as expected). However, the error could be more helpful.

mod foo {
    type Bar = u32;
}

use foo::Bar;

fn main() {
    let x: Bar = 22;
}

Error:

error[E0463]: can't find crate for `foo`
 --> src/main.rs:5:5
  |
5 | use foo::Bar;
  |     ^^^ can't find crate

error: aborting due to previous error

but I think we should suggest something like

did you mean `crate::foo::Bar`?

[nikomatsakis]

Some thoughts:

Ideally, we would compare against two things:
- the names of crates in the prelude etc
- the names of items defined in the root module (to some approximation)

and offer appropriate suggestions. Not sure if there is code that tries to do either of those already. I'd have to look around.

cc @petrochenkov @eddyb

[eddyb]

I'm mostly aware of the one speculative lookup I've introduced:

rust/src/librustc_resolve/resolve_imports.rs

Lines 169 to 196 in 052d24e

	let binding = self.resolve_ident_in_module_unadjusted(
	ModuleOrUniformRoot::Module(self_module),
	ident,
	ns,
	restricted_shadowing,
	record_used,
	path_span,
	);
	// FIXME(eddyb) This may give false negatives, specifically
	// if a crate with the same name is found in `extern_prelude`,
	// preventing the check below this one from returning `binding`
	// in all cases.
	//
	// That is, if there's no crate with the same name, `binding`
	// is always returned, which is the result of doing the exact
	// same lookup of `ident`, in the `self` module.
	// But when a crate does exist, it will get chosen even when
	// macro expansion could result in a success from the lookup
	// in the `self` module, later on.
	//
	// NB. This is currently alleviated by the "ambiguity canaries"
	// (see `is_uniform_paths_canary`) that get introduced for the
	// maybe-relative imports handled here: if the false negative
	// case were to arise, it would *also* cause an ambiguity error.
	if binding.is_ok() {
	return binding;
	}

You need to set module to self.resolve_crate_root(ident) and record_used to false.

Not sure what you mean by "the names of crates in the prelude" - that's easy enough, self.extern_prelude.contains(&ident.name) - but if it's in there, it wouldn't have failed?

[davidtwco]

Between starting to look at this and now, I've noticed that the error has changed to:

error[E0432]: unresolved import `foo`
  --> src/test/ui/rust-2018/local-path-suggestions.rs:17:5
   |
17 | use foo::Bar;
   |     ^^^ Did you mean `self::foo`?

error: aborting due to previous error

[nikomatsakis]

@davidtwco hmm, yeah, there is technically ambiguity here I guess, in that one could write with use self or use crate. I don't know which would be considered "more idiomatic" -- I lean towards absolute paths myself, but I'm sure opinions will vary. =)

e.g., if one is doing something like this, then surely you want use self::..

enum Foo { .. }
pub use self::Foo::*;

[nikomatsakis]

Also, if we modify the test ever so slightly to be more realistic:

mod foo {
    type Bar = u32;
}

mod baz {
    use foo::Bar;

    fn baz() {
        let x: Bar = 22;
    }
}

fn main() { }

then I assume you get no suggestion?