nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-25 16:24:46 +00:00
Code Issues Packages Projects Releases Wiki Activity

Auto merge of #116713 - estebank:issue-116703, r=compiler-errors

Browse Source 
Properly account for self ty in method disambiguation suggestion

Fix #116703.
This commit is contained in:
bors 2023-10-18 05:51:40 +00:00
commit b9832e72c9
31 changed files with 588 additions and 98 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
compiler/rustc_hir_analysis/src/astconv/mod.rs
View File

@ -1018,7 +1018,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
}
err.span_suggestions(
span,
"use the fully-qualified path",
"use fully-qualified syntax",
suggestions,
Applicability::MachineApplicable,
);
@ -1190,7 +1190,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
} else {
err.span_suggestion_verbose(
span.with_hi(assoc_name.span.lo()),
"use fully qualified syntax to disambiguate",
"use fully-qualified syntax to disambiguate",
format!("<{ty_param_name} as {}>::", bound.print_only_trait_path()),
Applicability::MaybeIncorrect,
);

102
compiler/rustc_hir_typeck/src/method/suggest.rs
View File

@ -1260,6 +1260,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
// Dynamic limit to avoid hiding just one candidate, which is silly.
let limit = if sources.len() == 5 { 5 } else { 4 };
let mut suggs = vec![];
for (idx, source) in sources.iter().take(limit).enumerate() {
match *source {
CandidateSource::Impl(impl_did) => {
@ -1322,7 +1323,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
let path = self.tcx.def_path_str(trait_ref.skip_binder().def_id);
let ty = match item.kind {
ty::AssocKind::Const | ty::AssocKind::Type => rcvr_ty,
ty::AssocKind::Const | ty::AssocKind::Type => impl_ty,
ty::AssocKind::Fn => self
.tcx
.fn_sig(item.def_id)
@ -1334,19 +1335,22 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
.copied()
.unwrap_or(rcvr_ty),
};
print_disambiguation_help(
if let Some(sugg) = print_disambiguation_help(
item_name,
args,
err,
path,
ty,
Some(impl_ty),
item.kind,
self.tcx.def_kind_descr(item.kind.as_def_kind(), item.def_id),
sugg_span,
idx,
self.tcx.sess.source_map(),
item.fn_has_self_parameter,
);
) {
suggs.push(sugg);
}
}
}
CandidateSource::Trait(trait_did) => {
@ -1370,23 +1374,34 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
};
if let Some(sugg_span) = sugg_span {
let path = self.tcx.def_path_str(trait_did);
print_disambiguation_help(
if let Some(sugg) = print_disambiguation_help(
item_name,
args,
err,
path,
rcvr_ty,
None,
item.kind,
self.tcx.def_kind_descr(item.kind.as_def_kind(), item.def_id),
sugg_span,
idx,
self.tcx.sess.source_map(),
item.fn_has_self_parameter,
);
) {
suggs.push(sugg);
}
}
}
}
}
if !suggs.is_empty() && let Some(span) = sugg_span {
err.span_suggestions(
span.with_hi(item_name.span.lo()),
"use fully-qualified syntax to disambiguate",
suggs,
Applicability::MachineApplicable,
);
}
if sources.len() > limit {
err.note(format!("and {} others", sources.len() - limit));
}
@ -3146,52 +3161,51 @@ fn print_disambiguation_help<'tcx>(
err: &mut Diagnostic,
trait_name: String,
rcvr_ty: Ty<'_>,
impl_self_ty: Option<Ty<'_>>,
kind: ty::AssocKind,
def_kind_descr: &'static str,
span: Span,
candidate: Option<usize>,
source_map: &source_map::SourceMap,
fn_has_self_parameter: bool,
) {
let mut applicability = Applicability::MachineApplicable;
let (span, sugg) = if let (
ty::AssocKind::Fn,
Some(MethodCallComponents { receiver, args, .. }),
) = (kind, args)
{
let args = format!(
"({}{})",
rcvr_ty.ref_mutability().map_or("", |mutbl| mutbl.ref_prefix_str()),
std::iter::once(receiver)
.chain(args.iter())
.map(|arg| source_map.span_to_snippet(arg.span).unwrap_or_else(|_| {
applicability = Applicability::HasPlaceholders;
"_".to_owned()
}))
.collect::<Vec<_>>()
.join(", "),
);
let trait_name = if !fn_has_self_parameter {
format!("<{rcvr_ty} as {trait_name}>")
) -> Option<String> {
Some(
if let (ty::AssocKind::Fn, Some(MethodCallComponents { receiver, args, .. })) = (kind, args)
{
let args = format!(
"({}{})",
rcvr_ty.ref_mutability().map_or("", |mutbl| mutbl.ref_prefix_str()),
std::iter::once(receiver)
.chain(args.iter())
.map(|arg| source_map
.span_to_snippet(arg.span)
.unwrap_or_else(|_| { "_".to_owned() }))
.collect::<Vec<_>>()
.join(", "),
);
let trait_name = if !fn_has_self_parameter && let Some(impl_self_ty) = impl_self_ty {
format!("<{impl_self_ty} as {trait_name}>")
} else {
trait_name
};
(span, format!("{trait_name}::{item_name}{args}"))
} else {
(span.with_hi(item_name.span.lo()), format!("<{rcvr_ty} as {trait_name}>::"))
};
err.span_suggestion_verbose(
span,
format!(
"disambiguate the {} for {}",
def_kind_descr,
if let Some(candidate) = candidate {
format!("candidate #{candidate}")
} else {
"the candidate".to_string()
},
),
sugg,
applicability,
);
err.span_suggestion_verbose(
span,
format!(
"disambiguate the {def_kind_descr} for {}",
if let Some(candidate) = candidate {
format!("candidate #{candidate}")
} else {
"the candidate".to_string()
},
),
format!("{trait_name}::{item_name}{args}"),
Applicability::HasPlaceholders,
);
return None;
} else if let Some(impl_self_ty) = impl_self_ty {
format!("<{impl_self_ty} as {trait_name}>::")
} else {
format!("{trait_name}::")
},
)
}

8
tests/ui/associated-consts/associated-const-ambiguity-report.stderr
View File

@ -14,14 +14,12 @@ note: candidate #2 is defined in an impl of the trait `Bar` for the type `i32`
|
LL | const ID: i32 = 3;
| ^^^^^^^^^^^^^
help: disambiguate the associated constant for candidate #1
|
LL | const X: i32 = <i32 as Foo>::ID;
| ~~~~~~~~~~~~~~
help: disambiguate the associated constant for candidate #2
help: use fully-qualified syntax to disambiguate
|
LL | const X: i32 = <i32 as Bar>::ID;
| ~~~~~~~~~~~~~~
LL | const X: i32 = <i32 as Foo>::ID;
| ~~~~~~~~~~~~~~
error: aborting due to previous error

2
tests/ui/associated-inherent-types/issue-109071.no_gate.stderr
View File

@ -33,7 +33,7 @@ error[E0223]: ambiguous associated type
--> $DIR/issue-109071.rs:15:22
|
LL | fn T() -> Option<Self::Item> {}
| ^^^^^^^^^^ help: use the fully-qualified path: `<Windows<T> as IntoIterator>::Item`
| ^^^^^^^^^^ help: use fully-qualified syntax: `<Windows<T> as IntoIterator>::Item`
error: aborting due to 4 previous errors

2
tests/ui/associated-inherent-types/not-found-self-type-differs-shadowing-trait-item.uncovered.stderr
View File

@ -2,7 +2,7 @@ error[E0223]: ambiguous associated type
--> $DIR/not-found-self-type-differs-shadowing-trait-item.rs:28:12
|
LL | let _: S::<bool>::Pr = ();
| ^^^^^^^^^^^^^ help: use the fully-qualified path: `<S<bool> as Tr>::Pr`
| ^^^^^^^^^^^^^ help: use fully-qualified syntax: `<S<bool> as Tr>::Pr`
error: aborting due to previous error

2
tests/ui/associated-item/ambiguous-associated-type-with-generics.stderr
View File

@ -2,7 +2,7 @@ error[E0223]: ambiguous associated type
--> $DIR/ambiguous-associated-type-with-generics.rs:13:13
|
LL | let _x: <dyn Trait<i32>>::Ty;
| ^^^^^^^^^^^^^^^^^^^^ help: use the fully-qualified path: `<dyn Trait<i32> as Assoc>::Ty`
| ^^^^^^^^^^^^^^^^^^^^ help: use fully-qualified syntax: `<dyn Trait<i32> as Assoc>::Ty`
error: aborting due to previous error

2
tests/ui/associated-item/associated-item-duplicate-names-3.stderr
View File

@ -13,7 +13,7 @@ error[E0223]: ambiguous associated type
--> $DIR/associated-item-duplicate-names-3.rs:18:12
|
LL | let x: Baz::Bar = 5;
| ^^^^^^^^ help: use the fully-qualified path: `<Baz as Foo>::Bar`
| ^^^^^^^^ help: use fully-qualified syntax: `<Baz as Foo>::Bar`
error: aborting due to 2 previous errors

24
tests/ui/associated-types/associated-type-projection-ambig-between-bound-and-where-clause.stderr
View File

@ -10,11 +10,11 @@ LL | type Color;
LL | fn a<C:Vehicle+Box>(_: C::Color) {
| ^^^^^^^^ ambiguous associated type `Color`
|
help: use fully qualified syntax to disambiguate
help: use fully-qualified syntax to disambiguate
|
LL | fn a<C:Vehicle+Box>(_: <C as Box>::Color) {
| ~~~~~~~~~~~~
help: use fully qualified syntax to disambiguate
help: use fully-qualified syntax to disambiguate
|
LL | fn a<C:Vehicle+Box>(_: <C as Vehicle>::Color) {
| ~~~~~~~~~~~~~~~~
@ -31,11 +31,11 @@ LL | type Color;
LL | fn b<C>(_: C::Color) where C : Vehicle+Box {
| ^^^^^^^^ ambiguous associated type `Color`
|
help: use fully qualified syntax to disambiguate
help: use fully-qualified syntax to disambiguate
|
LL | fn b<C>(_: <C as Box>::Color) where C : Vehicle+Box {
| ~~~~~~~~~~~~
help: use fully qualified syntax to disambiguate
help: use fully-qualified syntax to disambiguate
|
LL | fn b<C>(_: <C as Vehicle>::Color) where C : Vehicle+Box {
| ~~~~~~~~~~~~~~~~
@ -52,11 +52,11 @@ LL | type Color;
LL | fn c<C>(_: C::Color) where C : Vehicle, C : Box {
| ^^^^^^^^ ambiguous associated type `Color`
|
help: use fully qualified syntax to disambiguate
help: use fully-qualified syntax to disambiguate
|
LL | fn c<C>(_: <C as Box>::Color) where C : Vehicle, C : Box {
| ~~~~~~~~~~~~
help: use fully qualified syntax to disambiguate
help: use fully-qualified syntax to disambiguate
|
LL | fn c<C>(_: <C as Vehicle>::Color) where C : Vehicle, C : Box {
| ~~~~~~~~~~~~~~~~
@ -73,11 +73,11 @@ LL | type Color;
LL | fn e(&self, _: X::Color) where X : Box;
| ^^^^^^^^ ambiguous associated type `Color`
|
help: use fully qualified syntax to disambiguate
help: use fully-qualified syntax to disambiguate
|
LL | fn e(&self, _: <X as Box>::Color) where X : Box;
| ~~~~~~~~~~~~
help: use fully qualified syntax to disambiguate
help: use fully-qualified syntax to disambiguate
|
LL | fn e(&self, _: <X as Vehicle>::Color) where X : Box;
| ~~~~~~~~~~~~~~~~
@ -94,11 +94,11 @@ LL | type Color;
LL | fn f(&self, _: X::Color) where X : Box { }
| ^^^^^^^^ ambiguous associated type `Color`
|
help: use fully qualified syntax to disambiguate
help: use fully-qualified syntax to disambiguate
|
LL | fn f(&self, _: <X as Box>::Color) where X : Box { }
| ~~~~~~~~~~~~
help: use fully qualified syntax to disambiguate
help: use fully-qualified syntax to disambiguate
|
LL | fn f(&self, _: <X as Vehicle>::Color) where X : Box { }
| ~~~~~~~~~~~~~~~~
@ -115,11 +115,11 @@ LL | type Color;
LL | fn d(&self, _: X::Color) where X : Box { }
| ^^^^^^^^ ambiguous associated type `Color`
|
help: use fully qualified syntax to disambiguate
help: use fully-qualified syntax to disambiguate
|
LL | fn d(&self, _: <X as Box>::Color) where X : Box { }
| ~~~~~~~~~~~~
help: use fully qualified syntax to disambiguate
help: use fully-qualified syntax to disambiguate
|
LL | fn d(&self, _: <X as Vehicle>::Color) where X : Box { }
| ~~~~~~~~~~~~~~~~

8
tests/ui/associated-types/associated-type-projection-from-multiple-supertraits.stderr
View File

@ -18,11 +18,11 @@ LL | type Color;
LL | fn dent<C:BoxCar>(c: C, color: C::Color) {
| ^^^^^^^^ ambiguous associated type `Color`
|
help: use fully qualified syntax to disambiguate
help: use fully-qualified syntax to disambiguate
|
LL | fn dent<C:BoxCar>(c: C, color: <C as Vehicle>::Color) {
| ~~~~~~~~~~~~~~~~
help: use fully qualified syntax to disambiguate
help: use fully-qualified syntax to disambiguate
|
LL | fn dent<C:BoxCar>(c: C, color: <C as Box>::Color) {
| ~~~~~~~~~~~~
@ -71,11 +71,11 @@ LL | type Color;
LL | fn paint<C:BoxCar>(c: C, d: C::Color) {
| ^^^^^^^^ ambiguous associated type `Color`
|
help: use fully qualified syntax to disambiguate
help: use fully-qualified syntax to disambiguate
|
LL | fn paint<C:BoxCar>(c: C, d: <C as Vehicle>::Color) {
| ~~~~~~~~~~~~~~~~
help: use fully qualified syntax to disambiguate
help: use fully-qualified syntax to disambiguate
|
LL | fn paint<C:BoxCar>(c: C, d: <C as Box>::Color) {
| ~~~~~~~~~~~~

6
tests/ui/associated-types/associated-types-in-ambiguous-context.stderr
View File

@ -13,7 +13,7 @@ error[E0223]: ambiguous associated type
--> $DIR/associated-types-in-ambiguous-context.rs:22:17
|
LL | trait Foo where Foo::Assoc: Bar {
| ^^^^^^^^^^ help: use the fully-qualified path: `<Self as Foo>::Assoc`
| ^^^^^^^^^^ help: use fully-qualified syntax: `<Self as Foo>::Assoc`
error[E0223]: ambiguous associated type
--> $DIR/associated-types-in-ambiguous-context.rs:27:10
@ -21,7 +21,7 @@ error[E0223]: ambiguous associated type
LL | type X = std::ops::Deref::Target;
| ^^^^^^^^^^^^^^^^^^^^^^^
|
help: use the fully-qualified path
help: use fully-qualified syntax
|
LL | type X = <CString as Deref>::Target;
| ~~~~~~~~~~~~~~~~~~~~~~~~~~
@ -37,7 +37,7 @@ error[E0223]: ambiguous associated type
--> $DIR/associated-types-in-ambiguous-context.rs:13:23
|
LL | fn grab(&self) -> Grab::Value;
| ^^^^^^^^^^^ help: use the fully-qualified path: `<Self as Grab>::Value`
| ^^^^^^^^^^^ help: use fully-qualified syntax: `<Self as Grab>::Value`
error[E0223]: ambiguous associated type
--> $DIR/associated-types-in-ambiguous-context.rs:16:22

4
tests/ui/associated-types/associated-types-path-1.stderr
View File

@ -16,11 +16,11 @@ LL | type A;
LL | pub fn f2<T: Foo + Bar>(a: T, x: T::A) {}
| ^^^^ ambiguous associated type `A`
|
help: use fully qualified syntax to disambiguate
help: use fully-qualified syntax to disambiguate
|
LL | pub fn f2<T: Foo + Bar>(a: T, x: <T as Bar>::A) {}
| ~~~~~~~~~~~~
help: use fully qualified syntax to disambiguate
help: use fully-qualified syntax to disambiguate
|
LL | pub fn f2<T: Foo + Bar>(a: T, x: <T as Foo>::A) {}
| ~~~~~~~~~~~~

2
tests/ui/did_you_mean/bad-assoc-ty.stderr
View File

@ -191,7 +191,7 @@ error[E0223]: ambiguous associated type
--> $DIR/bad-assoc-ty.rs:33:10
|
LL | type H = Fn(u8) -> (u8)::Output;
| ^^^^^^^^^^^^^^^^^^^^^^ help: use the fully-qualified path: `<(dyn Fn(u8) -> u8 + 'static) as IntoFuture>::Output`
| ^^^^^^^^^^^^^^^^^^^^^^ help: use fully-qualified syntax: `<(dyn Fn(u8) -> u8 + 'static) as IntoFuture>::Output`
error[E0223]: ambiguous associated type
--> $DIR/bad-assoc-ty.rs:39:19

4
tests/ui/error-codes/E0034.stderr
View File

@ -14,12 +14,10 @@ note: candidate #2 is defined in an impl of the trait `Trait2` for the type `Tes
|
LL | fn foo() {}
| ^^^^^^^^
help: disambiguate the associated function for candidate #1
help: use fully-qualified syntax to disambiguate
|
LL | <Test as Trait1>::foo()
| ~~~~~~~~~~~~~~~~~~
help: disambiguate the associated function for candidate #2
|
LL | <Test as Trait2>::foo()
| ~~~~~~~~~~~~~~~~~~

6
tests/ui/error-codes/E0221.stderr
View File

@ -10,11 +10,11 @@ LL | fn do_something() {
LL | let _: Self::A;
| ^^^^^^^ ambiguous associated type `A`
|
help: use fully qualified syntax to disambiguate
help: use fully-qualified syntax to disambiguate
|
LL | let _: <Self as Foo>::A;
| ~~~~~~~~~~~~~~~
help: use fully qualified syntax to disambiguate
help: use fully-qualified syntax to disambiguate
|
LL | let _: <Self as Bar>::A;
| ~~~~~~~~~~~~~~~
@ -29,7 +29,7 @@ LL | let _: Self::Err;
| ^^^^^^^^^ ambiguous associated type `Err`
|
= note: associated type `Self` could derive from `FromStr`
help: use fully qualified syntax to disambiguate
help: use fully-qualified syntax to disambiguate
|
LL | let _: <Self as My>::Err;
| ~~~~~~~~~~~~~~

2
tests/ui/error-codes/E0223.stderr
View File

@ -2,7 +2,7 @@ error[E0223]: ambiguous associated type
--> $DIR/E0223.rs:8:14
|
LL | let foo: MyTrait::X;
| ^^^^^^^^^^ help: use the fully-qualified path: `<MyStruct as MyTrait>::X`
| ^^^^^^^^^^ help: use fully-qualified syntax: `<MyStruct as MyTrait>::X`
error: aborting due to previous error

2
tests/ui/lint/bare-trait-objects-path.stderr
View File

@ -16,7 +16,7 @@ error[E0223]: ambiguous associated type
--> $DIR/bare-trait-objects-path.rs:23:12
|
LL | let _: Dyn::Ty;
| ^^^^^^^ help: use the fully-qualified path: `<dyn Dyn as Assoc>::Ty`
| ^^^^^^^ help: use fully-qualified syntax: `<dyn Dyn as Assoc>::Ty`
warning: trait objects without an explicit `dyn` are deprecated
--> $DIR/bare-trait-objects-path.rs:14:5

38
tests/ui/methods/disambiguate-multiple-blanket-impl.rs Normal file
View File

@ -0,0 +1,38 @@
trait A {
type Type;
const CONST: usize;
fn foo(&self);
}
trait B {
type Type;
const CONST: usize;
fn foo(&self);
}
#[derive(Debug)]
struct S;
impl<T: std::fmt::Debug> A for T {
type Type = ();
const CONST: usize = 1; //~ NOTE candidate #1
fn foo(&self) {} //~ NOTE candidate #1
}
impl<T: std::fmt::Debug> B for T {
type Type = ();
const CONST: usize = 2; //~ NOTE candidate #2
fn foo(&self) {} //~ NOTE candidate #2
}
fn main() {
let s = S;
S::foo(&s); //~ ERROR multiple applicable items in scope
//~^ NOTE multiple `foo` found
//~| HELP use fully-qualified syntax to disambiguate
S::CONST; //~ ERROR multiple applicable items in scope
//~^ NOTE multiple `CONST` found
//~| HELP use fully-qualified syntax to disambiguate
let _: S::Type; //~ ERROR ambiguous associated type
//~^ HELP use fully-qualified syntax
}

63
tests/ui/methods/disambiguate-multiple-blanket-impl.stderr Normal file
View File

@ -0,0 +1,63 @@
error[E0223]: ambiguous associated type
--> $DIR/disambiguate-multiple-blanket-impl.rs:36:12
|
LL | let _: S::Type;
| ^^^^^^^
|
help: use fully-qualified syntax
|
LL | let _: <S as A>::Type;
| ~~~~~~~~~~~~~~
LL | let _: <S as B>::Type;
| ~~~~~~~~~~~~~~
error[E0034]: multiple applicable items in scope
--> $DIR/disambiguate-multiple-blanket-impl.rs:30:8
|
LL | S::foo(&s);
| ^^^ multiple `foo` found
|
note: candidate #1 is defined in an impl of the trait `A` for the type `T`
--> $DIR/disambiguate-multiple-blanket-impl.rs:19:5
|
LL | fn foo(&self) {}
| ^^^^^^^^^^^^^
note: candidate #2 is defined in an impl of the trait `B` for the type `T`
--> $DIR/disambiguate-multiple-blanket-impl.rs:25:5
|
LL | fn foo(&self) {}
| ^^^^^^^^^^^^^
help: use fully-qualified syntax to disambiguate
|
LL | <T as A>::foo(&s);
| ~~~~~~~~~~
LL | <T as B>::foo(&s);
| ~~~~~~~~~~
error[E0034]: multiple applicable items in scope
--> $DIR/disambiguate-multiple-blanket-impl.rs:33:8
|
LL | S::CONST;
| ^^^^^ multiple `CONST` found
|
note: candidate #1 is defined in an impl of the trait `A` for the type `T`
--> $DIR/disambiguate-multiple-blanket-impl.rs:18:5
|
LL | const CONST: usize = 1;
| ^^^^^^^^^^^^^^^^^^
note: candidate #2 is defined in an impl of the trait `B` for the type `T`
--> $DIR/disambiguate-multiple-blanket-impl.rs:24:5
|
LL | const CONST: usize = 2;
| ^^^^^^^^^^^^^^^^^^
help: use fully-qualified syntax to disambiguate
|
LL | <T as A>::CONST;
| ~~~~~~~~~~
LL | <T as B>::CONST;
| ~~~~~~~~~~
error: aborting due to 3 previous errors
Some errors have detailed explanations: E0034, E0223.
For more information about an error, try `rustc --explain E0034`.

37
tests/ui/methods/disambiguate-multiple-impl.rs Normal file
View File

@ -0,0 +1,37 @@
trait A {
type Type;
const CONST: usize;
fn foo(&self);
}
trait B {
type Type;
const CONST: usize;
fn foo(&self);
}
struct S;
impl A for S {
type Type = ();
const CONST: usize = 1; //~ NOTE candidate #1
fn foo(&self) {} //~ NOTE candidate #1
}
impl B for S {
type Type = ();
const CONST: usize = 2; //~ NOTE candidate #2
fn foo(&self) {} //~ NOTE candidate #2
}
fn main() {
let s = S;
S::foo(&s); //~ ERROR multiple applicable items in scope
//~^ NOTE multiple `foo` found
//~| HELP use fully-qualified syntax
let _: S::Type = (); //~ ERROR ambiguous associated type
//~| HELP use fully-qualified syntax
let _ = S::CONST; //~ ERROR multiple applicable items in scope
//~^ NOTE multiple `CONST` found
//~| HELP use fully-qualified syntax
}

63
tests/ui/methods/disambiguate-multiple-impl.stderr Normal file
View File

@ -0,0 +1,63 @@
error[E0223]: ambiguous associated type
--> $DIR/disambiguate-multiple-impl.rs:32:12
|
LL | let _: S::Type = ();
| ^^^^^^^
|
help: use fully-qualified syntax
|
LL | let _: <S as A>::Type = ();
| ~~~~~~~~~~~~~~
LL | let _: <S as B>::Type = ();
| ~~~~~~~~~~~~~~
error[E0034]: multiple applicable items in scope
--> $DIR/disambiguate-multiple-impl.rs:29:8
|
LL | S::foo(&s);
| ^^^ multiple `foo` found
|
note: candidate #1 is defined in an impl of the trait `A` for the type `S`
--> $DIR/disambiguate-multiple-impl.rs:18:5
|
LL | fn foo(&self) {}
| ^^^^^^^^^^^^^
note: candidate #2 is defined in an impl of the trait `B` for the type `S`
--> $DIR/disambiguate-multiple-impl.rs:24:5
|
LL | fn foo(&self) {}
| ^^^^^^^^^^^^^
help: use fully-qualified syntax to disambiguate
|
LL | <S as A>::foo(&s);
| ~~~~~~~~~~
LL | <S as B>::foo(&s);
| ~~~~~~~~~~
error[E0034]: multiple applicable items in scope
--> $DIR/disambiguate-multiple-impl.rs:34:16
|
LL | let _ = S::CONST;
| ^^^^^ multiple `CONST` found
|
note: candidate #1 is defined in an impl of the trait `A` for the type `S`
--> $DIR/disambiguate-multiple-impl.rs:17:5
|
LL | const CONST: usize = 1;
| ^^^^^^^^^^^^^^^^^^
note: candidate #2 is defined in an impl of the trait `B` for the type `S`
--> $DIR/disambiguate-multiple-impl.rs:23:5
|
LL | const CONST: usize = 2;
| ^^^^^^^^^^^^^^^^^^
help: use fully-qualified syntax to disambiguate
|
LL | let _ = <S as A>::CONST;
| ~~~~~~~~~~
LL | let _ = <S as B>::CONST;
| ~~~~~~~~~~
error: aborting due to 3 previous errors
Some errors have detailed explanations: E0034, E0223.
For more information about an error, try `rustc --explain E0034`.

54
tests/ui/methods/disambiguate-multiple-trait-2.rs Normal file
View File

@ -0,0 +1,54 @@
trait A {
type Type; //~ NOTE ambiguous `Type` from `A`
const CONST: usize = 1; //~ NOTE candidate #1
fn foo(&self); //~ NOTE candidate #1
}
trait B {
type Type; //~ NOTE ambiguous `Type` from `B`
const CONST: usize; //~ NOTE candidate #2
fn foo(&self); //~ NOTE candidate #2
}
trait C: A + B {}
fn a<T: C>(t: T) {
t.foo(); //~ ERROR multiple applicable items in scope
//~^ NOTE multiple `foo` found
//~| HELP disambiguate the method
//~| HELP disambiguate the method
let _ = T::CONST; //~ ERROR multiple applicable items in scope
//~^ NOTE multiple `CONST` found
//~| HELP use fully-qualified syntax
let _: T::Type; //~ ERROR ambiguous associated type
//~^ NOTE ambiguous associated type `Type`
//~| HELP use fully-qualified syntax
//~| HELP use fully-qualified syntax
}
#[derive(Debug)]
struct S;
impl<T: std::fmt::Debug> A for T {
type Type = ();
const CONST: usize = 1; //~ NOTE candidate #1
fn foo(&self) {} //~ NOTE candidate #1
}
impl<T: std::fmt::Debug> B for T {
type Type = ();
const CONST: usize = 1; //~ NOTE candidate #2
fn foo(&self) {} //~ NOTE candidate #2
}
fn main() {
let s = S;
S::foo(&s); //~ ERROR multiple applicable items in scope
//~^ NOTE multiple `foo` found
//~| HELP use fully-qualified syntax
let _ = S::CONST; //~ ERROR multiple applicable items in scope
//~^ NOTE multiple `CONST` found
//~| HELP use fully-qualified syntax
let _: S::Type; //~ ERROR ambiguous associated type
//~^ HELP use fully-qualified syntax
}

132
tests/ui/methods/disambiguate-multiple-trait-2.stderr Normal file
View File

@ -0,0 +1,132 @@
error[E0221]: ambiguous associated type `Type` in bounds of `T`
--> $DIR/disambiguate-multiple-trait-2.rs:23:12
|
LL | type Type;
| --------- ambiguous `Type` from `A`
...
LL | type Type;
| --------- ambiguous `Type` from `B`
...
LL | let _: T::Type;
| ^^^^^^^ ambiguous associated type `Type`
|
help: use fully-qualified syntax to disambiguate
|
LL | let _: <T as A>::Type;
| ~~~~~~~~~~
help: use fully-qualified syntax to disambiguate
|
LL | let _: <T as B>::Type;
| ~~~~~~~~~~
error[E0034]: multiple applicable items in scope
--> $DIR/disambiguate-multiple-trait-2.rs:16:7
|
LL | t.foo();
| ^^^ multiple `foo` found
|
note: candidate #1 is defined in the trait `A`
--> $DIR/disambiguate-multiple-trait-2.rs:4:5
|
LL | fn foo(&self);
| ^^^^^^^^^^^^^^
note: candidate #2 is defined in the trait `B`
--> $DIR/disambiguate-multiple-trait-2.rs:10:5
|
LL | fn foo(&self);
| ^^^^^^^^^^^^^^
help: disambiguate the method for candidate #1
|
LL | A::foo(t);
| ~~~~~~~~~
help: disambiguate the method for candidate #2
|
LL | B::foo(t);
| ~~~~~~~~~
error[E0034]: multiple applicable items in scope
--> $DIR/disambiguate-multiple-trait-2.rs:20:16
|
LL | let _ = T::CONST;
| ^^^^^ multiple `CONST` found
|
note: candidate #1 is defined in the trait `A`
--> $DIR/disambiguate-multiple-trait-2.rs:3:5
|
LL | const CONST: usize = 1;
| ^^^^^^^^^^^^^^^^^^
note: candidate #2 is defined in the trait `B`
--> $DIR/disambiguate-multiple-trait-2.rs:9:5
|
LL | const CONST: usize;
| ^^^^^^^^^^^^^^^^^^
help: use fully-qualified syntax to disambiguate
|
LL | let _ = A::CONST;
| ~~~
LL | let _ = B::CONST;
| ~~~
error[E0223]: ambiguous associated type
--> $DIR/disambiguate-multiple-trait-2.rs:52:12
|
LL | let _: S::Type;
| ^^^^^^^
|
help: use fully-qualified syntax
|
LL | let _: <S as A>::Type;
| ~~~~~~~~~~~~~~
LL | let _: <S as B>::Type;
| ~~~~~~~~~~~~~~
error[E0034]: multiple applicable items in scope
--> $DIR/disambiguate-multiple-trait-2.rs:46:8
|
LL | S::foo(&s);
| ^^^ multiple `foo` found
|
note: candidate #1 is defined in an impl of the trait `A` for the type `T`
--> $DIR/disambiguate-multiple-trait-2.rs:35:5
|
LL | fn foo(&self) {}
| ^^^^^^^^^^^^^
note: candidate #2 is defined in an impl of the trait `B` for the type `T`
--> $DIR/disambiguate-multiple-trait-2.rs:41:5
|
LL | fn foo(&self) {}
| ^^^^^^^^^^^^^
help: use fully-qualified syntax to disambiguate
|
LL | <T as A>::foo(&s);
| ~~~~~~~~~~
LL | <T as B>::foo(&s);
| ~~~~~~~~~~
error[E0034]: multiple applicable items in scope
--> $DIR/disambiguate-multiple-trait-2.rs:49:16
|
LL | let _ = S::CONST;
| ^^^^^ multiple `CONST` found
|
note: candidate #1 is defined in an impl of the trait `A` for the type `T`
--> $DIR/disambiguate-multiple-trait-2.rs:34:5
|
LL | const CONST: usize = 1;
| ^^^^^^^^^^^^^^^^^^
note: candidate #2 is defined in an impl of the trait `B` for the type `T`
--> $DIR/disambiguate-multiple-trait-2.rs:40:5
|
LL | const CONST: usize = 1;
| ^^^^^^^^^^^^^^^^^^
help: use fully-qualified syntax to disambiguate
|
LL | let _ = <T as A>::CONST;
| ~~~~~~~~~~
LL | let _ = <T as B>::CONST;
| ~~~~~~~~~~
error: aborting due to 6 previous errors
Some errors have detailed explanations: E0034, E0221, E0223.
For more information about an error, try `rustc --explain E0034`.

32
tests/ui/methods/disambiguate-multiple-trait.rs Normal file
View File

@ -0,0 +1,32 @@
#![feature(associated_type_defaults)]
trait A {
type Type = ();
const CONST: usize = 1; //~ NOTE candidate #1
fn foo(&self) {} //~ NOTE candidate #1
}
trait B {
type Type = ();
const CONST: usize = 2; //~ NOTE candidate #2
fn foo(&self) {} //~ NOTE candidate #2
}
#[derive(Debug)]
struct S;
impl<T: std::fmt::Debug> A for T {}
impl<T: std::fmt::Debug> B for T {}
fn main() {
let s = S;
S::foo(&s); //~ ERROR multiple applicable items in scope
//~^ NOTE multiple `foo` found
//~| HELP use fully-qualified syntax
let _ = S::CONST; //~ ERROR multiple applicable items in scope
//~^ NOTE multiple `CONST` found
//~| HELP use fully-qualified syntax
let _: S::Type; //~ ERROR ambiguous associated type
//~^ HELP use fully-qualified syntax
}

63
tests/ui/methods/disambiguate-multiple-trait.stderr Normal file
View File

@ -0,0 +1,63 @@
error[E0223]: ambiguous associated type
--> $DIR/disambiguate-multiple-trait.rs:30:12
|
LL | let _: S::Type;
| ^^^^^^^
|
help: use fully-qualified syntax
|
LL | let _: <S as A>::Type;
| ~~~~~~~~~~~~~~
LL | let _: <S as B>::Type;
| ~~~~~~~~~~~~~~
error[E0034]: multiple applicable items in scope
--> $DIR/disambiguate-multiple-trait.rs:24:8
|
LL | S::foo(&s);
| ^^^ multiple `foo` found
|
note: candidate #1 is defined in an impl of the trait `A` for the type `T`
--> $DIR/disambiguate-multiple-trait.rs:6:5
|
LL | fn foo(&self) {}
| ^^^^^^^^^^^^^
note: candidate #2 is defined in an impl of the trait `B` for the type `T`
--> $DIR/disambiguate-multiple-trait.rs:12:5
|
LL | fn foo(&self) {}
| ^^^^^^^^^^^^^
help: use fully-qualified syntax to disambiguate
|
LL | <T as A>::foo(&s);
| ~~~~~~~~~~
LL | <T as B>::foo(&s);
| ~~~~~~~~~~
error[E0034]: multiple applicable items in scope
--> $DIR/disambiguate-multiple-trait.rs:27:16
|
LL | let _ = S::CONST;
| ^^^^^ multiple `CONST` found
|
note: candidate #1 is defined in an impl of the trait `A` for the type `T`
--> $DIR/disambiguate-multiple-trait.rs:5:5
|
LL | const CONST: usize = 1;
| ^^^^^^^^^^^^^^^^^^
note: candidate #2 is defined in an impl of the trait `B` for the type `T`
--> $DIR/disambiguate-multiple-trait.rs:11:5
|
LL | const CONST: usize = 2;
| ^^^^^^^^^^^^^^^^^^
help: use fully-qualified syntax to disambiguate
|
LL | let _ = <T as A>::CONST;
| ~~~~~~~~~~
LL | let _ = <T as B>::CONST;
| ~~~~~~~~~~
error: aborting due to 3 previous errors
Some errors have detailed explanations: E0034, E0223.
For more information about an error, try `rustc --explain E0034`.

4
tests/ui/methods/method-ambig-two-traits-from-impls2.stderr
View File

@ -14,12 +14,10 @@ note: candidate #2 is defined in an impl of the trait `B` for the type `AB`
|
LL | fn foo() {}
| ^^^^^^^^
help: disambiguate the associated function for candidate #1
help: use fully-qualified syntax to disambiguate
|
LL | <AB as A>::foo();
| ~~~~~~~~~~~
help: disambiguate the associated function for candidate #2
|
LL | <AB as B>::foo();
| ~~~~~~~~~~~

4
tests/ui/self/self-impl.stderr
View File

@ -2,13 +2,13 @@ error[E0223]: ambiguous associated type
--> $DIR/self-impl.rs:23:16
|
LL | let _: <Self>::Baz = true;
| ^^^^^^^^^^^ help: use the fully-qualified path: `<Bar as Foo>::Baz`
| ^^^^^^^^^^^ help: use fully-qualified syntax: `<Bar as Foo>::Baz`
error[E0223]: ambiguous associated type
--> $DIR/self-impl.rs:25:16
|
LL | let _: Self::Baz = true;
| ^^^^^^^^^ help: use the fully-qualified path: `<Bar as Foo>::Baz`
| ^^^^^^^^^ help: use fully-qualified syntax: `<Bar as Foo>::Baz`
error: aborting due to 2 previous errors

6
tests/ui/structs/struct-path-associated-type.stderr
View File

@ -48,19 +48,19 @@ error[E0223]: ambiguous associated type
--> $DIR/struct-path-associated-type.rs:32:13
|
LL | let s = S::A {};
| ^^^^ help: use the fully-qualified path: `<S as Tr>::A`
| ^^^^ help: use fully-qualified syntax: `<S as Tr>::A`
error[E0223]: ambiguous associated type
--> $DIR/struct-path-associated-type.rs:33:13
|
LL | let z = S::A::<u8> {};
| ^^^^ help: use the fully-qualified path: `<S as Tr>::A`
| ^^^^ help: use fully-qualified syntax: `<S as Tr>::A`
error[E0223]: ambiguous associated type
--> $DIR/struct-path-associated-type.rs:35:9
|
LL | S::A {} => {}
| ^^^^ help: use the fully-qualified path: `<S as Tr>::A`
| ^^^^ help: use fully-qualified syntax: `<S as Tr>::A`
error: aborting due to 8 previous errors

2
tests/ui/suggestions/suggest-trait-in-ufcs-in-hrtb.stderr
View File

@ -2,7 +2,7 @@ error[E0223]: ambiguous associated type
--> $DIR/suggest-trait-in-ufcs-in-hrtb.rs:5:38
|
LL | impl<S> Foo for Bar<S> where for<'a> <&'a S>::Item: Foo {}
| ^^^^^^^^^^^^^ help: use the fully-qualified path: `<&'a S as IntoIterator>::Item`
| ^^^^^^^^^^^^^ help: use fully-qualified syntax: `<&'a S as IntoIterator>::Item`
error: aborting due to previous error

4
tests/ui/traits/item-privacy.stderr
View File

@ -159,13 +159,13 @@ error[E0223]: ambiguous associated type
--> $DIR/item-privacy.rs:116:12
|
LL | let _: S::B;
| ^^^^ help: use the fully-qualified path: `<S as assoc_ty::B>::B`
| ^^^^ help: use fully-qualified syntax: `<S as assoc_ty::B>::B`
error[E0223]: ambiguous associated type
--> $DIR/item-privacy.rs:117:12
|
LL | let _: S::C;
| ^^^^ help: use the fully-qualified path: `<S as assoc_ty::C>::C`
| ^^^^ help: use fully-qualified syntax: `<S as assoc_ty::C>::C`
error[E0624]: associated type `A` is private
--> $DIR/item-privacy.rs:119:12

2
tests/ui/typeck/issue-107087.stderr
View File

@ -2,7 +2,7 @@ error[E0223]: ambiguous associated type
--> $DIR/issue-107087.rs:16:5
|
LL | A::B::<>::C
| ^^^^^^^^ help: use the fully-qualified path: `<A<_> as Foo>::B`
| ^^^^^^^^ help: use fully-qualified syntax: `<A<_> as Foo>::B`
error: aborting due to previous error

2
tests/ui/typeck/issue-110052.stderr
View File

@ -2,7 +2,7 @@ error[E0223]: ambiguous associated type
--> $DIR/issue-110052.rs:6:30
|
LL | for<'iter> dyn Validator<<&'iter I>::Item>:,
| ^^^^^^^^^^^^^^^^ help: use the fully-qualified path: `<&'iter I as IntoIterator>::Item`
| ^^^^^^^^^^^^^^^^ help: use fully-qualified syntax: `<&'iter I as IntoIterator>::Item`
error: aborting due to previous error