Skip to content

Commit

Permalink
Rollup merge of rust-lang#96507 - TaKO8Ki:suggest-calling-associated-…
Browse files Browse the repository at this point in the history 
…function, r=lcnr

Suggest calling `Self::associated_function()`

closes rust-lang#96453
  • Loading branch information
@matthiaskrgr
matthiaskrgr authored May 5, 2022
2 parents 3f07303 + df25189 commit 34bf620
Show file tree
Hide file tree
Showing 5 changed files with 147 additions and 34 deletions.
5 changes: 5 additions & 0 deletions compiler/rustc_resolve/src/late.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -486,6 +486,9 @@ struct DiagnosticMetadata<'ast> {
current_where_predicate: Option<&'ast WherePredicate>,

current_type_path: Option<&'ast Ty>,

/// The current impl items (used to suggest).
current_impl_items: Option<&'ast [P<AssocItem>]>,
}

struct LateResolutionVisitor<'a, 'b, 'ast> {
Expand Down Expand Up @@ -1637,7 +1640,9 @@ impl<'a: 'ast, 'b, 'ast> LateResolutionVisitor<'a, 'b, 'ast> {
items: ref impl_items,
..
}) => {
self.diagnostic_metadata.current_impl_items = Some(impl_items);
self.resolve_implementation(generics, of_trait, &self_ty, item.id, impl_items);
self.diagnostic_metadata.current_impl_items = None;
}

