Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Bug #21221: Show candidates for names not in scope #31674

Merged
merged 1 commit into from
Feb 20, 2016
Merged

Bug #21221: Show candidates for names not in scope #31674

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
12 changes: 6 additions & 6 deletions src/librustc_resolve/diagnostics.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -461,12 +461,12 @@ impl Foo for Bar { // ok!
"##,

E0405: r##"
An unknown trait was implemented. Example of erroneous code:
The code refers to a trait that is not in scope. Example of erroneous code:

```compile_fail
struct Foo;

impl SomeTrait for Foo {} // error: use of undeclared trait name `SomeTrait`
impl SomeTrait for Foo {} // error: trait `SomeTrait` is not in scope
```

Please verify that the name of the trait wasn't misspelled and ensure that it
Expand Down Expand Up @@ -599,20 +599,20 @@ trait Baz : Foo + Foo2 {
"##,

E0412: r##"
An undeclared type name was used. Example of erroneous codes:
The type name used is not in scope. Example of erroneous codes:

```compile_fail
impl Something {} // error: use of undeclared type name `Something`
impl Something {} // error: type name `Something` is not in scope

// or:

trait Foo {
fn bar(N); // error: use of undeclared type name `N`
fn bar(N); // error: type name `N` is not in scope
}

// or:

fn foo(x: T) {} // error: use of undeclared type name `T`
fn foo(x: T) {} // type name `T` is not in scope
```

To fix this error, please verify you didn't misspell the type name, you did
Expand Down
257 changes: 231 additions & 26 deletions src/librustc_resolve/lib.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -81,6 +81,8 @@ use rustc_front::hir::{ItemFn, ItemForeignMod, ItemImpl, ItemMod, ItemStatic, It
use rustc_front::hir::{ItemStruct, ItemTrait, ItemTy, ItemUse};
use rustc_front::hir::Local;
use rustc_front::hir::{Pat, PatKind, Path, PrimTy};
use rustc_front::hir::{PathSegment, PathParameters};
use rustc_front::hir::HirVec;
use rustc_front::hir::{TraitRef, Ty, TyBool, TyChar, TyFloat, TyInt};
use rustc_front::hir::{TyRptr, TyStr, TyUint, TyPath, TyPtr};
use rustc_front::util::walk_pat;
Expand Down Expand Up @@ -117,6 +119,12 @@ enum SuggestionType {
NotFound,
}

/// Candidates for a name resolution failure
pub struct SuggestedCandidates {
name: String,
candidates: Vec<Path>,
}

pub enum ResolutionError<'a> {
/// error E0401: can't use type parameters from outer function
TypeParametersFromOuterFunction,
Expand All @@ -127,7 +135,7 @@ pub enum ResolutionError<'a> {
/// error E0404: is not a trait
IsNotATrait(&'a str),
/// error E0405: use of undeclared trait name
UndeclaredTraitName(&'a str),
UndeclaredTraitName(&'a str, SuggestedCandidates),
/// error E0406: undeclared associated type
UndeclaredAssociatedType,
/// error E0407: method is not a member of trait
Expand All @@ -145,7 +153,7 @@ pub enum ResolutionError<'a> {
/// error E0411: use of `Self` outside of an impl or trait
SelfUsedOutsideImplOrTrait,
/// error E0412: use of undeclared
UseOfUndeclared(&'a str, &'a str),
UseOfUndeclared(&'a str, &'a str, SuggestedCandidates),
/// error E0413: declaration shadows an enum variant or unit-like struct in scope
DeclarationShadowsEnumVariantOrUnitLikeStruct(Name),
/// error E0414: only irrefutable patterns allowed here
Expand Down Expand Up @@ -248,12 +256,14 @@ fn resolve_struct_error<'b, 'a: 'b, 'tcx: 'a>(resolver: &'b Resolver<'a, 'tcx>,
ResolutionError::IsNotATrait(name) => {
struct_span_err!(resolver.session, span, E0404, "`{}` is not a trait", name)
}
ResolutionError::UndeclaredTraitName(name) => {
struct_span_err!(resolver.session,
span,
E0405,
"use of undeclared trait name `{}`",
name)
ResolutionError::UndeclaredTraitName(name, candidates) => {
let mut err = struct_span_err!(resolver.session,
span,
E0405,
"trait `{}` is not in scope",
name);
show_candidates(&mut err, span, &candidates);
err
}
ResolutionError::UndeclaredAssociatedType => {
struct_span_err!(resolver.session, span, E0406, "undeclared associated type")
Expand Down Expand Up @@ -313,13 +323,15 @@ fn resolve_struct_error<'b, 'a: 'b, 'tcx: 'a>(resolver: &'b Resolver<'a, 'tcx>,
E0411,
"use of `Self` outside of an impl or trait")
}
ResolutionError::UseOfUndeclared(kind, name) => {
struct_span_err!(resolver.session,
span,
E0412,
"use of undeclared {} `{}`",
kind,
name)
ResolutionError::UseOfUndeclared(kind, name, candidates) => {
let mut err = struct_span_err!(resolver.session,
span,
E0412,
"{} `{}` is undefined or not in scope",
kind,
name);
show_candidates(&mut err, span, &candidates);
err
}
ResolutionError::DeclarationShadowsEnumVariantOrUnitLikeStruct(name) => {
struct_span_err!(resolver.session,
Expand Down Expand Up @@ -839,6 +851,7 @@ pub struct ModuleS<'a> {
pub type Module<'a> = &'a ModuleS<'a>;

impl<'a> ModuleS<'a> {

fn new(parent_link: ParentLink<'a>, def: Option<Def>, external: bool, is_public: bool) -> Self {
ModuleS {
parent_link: parent_link,
Expand Down Expand Up @@ -1969,10 +1982,28 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
Err(())
}
} else {
resolve_error(self,
trait_path.span,
ResolutionError::UndeclaredTraitName(&path_names_to_string(trait_path,
path_depth)));

// find possible candidates
let trait_name = trait_path.segments.last().unwrap().identifier.name;
let candidates =
self.lookup_candidates(
trait_name,
TypeNS,
|def| match def {
Def::Trait(_) => true,
_ => false,
},
);

// create error object
let name = &path_names_to_string(trait_path, path_depth);
let error =
ResolutionError::UndeclaredTraitName(
name,
candidates,
);

resolve_error(self, trait_path.span, error);
Err(())
}
}
Expand Down Expand Up @@ -2296,13 +2327,33 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
ty.span,
ResolutionError::SelfUsedOutsideImplOrTrait);
} else {
resolve_error(self,
ty.span,
ResolutionError::UseOfUndeclared(
kind,
&path_names_to_string(path,
0))
);
let segment = path.segments.last();
let segment = segment.expect("missing name in path");
let type_name = segment.identifier.name;

let candidates =
self.lookup_candidates(
type_name,
TypeNS,
|def| match def {
Def::Trait(_) |
Def::Enum(_) |
Def::Struct(_) |
Def::TyAlias(_) => true,
_ => false,
},
);

// create error object
let name = &path_names_to_string(path, 0);
let error =
ResolutionError::UseOfUndeclared(
kind,
name,
candidates,
);

resolve_error(self, ty.span, error);
}
}
}
Expand Down Expand Up @@ -3457,6 +3508,99 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
found_traits
}

/// When name resolution fails, this method can be used to look up candidate
/// entities with the expected name. It allows filtering them using the
/// supplied predicate (which should be used to only accept the types of
/// definitions expected e.g. traits). The lookup spans across all crates.
///
/// NOTE: The method does not look into imports, but this is not a problem,
/// since we report the definitions (thus, the de-aliased imports).
fn lookup_candidates<FilterFn>(&mut self,
lookup_name: Name,
namespace: Namespace,
filter_fn: FilterFn) -> SuggestedCandidates
where FilterFn: Fn(Def) -> bool {

let mut lookup_results = Vec::new();
let mut worklist = Vec::new();
worklist.push((self.graph_root, Vec::new(), false));

while let Some((in_module,
path_segments,
in_module_is_extern)) = worklist.pop() {
build_reduced_graph::populate_module_if_necessary(self, &in_module);

in_module.for_each_child(|name, ns, name_binding| {

// avoid imports entirely
if name_binding.is_import() { return; }

// collect results based on the filter function
if let Some(def) = name_binding.def() {
if name == lookup_name && ns == namespace && filter_fn(def) {
// create the path
let ident = hir::Ident::from_name(name);
let params = PathParameters::none();
let segment = PathSegment {
identifier: ident,
parameters: params,
};
let span = name_binding.span.unwrap_or(syntax::codemap::DUMMY_SP);
let mut segms = path_segments.clone();
segms.push(segment);
let segms = HirVec::from_vec(segms);
let path = Path {
span: span,
global: true,
segments: segms,
};
// the entity is accessible in the following cases:
// 1. if it's defined in the same crate, it's always
// accessible (since private entities can be made public)
// 2. if it's defined in another crate, it's accessible
// only if both the module is public and the entity is
// declared as public (due to pruning, we don't explore
// outside crate private modules => no need to check this)
if !in_module_is_extern || name_binding.is_public() {
lookup_results.push(path);
}
}
}

// collect submodules to explore
if let Some(module) = name_binding.module() {
// form the path
let path_segments = match module.parent_link {
NoParentLink => path_segments.clone(),
ModuleParentLink(_, name) => {
let mut paths = path_segments.clone();
let ident = hir::Ident::from_name(name);
let params = PathParameters::none();
let segm = PathSegment {
identifier: ident,
parameters: params,
};
paths.push(segm);
paths
}
_ => unreachable!(),
};

if !in_module_is_extern || name_binding.is_public() {
// add the module to the lookup
let is_extern = in_module_is_extern || module.is_extern_crate;
worklist.push((module, path_segments, is_extern));
}
}
})
}

SuggestedCandidates {
name: lookup_name.as_str().to_string(),
candidates: lookup_results,
}
}

fn record_def(&mut self, node_id: NodeId, resolution: PathResolution) {
debug!("(recording def) recording {:?} for {}", resolution, node_id);
assert!(match resolution.last_private {
Expand Down Expand Up @@ -3512,6 +3656,67 @@ fn path_names_to_string(path: &Path, depth: usize) -> String {
names_to_string(&names[..])
}

/// When an entity with a given name is not available in scope, we search for
/// entities with that name in all crates. This method allows outputting the
/// results of this search in a programmer-friendly way
fn show_candidates(session: &mut DiagnosticBuilder,
span: syntax::codemap::Span,
candidates: &SuggestedCandidates) {

let paths = &candidates.candidates;

if paths.len() > 0 {
// don't show more than MAX_CANDIDATES results, so
// we're consistent with the trait suggestions
const MAX_CANDIDATES: usize = 5;

// we want consistent results across executions, but candidates are produced
// by iterating through a hash map, so make sure they are ordered:
let mut path_strings: Vec<_> = paths.into_iter()
.map(|p| path_names_to_string(&p, 0))
.collect();
path_strings.sort();

// behave differently based on how many candidates we have:
if !paths.is_empty() {
if paths.len() == 1 {
session.fileline_help(
span,
&format!("you can to import it into scope: `use {};`.",
&path_strings[0]),
);
} else {
session.fileline_help(span, "you can import several candidates \
into scope (`use ...;`):");
let count = path_strings.len() as isize - MAX_CANDIDATES as isize + 1;

for (idx, path_string) in path_strings.iter().enumerate() {
if idx == MAX_CANDIDATES - 1 && count > 1 {
session.fileline_help(
span,
&format!(" and {} other candidates", count).to_string(),
);
break;
} else {
session.fileline_help(
span,
&format!(" `{}`", path_string).to_string(),
);
}
}
}
}
} else {
// nothing found:
session.fileline_help(
span,
&format!("no candidates by the name of `{}` found in your \
project; maybe you misspelled the name or forgot to import \
an external crate?", candidates.name.to_string()),
);
};
}

/// A somewhat inefficient routine to obtain the name of a module.
fn module_to_string<'a>(module: Module<'a>) -> String {
let mut names = Vec::new();
Expand Down
Loading