ItemKind::Trait(box Trait { ref generics, ref bounds, ref items, .. }) => {
Expand Down
109 changes: 75 additions & 34 deletions compiler/rustc_resolve/src/late/diagnostics.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -6,7 +6,7 @@ use crate::path_names_to_string;
use crate::{Module, ModuleKind, ModuleOrUniformRoot};
use crate::{PathResult, PathSource, Segment};

use rustc_ast::visit::FnKind;
use rustc_ast::visit::{FnCtxt, FnKind};
use rustc_ast::{
self as ast, AssocItemKind, Expr, ExprKind, GenericParam, GenericParamKind, Item, ItemKind,
NodeId, Path, Ty, TyKind,
Expand Down Expand Up @@ -144,15 +144,22 @@ impl<'a: 'ast, 'ast> LateResolutionVisitor<'a, '_, 'ast> {
let is_enum_variant = &|res| matches!(res, Res::Def(DefKind::Variant, _));

// Make the base error.
struct BaseError<'a> {
msg: String,
fallback_label: String,
span: Span,
could_be_expr: bool,
suggestion: Option<(Span, &'a str, String)>,
}
let mut expected = source.descr_expected();
let path_str = Segment::names_to_string(path);
let item_str = path.last().unwrap().ident;
let (base_msg, fallback_label, base_span, could_be_expr) = if let Some(res) = res {
(
format!("expected {}, found {} `{}`", expected, res.descr(), path_str),
format!("not a {}", expected),
let base_error = if let Some(res) = res {
BaseError {
msg: format!("expected {}, found {} `{}`", expected, res.descr(), path_str),
fallback_label: format!("not a {expected}"),
span,
match res {
could_be_expr: match res {
Res::Def(DefKind::Fn, _) => {
// Verify whether this is a fn call or an Fn used as a type.
self.r
Expand All @@ -171,45 +178,78 @@ impl<'a: 'ast, 'ast> LateResolutionVisitor<'a, '_, 'ast> {
| Res::Local(_) => true,
_ => false,
},
)
suggestion: None,
}
} else {
let item_span = path.last().unwrap().ident.span;
let (mod_prefix, mod_str) = if path.len() == 1 {
(String::new(), "this scope".to_string())
let (mod_prefix, mod_str, suggestion) = if path.len() == 1 {
debug!(?self.diagnostic_metadata.current_impl_items);
debug!(?self.diagnostic_metadata.current_function);
let suggestion = if let Some(items) = self.diagnostic_metadata.current_impl_items
&& let Some((fn_kind, _)) = self.diagnostic_metadata.current_function
&& self.current_trait_ref.is_none()
&& let Some(FnCtxt::Assoc(_)) = fn_kind.ctxt()
&& let Some(item) = items.iter().find(|i| {
if let AssocItemKind::Fn(fn_) = &i.kind
&& !fn_.sig.decl.has_self()
&& i.ident.name == item_str.name
{
debug!(?item_str.name);
debug!(?fn_.sig.decl.inputs);
return true
}
false
})
{
Some((
item_span,
"consider using the associated function",
format!("Self::{}", item.ident)
))
} else {
None
};
(String::new(), "this scope".to_string(), suggestion)
} else if path.len() == 2 && path[0].ident.name == kw::PathRoot {
if self.r.session.edition() > Edition::Edition2015 {
// In edition 2018 onwards, the `::foo` syntax may only pull from the extern prelude
// which overrides all other expectations of item type
expected = "crate";
(String::new(), "the list of imported crates".to_string())
(String::new(), "the list of imported crates".to_string(), None)
} else {
(String::new(), "the crate root".to_string())
(String::new(), "the crate root".to_string(), None)
}
} else if path.len() == 2 && path[0].ident.name == kw::Crate {
(String::new(), "the crate root".to_string())
(String::new(), "the crate root".to_string(), None)
} else {
let mod_path = &path[..path.len() - 1];
let mod_prefix = match self.resolve_path(mod_path, Some(TypeNS), None) {
PathResult::Module(ModuleOrUniformRoot::Module(module)) => module.res(),
_ => None,
}
.map_or_else(String::new, |res| format!("{} ", res.descr()));
(mod_prefix, format!("`{}`", Segment::names_to_string(mod_path)))
(mod_prefix, format!("`{}`", Segment::names_to_string(mod_path)), None)
};
(
format!("cannot find {} `{}` in {}{}", expected, item_str, mod_prefix, mod_str),
if path_str == "async" && expected.starts_with("struct") {
BaseError {
msg: format!("cannot find {expected} `{item_str}` in {mod_prefix}{mod_str}"),
fallback_label: if path_str == "async" && expected.starts_with("struct") {
"`async` blocks are only allowed in Rust 2018 or later".to_string()
} else {
format!("not found in {}", mod_str)
format!("not found in {mod_str}")
},
item_span,
false,
)
span: item_span,
could_be_expr: false,
suggestion,
}
};

let code = source.error_code(res.is_some());
let mut err = self.r.session.struct_span_err_with_code(base_span, &base_msg, code);
let mut err =
self.r.session.struct_span_err_with_code(base_error.span, &base_error.msg, code);

if let Some(sugg) = base_error.suggestion {
err.span_suggestion_verbose(sugg.0, sugg.1, sugg.2, Applicability::MaybeIncorrect);
}

if let Some(span) = self.diagnostic_metadata.current_block_could_be_bare_struct_literal {
err.multipart_suggestion(
Expand Down Expand Up @@ -269,7 +309,7 @@ impl<'a: 'ast, 'ast> LateResolutionVisitor<'a, '_, 'ast> {
}
}

self.detect_assoct_type_constraint_meant_as_path(base_span, &mut err);
self.detect_assoct_type_constraint_meant_as_path(base_error.span, &mut err);

// Emit special messages for unresolved `Self` and `self`.
if is_self_type(path, ns) {
Expand Down Expand Up @@ -471,16 +511,17 @@ impl<'a: 'ast, 'ast> LateResolutionVisitor<'a, '_, 'ast> {
source,
res,
&path_str,
&fallback_label,
&base_error.fallback_label,
) {
// We do this to avoid losing a secondary span when we override the main error span.
self.r.add_typo_suggestion(&mut err, typo_sugg, ident_span);
return (err, candidates);
}
}

let is_macro = base_span.from_expansion() && base_span.desugaring_kind().is_none();
if !self.type_ascription_suggestion(&mut err, base_span) {
let is_macro =
base_error.span.from_expansion() && base_error.span.desugaring_kind().is_none();
if !self.type_ascription_suggestion(&mut err, base_error.span) {
let mut fallback = false;
if let (
PathSource::Trait(AliasPossibility::Maybe),
Expand All @@ -493,7 +534,7 @@ impl<'a: 'ast, 'ast> LateResolutionVisitor<'a, '_, 'ast> {
let spans: Vec<Span> = bounds
.iter()
.map(|bound| bound.span())
.filter(|&sp| sp != base_span)
.filter(|&sp| sp != base_error.span)
.collect();

let start_span = bounds.iter().map(|bound| bound.span()).next().unwrap();
Expand All @@ -515,7 +556,7 @@ impl<'a: 'ast, 'ast> LateResolutionVisitor<'a, '_, 'ast> {
multi_span.push_span_label(sp, msg);
}
multi_span.push_span_label(
base_span,
base_error.span,
"expected this type to be a trait...".to_string(),
);
err.span_help(
Expand All @@ -525,14 +566,14 @@ impl<'a: 'ast, 'ast> LateResolutionVisitor<'a, '_, 'ast> {
);
if bounds.iter().all(|bound| match bound {
ast::GenericBound::Outlives(_) => true,
ast::GenericBound::Trait(tr, _) => tr.span == base_span,
ast::GenericBound::Trait(tr, _) => tr.span == base_error.span,
}) {
let mut sugg = vec![];
if base_span != start_span {
sugg.push((start_span.until(base_span), String::new()));
if base_error.span != start_span {
sugg.push((start_span.until(base_error.span), String::new()));
}
if base_span != end_span {
sugg.push((base_span.shrink_to_hi().to(end_span), String::new()));
if base_error.span != end_span {
sugg.push((base_error.span.shrink_to_hi().to(end_span), String::new()));
}

err.multipart_suggestion(
Expand All @@ -550,7 +591,7 @@ impl<'a: 'ast, 'ast> LateResolutionVisitor<'a, '_, 'ast> {
fallback = true;
match self.diagnostic_metadata.current_let_binding {
Some((pat_sp, Some(ty_sp), None))
if ty_sp.contains(base_span) && could_be_expr =>
if ty_sp.contains(base_error.span) && base_error.could_be_expr =>
{
err.span_suggestion_short(
pat_sp.between(ty_sp),
Expand All @@ -568,7 +609,7 @@ impl<'a: 'ast, 'ast> LateResolutionVisitor<'a, '_, 'ast> {
}
if fallback {
// Fallback label.
err.span_label(base_span, fallback_label);
err.span_label(base_error.span, base_error.fallback_label);
}
}
if let Some(err_code) = &err.code {
Expand Down
10 changes: 10 additions & 0 deletions src/test/ui/resolve/issue-2356.stderr
View file
Original file line number Diff line number Diff line change
Expand Up @@ -48,6 +48,11 @@ error[E0425]: cannot find function `static_method` in this scope
|
LL | static_method();
| ^^^^^^^^^^^^^ not found in this scope
|
help: consider using the associated function
|
LL | Self::static_method();
| ~~~~~~~~~~~~~~~~~~~

error[E0425]: cannot find function `purr` in this scope
--> $DIR/issue-2356.rs:54:9
Expand Down Expand Up @@ -85,6 +90,11 @@ error[E0425]: cannot find function `grow_older` in this scope
|
LL | grow_older();
| ^^^^^^^^^^ not found in this scope
|
help: consider using the associated function
|
LL | Self::grow_older();
| ~~~~~~~~~~~~~~~~

error[E0425]: cannot find function `shave` in this scope
--> $DIR/issue-2356.rs:74:5
Expand Down
20 changes: 20 additions & 0 deletions src/test/ui/suggestions/assoc_fn_without_self.rs
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,20 @@
fn main() {}

struct S;

impl S {
fn foo() {}

fn bar(&self) {}

fn baz(a: u8, b: u8) {}

fn b() {
fn c() {
foo(); //~ ERROR cannot find function `foo` in this scope
}
foo(); //~ ERROR cannot find function `foo` in this scope
bar(); //~ ERROR cannot find function `bar` in this scope
baz(2, 3); //~ ERROR cannot find function `baz` in this scope
}
}
37 changes: 37 additions & 0 deletions src/test/ui/suggestions/assoc_fn_without_self.stderr
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,37 @@
error[E0425]: cannot find function `foo` in this scope
--> $DIR/assoc_fn_without_self.rs:14:13
|
LL | foo();
| ^^^ not found in this scope

error[E0425]: cannot find function `foo` in this scope
--> $DIR/assoc_fn_without_self.rs:16:9
|
LL | foo();
| ^^^ not found in this scope
|
help: consider using the associated function
|
LL | Self::foo();
| ~~~~~~~~~

error[E0425]: cannot find function `bar` in this scope
--> $DIR/assoc_fn_without_self.rs:17:9
|
LL | bar();
| ^^^ not found in this scope

error[E0425]: cannot find function `baz` in this scope
--> $DIR/assoc_fn_without_self.rs:18:9
|
LL | baz(2, 3);
| ^^^ not found in this scope
|
help: consider using the associated function
|
LL | Self::baz(2, 3);
| ~~~~~~~~~

error: aborting due to 4 previous errors

For more information about this error, try `rustc --explain E0425`.

0 comments on commit 34bf620

Please sign in to comment.