Rollup merge of #83954 - estebank:issue-83613, r=varkor

Do not ICE when closure is involved in Trait Alias Impl Trait Fix #83613.

Rollup merge of #83954 - estebank:issue-83613, r=varkor
Do not ICE when closure is involved in Trait Alias Impl Trait Fix #83613.
d82419b4 · Dylan DPC · GitHub · d7d42ccf · 18cf44b6 · d82419b4
64 changed file
--- a/compiler/rustc_trait_selection/src/traits/coherence.rs
+++ b/compiler/rustc_trait_selection/src/traits/coherence.rs
@@ -586,6 +586,11 @@ fn ty_is_local_constructor(ty: Ty<'_>, in_crate: InCrate) -> bool {
            false
        }

+        ty::Closure(..) => {
+            // Similar to the `Opaque` case (#83613).
+            false
+        }
+
        ty::Dynamic(ref tt, ..) => {
            if let Some(principal) = tt.principal() {
                def_id_is_local(principal.def_id(), in_crate)
@@ -596,7 +601,7 @@ fn ty_is_local_constructor(ty: Ty<'_>, in_crate: InCrate) -> bool {

        ty::Error(_) => true,

-        ty::Closure(..) | ty::Generator(..) | ty::GeneratorWitness(..) => {
+        ty::Generator(..) | ty::GeneratorWitness(..) => {
            bug!("ty_is_local invoked on unexpected type: {:?}", ty)
        }
    }

--- a/compiler/rustc_trait_selection/src/traits/specialize/mod.rs
+++ b/compiler/rustc_trait_selection/src/traits/specialize/mod.rs
@@ -395,14 +395,14 @@ fn report_conflicting_impls(
    // that's passed in.
    let decorate = |err: LintDiagnosticBuilder<'_>| {
        let msg = format!(
-            "conflicting implementations of trait `{}`{}:{}",
+            "conflicting implementations of trait `{}`{}{}",
            overlap.trait_desc,
            overlap
                .self_desc
                .clone()
                .map_or_else(String::new, |ty| { format!(" for type `{}`", ty) }),
            match used_to_be_allowed {
-                Some(FutureCompatOverlapErrorKind::Issue33140) => " (E0119)",
+                Some(FutureCompatOverlapErrorKind::Issue33140) => ": (E0119)",
                _ => "",
            }
        );

--- a/src/test/ui/associated-types/associated-types-coherence-failure.stderr
+++ b/src/test/ui/associated-types/associated-types-coherence-failure.stderr
-error[E0119]: conflicting implementations of trait `IntoCow<'_, _>` for type `Cow<'_, _>`:
+error[E0119]: conflicting implementations of trait `IntoCow<'_, _>` for type `Cow<'_, _>`
  --> $DIR/associated-types-coherence-failure.rs:21:1
   |
 LL | impl<'a, B: ?Sized> IntoCow<'a, B> for <B as ToOwned>::Owned where B: ToOwned {
@@ -7,7 +7,7 @@ LL | impl<'a, B: ?Sized> IntoCow<'a, B> for <B as ToOwned>::Owned where B: ToOwn
 LL | impl<'a, B: ?Sized> IntoCow<'a, B> for Cow<'a, B> where B: ToOwned {
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `Cow<'_, _>`

-error[E0119]: conflicting implementations of trait `IntoCow<'_, _>` for type `&_`:
+error[E0119]: conflicting implementations of trait `IntoCow<'_, _>` for type `&_`
  --> $DIR/associated-types-coherence-failure.rs:28:1
   |
 LL | impl<'a, B: ?Sized> IntoCow<'a, B> for <B as ToOwned>::Owned where B: ToOwned {

--- a/src/test/ui/async-await/issue-67651.stderr
+++ b/src/test/ui/async-await/issue-67651.stderr
-error[E0119]: conflicting implementations of trait `From` for type `()`:
+error[E0119]: conflicting implementations of trait `From` for type `()`
  --> $DIR/issue-67651.rs:11:1
   |
 LL | impl From for () {

--- a/src/test/ui/coherence/coherence-blanket-conflicts-with-blanket-implemented.stderr
+++ b/src/test/ui/coherence/coherence-blanket-conflicts-with-blanket-implemented.stderr
-error[E0119]: conflicting implementations of trait `MyTrait`:
+error[E0119]: conflicting implementations of trait `MyTrait`
  --> $DIR/coherence-blanket-conflicts-with-blanket-implemented.rs:24:1
   |
 LL | impl<T:Even> MyTrait for T {

--- a/src/test/ui/coherence/coherence-blanket-conflicts-with-blanket-unimplemented.stderr
+++ b/src/test/ui/coherence/coherence-blanket-conflicts-with-blanket-unimplemented.stderr
-error[E0119]: conflicting implementations of trait `MyTrait`:
+error[E0119]: conflicting implementations of trait `MyTrait`
  --> $DIR/coherence-blanket-conflicts-with-blanket-unimplemented.rs:20:1
   |
 LL | impl<T:Even> MyTrait for T {

--- a/src/test/ui/coherence/coherence-blanket-conflicts-with-specific-cross-crate.stderr
+++ b/src/test/ui/coherence/coherence-blanket-conflicts-with-specific-cross-crate.stderr
-error[E0119]: conflicting implementations of trait `go_trait::GoMut` for type `MyThingy`:
+error[E0119]: conflicting implementations of trait `go_trait::GoMut` for type `MyThingy`
  --> $DIR/coherence-blanket-conflicts-with-specific-cross-crate.rs:15:1
   |
 LL | impl GoMut for MyThingy {

--- a/src/test/ui/coherence/coherence-blanket-conflicts-with-specific-multidispatch.stderr
+++ b/src/test/ui/coherence/coherence-blanket-conflicts-with-specific-multidispatch.stderr
-error[E0119]: conflicting implementations of trait `MyTrait<MyType>` for type `MyType`:
+error[E0119]: conflicting implementations of trait `MyTrait<MyType>` for type `MyType`
  --> $DIR/coherence-blanket-conflicts-with-specific-multidispatch.rs:22:1
   |
 LL | impl<T> MyTrait<T> for T {

--- a/src/test/ui/coherence/coherence-blanket-conflicts-with-specific-trait.stderr
+++ b/src/test/ui/coherence/coherence-blanket-conflicts-with-specific-trait.stderr
-error[E0119]: conflicting implementations of trait `MyTrait` for type `MyType`:
+error[E0119]: conflicting implementations of trait `MyTrait` for type `MyType`
  --> $DIR/coherence-blanket-conflicts-with-specific-trait.rs:20:1
   |
 LL | impl<T:OtherTrait> MyTrait for T {

--- a/src/test/ui/coherence/coherence-blanket-conflicts-with-specific.stderr
+++ b/src/test/ui/coherence/coherence-blanket-conflicts-with-specific.stderr
-error[E0119]: conflicting implementations of trait `MyTrait` for type `MyType`:
+error[E0119]: conflicting implementations of trait `MyTrait` for type `MyType`
  --> $DIR/coherence-blanket-conflicts-with-specific.rs:19:1
   |
 LL | impl<T> MyTrait for T {

--- a/src/test/ui/coherence/coherence-conflicting-negative-trait-impl.stderr
+++ b/src/test/ui/coherence/coherence-conflicting-negative-trait-impl.stderr
@@ -7,7 +7,7 @@ LL |
 LL | impl<T: MyTrait> !Send for TestType<T> {}
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ negative implementation here

-error[E0119]: conflicting implementations of trait `std::marker::Send` for type `TestType<_>`:
+error[E0119]: conflicting implementations of trait `std::marker::Send` for type `TestType<_>`
  --> $DIR/coherence-conflicting-negative-trait-impl.rs:13:1
   |
 LL | unsafe impl<T: MyTrait + 'static> Send for TestType<T> {}

--- a/src/test/ui/coherence/coherence-cross-crate-conflict.stderr
+++ b/src/test/ui/coherence/coherence-cross-crate-conflict.stderr
-error[E0119]: conflicting implementations of trait `trait_impl_conflict::Foo` for type `isize`:
+error[E0119]: conflicting implementations of trait `trait_impl_conflict::Foo` for type `isize`
  --> $DIR/coherence-cross-crate-conflict.rs:9:1
   |
 LL | impl<A> Foo for A {

--- a/src/test/ui/coherence/coherence-fn-covariant-bound-vs-static.stderr
+++ b/src/test/ui/coherence/coherence-fn-covariant-bound-vs-static.stderr
-error[E0119]: conflicting implementations of trait `Trait` for type `for<'r> fn(fn(&'r ()))`:
+error[E0119]: conflicting implementations of trait `Trait` for type `for<'r> fn(fn(&'r ()))`
  --> $DIR/coherence-fn-covariant-bound-vs-static.rs:17:1
   |
 LL | impl Trait for for<'r> fn(fn(&'r ())) {}

--- a/src/test/ui/coherence/coherence-fn-implied-bounds.stderr
+++ b/src/test/ui/coherence/coherence-fn-implied-bounds.stderr
-error: conflicting implementations of trait `Trait` for type `for<'a, 'b> fn(&'a &'b u32, &'b &'a u32) -> &'b u32`:
+error: conflicting implementations of trait `Trait` for type `for<'a, 'b> fn(&'a &'b u32, &'b &'a u32) -> &'b u32`
  --> $DIR/coherence-fn-implied-bounds.rs:21:1
   |
 LL | impl Trait for for<'a, 'b> fn(&'a &'b u32, &'b &'a u32) -> &'b u32 {}

--- a/src/test/ui/coherence/coherence-fn-inputs.stderr
+++ b/src/test/ui/coherence/coherence-fn-inputs.stderr
-error[E0119]: conflicting implementations of trait `Trait` for type `for<'a, 'b> fn(&'a u32, &'b u32)`:
+error[E0119]: conflicting implementations of trait `Trait` for type `for<'a, 'b> fn(&'a u32, &'b u32)`
  --> $DIR/coherence-fn-inputs.rs:15:1
   |
 LL | impl Trait for for<'a, 'b> fn(&'a u32, &'b u32) {}

--- a/src/test/ui/coherence/coherence-free-vs-bound-region.stderr
+++ b/src/test/ui/coherence/coherence-free-vs-bound-region.stderr
-error: conflicting implementations of trait `TheTrait` for type `fn(&u8)`:
+error: conflicting implementations of trait `TheTrait` for type `fn(&u8)`
  --> $DIR/coherence-free-vs-bound-region.rs:16:1
   |
 LL | impl<'a> TheTrait for fn(&'a u8) {}

--- a/src/test/ui/coherence/coherence-impls-copy.stderr
+++ b/src/test/ui/coherence/coherence-impls-copy.stderr
-error[E0119]: conflicting implementations of trait `std::marker::Copy` for type `i32`:
+error[E0119]: conflicting implementations of trait `std::marker::Copy` for type `i32`
  --> $DIR/coherence-impls-copy.rs:5:1
   |
 LL | impl Copy for i32 {}
@@ -7,7 +7,7 @@ LL | impl Copy for i32 {}
   = note: conflicting implementation in crate `core`:
           - impl Copy for i32;

-error[E0119]: conflicting implementations of trait `std::marker::Copy` for type `&NotSync`:
+error[E0119]: conflicting implementations of trait `std::marker::Copy` for type `&NotSync`
  --> $DIR/coherence-impls-copy.rs:29:1
   |
 LL | impl Copy for &'static NotSync {}
@@ -17,7 +17,7 @@ LL | impl Copy for &'static NotSync {}
           - impl<T> Copy for &T
             where T: ?Sized;

-error[E0119]: conflicting implementations of trait `std::marker::Copy` for type `&[NotSync]`:
+error[E0119]: conflicting implementations of trait `std::marker::Copy` for type `&[NotSync]`
  --> $DIR/coherence-impls-copy.rs:34:1
   |
 LL | impl Copy for &'static [NotSync] {}

--- a/src/test/ui/coherence/coherence-impls-send.stderr
+++ b/src/test/ui/coherence/coherence-impls-send.stderr
-error[E0119]: conflicting implementations of trait `std::marker::Send` for type `&[NotSync]`:
+error[E0119]: conflicting implementations of trait `std::marker::Send` for type `&[NotSync]`
  --> $DIR/coherence-impls-send.rs:25:1
   |
 LL | unsafe impl Send for &'static [NotSync] {}

--- a/src/test/ui/coherence/coherence-no-direct-lifetime-dispatch.stderr
+++ b/src/test/ui/coherence/coherence-no-direct-lifetime-dispatch.stderr
-error[E0119]: conflicting implementations of trait `MyTrait`:
+error[E0119]: conflicting implementations of trait `MyTrait`
  --> $DIR/coherence-no-direct-lifetime-dispatch.rs:6:1
   |
 LL | impl<T> MyTrait for T {}

--- a/src/test/ui/coherence/coherence-overlap-all-t-and-tuple.stderr
+++ b/src/test/ui/coherence/coherence-overlap-all-t-and-tuple.stderr
-error[E0119]: conflicting implementations of trait `From<(_,)>` for type `(_,)`:
+error[E0119]: conflicting implementations of trait `From<(_,)>` for type `(_,)`
  --> $DIR/coherence-overlap-all-t-and-tuple.rs:16:1
   |
 LL | impl <T> From<T> for T {

--- a/src/test/ui/coherence/coherence-overlap-downstream.stderr
+++ b/src/test/ui/coherence/coherence-overlap-downstream.stderr
-error[E0119]: conflicting implementations of trait `Sweet`:
+error[E0119]: conflicting implementations of trait `Sweet`
  --> $DIR/coherence-overlap-downstream.rs:8:1
   |
 LL | impl<T:Sugar> Sweet for T { }
@@ -6,7 +6,7 @@ LL | impl<T:Sugar> Sweet for T { }
 LL | impl<T:Fruit> Sweet for T { }
   | ^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation

-error[E0119]: conflicting implementations of trait `Foo<_>` for type `i32`:
+error[E0119]: conflicting implementations of trait `Foo<_>` for type `i32`
  --> $DIR/coherence-overlap-downstream.rs:14:1
   |
 LL | impl<X, T> Foo<X> for T where T: Bar<X> {}

--- a/src/test/ui/coherence/coherence-overlap-issue-23516.stderr
+++ b/src/test/ui/coherence/coherence-overlap-issue-23516.stderr
-error[E0119]: conflicting implementations of trait `Sweet` for type `std::boxed::Box<_>`:
+error[E0119]: conflicting implementations of trait `Sweet` for type `std::boxed::Box<_>`
  --> $DIR/coherence-overlap-issue-23516.rs:8:1
   |
 LL | impl<T:Sugar> Sweet for T { }

--- a/src/test/ui/coherence/coherence-overlap-messages.stderr
+++ b/src/test/ui/coherence/coherence-overlap-messages.stderr
-error[E0119]: conflicting implementations of trait `Foo`:
+error[E0119]: conflicting implementations of trait `Foo`
  --> $DIR/coherence-overlap-messages.rs:4:1
   |
 LL | impl<T> Foo for T {}
@@ -6,7 +6,7 @@ LL | impl<T> Foo for T {}
 LL | impl<U> Foo for U {}
   | ^^^^^^^^^^^^^^^^^ conflicting implementation

-error[E0119]: conflicting implementations of trait `Bar` for type `(u8, u8)`:
+error[E0119]: conflicting implementations of trait `Bar` for type `(u8, u8)`
  --> $DIR/coherence-overlap-messages.rs:11:1
   |
 LL | impl<T> Bar for (T, u8) {}
@@ -14,7 +14,7 @@ LL | impl<T> Bar for (T, u8) {}
 LL | impl<T> Bar for (u8, T) {}
   | ^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `(u8, u8)`

-error[E0119]: conflicting implementations of trait `Baz<u8>` for type `u8`:
+error[E0119]: conflicting implementations of trait `Baz<u8>` for type `u8`
  --> $DIR/coherence-overlap-messages.rs:17:1
   |
 LL | impl<T> Baz<u8> for T {}
@@ -22,7 +22,7 @@ LL | impl<T> Baz<u8> for T {}
 LL | impl<T> Baz<T> for u8 {}
   | ^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `u8`

-error[E0119]: conflicting implementations of trait `Quux<_, _>`:
+error[E0119]: conflicting implementations of trait `Quux<_, _>`
  --> $DIR/coherence-overlap-messages.rs:23:1
   |
 LL | impl<T, U, V> Quux<U, V> for T {}
@@ -30,7 +30,7 @@ LL | impl<T, U, V> Quux<U, V> for T {}
 LL | impl<T, U> Quux<U, U> for T {}
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation

-error[E0119]: conflicting implementations of trait `Quux<_, _>`:
+error[E0119]: conflicting implementations of trait `Quux<_, _>`
  --> $DIR/coherence-overlap-messages.rs:25:1
   |
 LL | impl<T, U, V> Quux<U, V> for T {}

--- a/src/test/ui/coherence/coherence-overlap-upstream.stderr
+++ b/src/test/ui/coherence/coherence-overlap-upstream.stderr
-error[E0119]: conflicting implementations of trait `Foo` for type `i16`:
+error[E0119]: conflicting implementations of trait `Foo` for type `i16`
  --> $DIR/coherence-overlap-upstream.rs:13:1
   |
 LL | impl<T> Foo for T where T: Remote {}

--- a/src/test/ui/coherence/coherence-projection-conflict-orphan.stderr
+++ b/src/test/ui/coherence/coherence-projection-conflict-orphan.stderr
-error[E0119]: conflicting implementations of trait `Foo<i32>` for type `i32`:
+error[E0119]: conflicting implementations of trait `Foo<i32>` for type `i32`
  --> $DIR/coherence-projection-conflict-orphan.rs:16:1
   |
 LL | impl Foo<i32> for i32 { }

--- a/src/test/ui/coherence/coherence-projection-conflict-ty-param.stderr
+++ b/src/test/ui/coherence/coherence-projection-conflict-ty-param.stderr
-error[E0119]: conflicting implementations of trait `Foo<_>` for type `std::option::Option<_>`:
+error[E0119]: conflicting implementations of trait `Foo<_>` for type `std::option::Option<_>`
  --> $DIR/coherence-projection-conflict-ty-param.rs:10:1
   |
 LL | impl <P, T: Foo<P>> Foo<P> for Option<T> {}

--- a/src/test/ui/coherence/coherence-projection-conflict.stderr
+++ b/src/test/ui/coherence/coherence-projection-conflict.stderr
-error[E0119]: conflicting implementations of trait `Foo<i32>` for type `i32`:
+error[E0119]: conflicting implementations of trait `Foo<i32>` for type `i32`
  --> $DIR/coherence-projection-conflict.rs:11:1
   |
 LL | impl Foo<i32> for i32 { }

--- a/src/test/ui/coherence/coherence-subtyping.stderr
+++ b/src/test/ui/coherence/coherence-subtyping.stderr
-warning: conflicting implementations of trait `TheTrait` for type `for<'a, 'b> fn(&'a u8, &'b u8) -> &'a u8`:
+warning: conflicting implementations of trait `TheTrait` for type `for<'a, 'b> fn(&'a u8, &'b u8) -> &'a u8`
  --> $DIR/coherence-subtyping.rs:15:1
   |
 LL | impl TheTrait for for<'a, 'b> fn(&'a u8, &'b u8) -> &'a u8 {}

--- a/src/test/ui/coherence/coherence-tuple-conflict.stderr
+++ b/src/test/ui/coherence/coherence-tuple-conflict.stderr
-error[E0119]: conflicting implementations of trait `MyTrait` for type `(_, _)`:
+error[E0119]: conflicting implementations of trait `MyTrait` for type `(_, _)`
  --> $DIR/coherence-tuple-conflict.rs:15:1
   |
 LL | impl<T> MyTrait for (T,T) {

--- a/src/test/ui/coherence/coherence-wasm-bindgen.stderr
+++ b/src/test/ui/coherence/coherence-wasm-bindgen.stderr
-error: conflicting implementations of trait `IntoWasmAbi` for type `&dyn std::ops::Fn(&_) -> _`:
+error: conflicting implementations of trait `IntoWasmAbi` for type `&dyn std::ops::Fn(&_) -> _`
  --> $DIR/coherence-wasm-bindgen.rs:28:1
   |
 LL | / impl<'a, 'b, A, R> IntoWasmAbi for &'a (dyn Fn(A) -> R + 'b)

--- a/src/test/ui/coherence/coherence_copy_like_err_fundamental_struct_tuple.stderr
+++ b/src/test/ui/coherence/coherence_copy_like_err_fundamental_struct_tuple.stderr
-error[E0119]: conflicting implementations of trait `MyTrait` for type `lib::MyFundamentalStruct<(MyType,)>`:
+error[E0119]: conflicting implementations of trait `MyTrait` for type `lib::MyFundamentalStruct<(MyType,)>`
  --> $DIR/coherence_copy_like_err_fundamental_struct_tuple.rs:16:1
   |
 LL | impl<T: lib::MyCopy> MyTrait for T { }

--- a/src/test/ui/coherence/coherence_copy_like_err_struct.stderr
+++ b/src/test/ui/coherence/coherence_copy_like_err_struct.stderr
-error[E0119]: conflicting implementations of trait `MyTrait` for type `lib::MyStruct<MyType>`:
+error[E0119]: conflicting implementations of trait `MyTrait` for type `lib::MyStruct<MyType>`
  --> $DIR/coherence_copy_like_err_struct.rs:19:1
   |
 LL | impl<T: lib::MyCopy> MyTrait for T { }

--- a/src/test/ui/coherence/coherence_copy_like_err_tuple.stderr
+++ b/src/test/ui/coherence/coherence_copy_like_err_tuple.stderr
-error[E0119]: conflicting implementations of trait `MyTrait` for type `(MyType,)`:
+error[E0119]: conflicting implementations of trait `MyTrait` for type `(MyType,)`
  --> $DIR/coherence_copy_like_err_tuple.rs:18:1
   |
 LL | impl<T: lib::MyCopy> MyTrait for T { }

--- a/src/test/ui/const-generics/issues/issue-64494.min.stderr
+++ b/src/test/ui/const-generics/issues/issue-64494.min.stderr
@@ -16,7 +16,7 @@ LL | impl<T: Foo> MyTrait for T where Is<{T::VAL == 6}>: True {}
   = note: type parameters may not be used in const expressions
   = help: use `#![feature(const_generics)]` and `#![feature(const_evaluatable_checked)]` to allow generic const expressions

-error[E0119]: conflicting implementations of trait `MyTrait`:
+error[E0119]: conflicting implementations of trait `MyTrait`
  --> $DIR/issue-64494.rs:18:1
   |
 LL | impl<T: Foo> MyTrait for T where Is<{T::VAL == 5}>: True {}

--- a/src/test/ui/error-codes/E0119.stderr
+++ b/src/test/ui/error-codes/E0119.stderr
-error[E0119]: conflicting implementations of trait `MyTrait` for type `Foo`:
+error[E0119]: conflicting implementations of trait `MyTrait` for type `Foo`
  --> $DIR/E0119.rs:13:1
   |
 LL | impl<T> MyTrait for T {

--- a/src/test/ui/error-codes/e0119/complex-impl.stderr
+++ b/src/test/ui/error-codes/e0119/complex-impl.stderr
-error[E0119]: conflicting implementations of trait `complex_impl_support::External` for type `(Q, complex_impl_support::M<'_, '_, '_, std::boxed::Box<_>, _, _>)`:
+error[E0119]: conflicting implementations of trait `complex_impl_support::External` for type `(Q, complex_impl_support::M<'_, '_, '_, std::boxed::Box<_>, _, _>)`
  --> $DIR/complex-impl.rs:9:1
   |
 LL | impl<R> External for (Q, R) {}

--- a/src/test/ui/error-codes/e0119/conflict-with-std.stderr
+++ b/src/test/ui/error-codes/e0119/conflict-with-std.stderr
-error[E0119]: conflicting implementations of trait `std::convert::AsRef<Q>` for type `std::boxed::Box<Q>`:
+error[E0119]: conflicting implementations of trait `std::convert::AsRef<Q>` for type `std::boxed::Box<Q>`
  --> $DIR/conflict-with-std.rs:5:1
   |
 LL | impl AsRef<Q> for Box<Q> {
@@ -8,7 +8,7 @@ LL | impl AsRef<Q> for Box<Q> {
           - impl<T, A> AsRef<T> for Box<T, A>
             where A: Allocator, T: ?Sized;

-error[E0119]: conflicting implementations of trait `std::convert::From<S>` for type `S`:
+error[E0119]: conflicting implementations of trait `std::convert::From<S>` for type `S`
  --> $DIR/conflict-with-std.rs:12:1
   |
 LL | impl From<S> for S {
@@ -17,7 +17,7 @@ LL | impl From<S> for S {
   = note: conflicting implementation in crate `core`:
           - impl<T> From<T> for T;

-error[E0119]: conflicting implementations of trait `std::convert::TryFrom<X>` for type `X`:
+error[E0119]: conflicting implementations of trait `std::convert::TryFrom<X>` for type `X`
  --> $DIR/conflict-with-std.rs:19:1
   |
 LL | impl TryFrom<X> for X {

--- a/src/test/ui/error-codes/e0119/issue-23563.stderr
+++ b/src/test/ui/error-codes/e0119/issue-23563.stderr
-error[E0119]: conflicting implementations of trait `a::LolFrom<&[_]>` for type `LocalType<_>`:
+error[E0119]: conflicting implementations of trait `a::LolFrom<&[_]>` for type `LocalType<_>`
  --> $DIR/issue-23563.rs:13:1
   |
 LL | impl<'a, T> LolFrom<&'a [T]> for LocalType<T> {

--- a/src/test/ui/error-codes/e0119/issue-27403.stderr
+++ b/src/test/ui/error-codes/e0119/issue-27403.stderr
-error[E0119]: conflicting implementations of trait `std::convert::Into<_>` for type `GenX<_>`:
+error[E0119]: conflicting implementations of trait `std::convert::Into<_>` for type `GenX<_>`
  --> $DIR/issue-27403.rs:5:1
   |
 LL | impl<S> Into<S> for GenX<S> {

--- a/src/test/ui/error-codes/e0119/issue-28981.stderr
+++ b/src/test/ui/error-codes/e0119/issue-28981.stderr
-error[E0119]: conflicting implementations of trait `std::ops::Deref` for type `&_`:
+error[E0119]: conflicting implementations of trait `std::ops::Deref` for type `&_`
  --> $DIR/issue-28981.rs:5:1
   |
 LL | impl<Foo> Deref for Foo { }

--- a/src/test/ui/error-codes/e0119/so-37347311.stderr
+++ b/src/test/ui/error-codes/e0119/so-37347311.stderr
-error[E0119]: conflicting implementations of trait `std::convert::From<MyError<_>>` for type `MyError<_>`:
+error[E0119]: conflicting implementations of trait `std::convert::From<MyError<_>>` for type `MyError<_>`
  --> $DIR/so-37347311.rs:11:1
   |
 LL | impl<S: Storage> From<S::Error> for MyError<S> {

--- a/src/test/ui/feature-gates/feature-gate-overlapping_marker_traits.stderr
+++ b/src/test/ui/feature-gates/feature-gate-overlapping_marker_traits.stderr
-error[E0119]: conflicting implementations of trait `MyMarker`:
+error[E0119]: conflicting implementations of trait `MyMarker`
  --> $DIR/feature-gate-overlapping_marker_traits.rs:6:1
   |
 LL | impl<T: Display> MyMarker for T {}

--- a/src/test/ui/impl-trait/auto-trait.full_tait.stderr
+++ b/src/test/ui/impl-trait/auto-trait.full_tait.stderr
@@ -7,7 +7,7 @@ LL | #![cfg_attr(full_tait, feature(type_alias_impl_trait))]
   = note: `#[warn(incomplete_features)]` on by default
   = note: see issue #63063 <https://github.com/rust-lang/rust/issues/63063> for more information

-error[E0119]: conflicting implementations of trait `AnotherTrait` for type `D<impl OpaqueTrait>`:
+error[E0119]: conflicting implementations of trait `AnotherTrait` for type `D<impl OpaqueTrait>`
  --> $DIR/auto-trait.rs:24:1
   |
 LL | impl<T: Send> AnotherTrait for T {}

--- a/src/test/ui/impl-trait/auto-trait.min_tait.stderr
+++ b/src/test/ui/impl-trait/auto-trait.min_tait.stderr
-error[E0119]: conflicting implementations of trait `AnotherTrait` for type `D<impl OpaqueTrait>`:
+error[E0119]: conflicting implementations of trait `AnotherTrait` for type `D<impl OpaqueTrait>`
  --> $DIR/auto-trait.rs:24:1
   |
 LL | impl<T: Send> AnotherTrait for T {}

--- a/src/test/ui/impl-trait/negative-reasoning.full_tait.stderr
+++ b/src/test/ui/impl-trait/negative-reasoning.full_tait.stderr
@@ -7,7 +7,7 @@ LL | #![cfg_attr(full_tait, feature(type_alias_impl_trait))]
   = note: `#[warn(incomplete_features)]` on by default
   = note: see issue #63063 <https://github.com/rust-lang/rust/issues/63063> for more information

-error[E0119]: conflicting implementations of trait `AnotherTrait` for type `D<impl OpaqueTrait>`:
+error[E0119]: conflicting implementations of trait `AnotherTrait` for type `D<impl OpaqueTrait>`
  --> $DIR/negative-reasoning.rs:22:1
   |
 LL | impl<T: std::fmt::Debug> AnotherTrait for T {}

--- a/src/test/ui/impl-trait/negative-reasoning.min_tait.stderr
+++ b/src/test/ui/impl-trait/negative-reasoning.min_tait.stderr
-error[E0119]: conflicting implementations of trait `AnotherTrait` for type `D<impl OpaqueTrait>`:
+error[E0119]: conflicting implementations of trait `AnotherTrait` for type `D<impl OpaqueTrait>`
  --> $DIR/negative-reasoning.rs:22:1
   |
 LL | impl<T: std::fmt::Debug> AnotherTrait for T {}

--- a/src/test/ui/issues/issue-28568.stderr
+++ b/src/test/ui/issues/issue-28568.stderr
-error[E0119]: conflicting implementations of trait `std::ops::Drop` for type `MyStruct`:
+error[E0119]: conflicting implementations of trait `std::ops::Drop` for type `MyStruct`
  --> $DIR/issue-28568.rs:7:1
   |
 LL | impl Drop for MyStruct {

--- a/src/test/ui/issues/issue-41974.stderr
+++ b/src/test/ui/issues/issue-41974.stderr
-error[E0119]: conflicting implementations of trait `std::ops::Drop` for type `std::boxed::Box<_, _>`:
+error[E0119]: conflicting implementations of trait `std::ops::Drop` for type `std::boxed::Box<_, _>`
  --> $DIR/issue-41974.rs:7:1
   |
 LL | impl<T> Drop for T where T: A {

--- a/src/test/ui/issues/issue-43355.stderr
+++ b/src/test/ui/issues/issue-43355.stderr
-error[E0119]: conflicting implementations of trait `Trait1<std::boxed::Box<_>>` for type `A`:
+error[E0119]: conflicting implementations of trait `Trait1<std::boxed::Box<_>>` for type `A`
  --> $DIR/issue-43355.rs:13:1
   |
 LL | impl<X, T> Trait1<X> for T where T: Trait2<X> {

--- a/src/test/ui/issues/issue-48728.stderr
+++ b/src/test/ui/issues/issue-48728.stderr
-error[E0119]: conflicting implementations of trait `std::clone::Clone` for type `Node<[_]>`:
+error[E0119]: conflicting implementations of trait `std::clone::Clone` for type `Node<[_]>`
  --> $DIR/issue-48728.rs:4:10
   |
 LL | #[derive(Clone)]

--- a/src/test/ui/never_type/never-from-impl-is-reserved.stderr
+++ b/src/test/ui/never_type/never-from-impl-is-reserved.stderr
-error[E0119]: conflicting implementations of trait `MyTrait` for type `MyFoo`:
+error[E0119]: conflicting implementations of trait `MyTrait` for type `MyFoo`
  --> $DIR/never-from-impl-is-reserved.rs:10:1
   |
 LL | impl MyTrait for MyFoo {}

--- a/src/test/ui/rfc-2632-const-trait-impl/const-and-non-const-impl.stderr
+++ b/src/test/ui/rfc-2632-const-trait-impl/const-and-non-const-impl.stderr
-error[E0119]: conflicting implementations of trait `std::ops::Add` for type `i32`:
+error[E0119]: conflicting implementations of trait `std::ops::Add` for type `i32`
  --> $DIR/const-and-non-const-impl.rs:6:1
   |
 LL | impl const std::ops::Add for i32 {
@@ -7,7 +7,7 @@ LL | impl const std::ops::Add for i32 {
   = note: conflicting implementation in crate `core`:
           - impl Add for i32;

-error[E0119]: conflicting implementations of trait `std::ops::Add` for type `Int`:
+error[E0119]: conflicting implementations of trait `std::ops::Add` for type `Int`
  --> $DIR/const-and-non-const-impl.rs:24:1
   |
 LL | impl std::ops::Add for Int {

--- a/src/test/ui/specialization/issue-52050.stderr
+++ b/src/test/ui/specialization/issue-52050.stderr
@@ -8,7 +8,7 @@ LL | #![feature(specialization)]
   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
   = help: consider using `min_specialization` instead, which is more stable and complete

-error[E0119]: conflicting implementations of trait `IntoPyDictPointer` for type `()`:
+error[E0119]: conflicting implementations of trait `IntoPyDictPointer` for type `()`
  --> $DIR/issue-52050.rs:28:1
   |
 LL | / impl<I> IntoPyDictPointer for I

--- a/src/test/ui/specialization/specialization-feature-gate-overlap.stderr
+++ b/src/test/ui/specialization/specialization-feature-gate-overlap.stderr
-error[E0119]: conflicting implementations of trait `Foo` for type `u8`:
+error[E0119]: conflicting implementations of trait `Foo` for type `u8`
  --> $DIR/specialization-feature-gate-overlap.rs:13:1
   |
 LL | impl<T> Foo for T {

--- a/src/test/ui/specialization/specialization-overlap.stderr
+++ b/src/test/ui/specialization/specialization-overlap.stderr
@@ -8,7 +8,7 @@ LL | #![feature(specialization)]
   = note: see issue #31844 <https://github.com/rust-lang/rust/issues/31844> for more information
   = help: consider using `min_specialization` instead, which is more stable and complete

-error[E0119]: conflicting implementations of trait `Foo` for type `std::vec::Vec<_>`:
+error[E0119]: conflicting implementations of trait `Foo` for type `std::vec::Vec<_>`
  --> $DIR/specialization-overlap.rs:5:1
   |
 LL | impl<T: Clone> Foo for T {}
@@ -16,7 +16,7 @@ LL | impl<T: Clone> Foo for T {}
 LL | impl<T> Foo for Vec<T> {}
   | ^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `std::vec::Vec<_>`

-error[E0119]: conflicting implementations of trait `Bar` for type `(u8, u8)`:
+error[E0119]: conflicting implementations of trait `Bar` for type `(u8, u8)`
  --> $DIR/specialization-overlap.rs:9:1
   |
 LL | impl<T> Bar for (T, u8) {}
@@ -24,7 +24,7 @@ LL | impl<T> Bar for (T, u8) {}
 LL | impl<T> Bar for (u8, T) {}
   | ^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `(u8, u8)`

-error[E0119]: conflicting implementations of trait `Baz<u8>` for type `u8`:
+error[E0119]: conflicting implementations of trait `Baz<u8>` for type `u8`
  --> $DIR/specialization-overlap.rs:13:1
   |
 LL | impl<T> Baz<T> for u8 {}
@@ -32,7 +32,7 @@ LL | impl<T> Baz<T> for u8 {}
 LL | impl<T> Baz<u8> for T {}
   | ^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `u8`

-error[E0119]: conflicting implementations of trait `Qux`:
+error[E0119]: conflicting implementations of trait `Qux`
  --> $DIR/specialization-overlap.rs:17:1
   |
 LL | impl<T: Clone> Qux for T {}

--- a/src/test/ui/traits/alias/issue-83613.rs
+++ b/src/test/ui/traits/alias/issue-83613.rs
+#![feature(min_type_alias_impl_trait)]
+trait OpaqueTrait {}
+impl<T> OpaqueTrait for T {}
+type OpaqueType = impl OpaqueTrait;
+fn mk_opaque() -> OpaqueType {
+    || 0
+}
+trait AnotherTrait {}
+impl<T: Send> AnotherTrait for T {}
+impl AnotherTrait for OpaqueType {}
+//~^ ERROR conflicting implementations of trait `AnotherTrait` for type `impl OpaqueTrait`
+//~| ERROR cannot implement trait on type alias impl trait
+fn main() {}
--- a/src/test/ui/traits/alias/issue-83613.stderr
+++ b/src/test/ui/traits/alias/issue-83613.stderr
+error[E0119]: conflicting implementations of trait `AnotherTrait` for type `impl OpaqueTrait`
+  --> $DIR/issue-83613.rs:10:1
+   |
+LL | impl<T: Send> AnotherTrait for T {}
+   | -------------------------------- first implementation here
+LL | impl AnotherTrait for OpaqueType {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `impl OpaqueTrait`
+
+error: cannot implement trait on type alias impl trait
+  --> $DIR/issue-83613.rs:10:1
+   |
+LL | impl AnotherTrait for OpaqueType {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: type alias impl trait defined here
+  --> $DIR/issue-83613.rs:4:19
+   |
+LL | type OpaqueType = impl OpaqueTrait;
+   |                   ^^^^^^^^^^^^^^^^
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0119`.
--- a/src/test/ui/traits/issue-33140-hack-boundaries.stderr
+++ b/src/test/ui/traits/issue-33140-hack-boundaries.stderr
-error[E0119]: conflicting implementations of trait `Trait1` for type `(dyn std::marker::Send + 'static)`:
+error[E0119]: conflicting implementations of trait `Trait1` for type `(dyn std::marker::Send + 'static)`
  --> $DIR/issue-33140-hack-boundaries.rs:18:1
   |
 LL | impl Trait1 for dyn Send {}
@@ -14,7 +14,7 @@ LL | impl Trait2 for dyn Send {}
 LL | impl !Trait2 for dyn Send {}
   | ^^^^^^^^^^^^^^^^^^^^^^^^^ negative implementation here

-error[E0119]: conflicting implementations of trait `Trait3<(dyn std::marker::Sync + 'static)>` for type `(dyn std::marker::Send + 'static)`:
+error[E0119]: conflicting implementations of trait `Trait3<(dyn std::marker::Sync + 'static)>` for type `(dyn std::marker::Send + 'static)`
  --> $DIR/issue-33140-hack-boundaries.rs:32:1
   |
 LL | impl Trait3<dyn Sync> for dyn Send {}
@@ -22,7 +22,7 @@ LL | impl Trait3<dyn Sync> for dyn Send {}
 LL | impl Trait3<dyn Sync> for dyn Send {}
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `(dyn std::marker::Send + 'static)`

-error[E0119]: conflicting implementations of trait `Trait4a` for type `(dyn std::marker::Send + 'static)`:
+error[E0119]: conflicting implementations of trait `Trait4a` for type `(dyn std::marker::Send + 'static)`
  --> $DIR/issue-33140-hack-boundaries.rs:39:1
   |
 LL | impl<T: ?Sized> Trait4a for T {}
@@ -30,7 +30,7 @@ LL | impl<T: ?Sized> Trait4a for T {}
 LL | impl Trait4a for dyn Send {}
   | ^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `(dyn std::marker::Send + 'static)`

-error[E0119]: conflicting implementations of trait `Trait4b` for type `()`:
+error[E0119]: conflicting implementations of trait `Trait4b` for type `()`
  --> $DIR/issue-33140-hack-boundaries.rs:46:1
   |
 LL | impl Trait4b for () {}
@@ -38,7 +38,7 @@ LL | impl Trait4b for () {}
 LL | impl Trait4b for () {}
   | ^^^^^^^^^^^^^^^^^^^ conflicting implementation for `()`

-error[E0119]: conflicting implementations of trait `Trait4c` for type `(dyn Trait1 + std::marker::Send + 'static)`:
+error[E0119]: conflicting implementations of trait `Trait4c` for type `(dyn Trait1 + std::marker::Send + 'static)`
  --> $DIR/issue-33140-hack-boundaries.rs:53:1
   |
 LL | impl Trait4c for dyn Trait1 + Send {}
@@ -46,7 +46,7 @@ LL | impl Trait4c for dyn Trait1 + Send {}
 LL | impl Trait4c for dyn Trait1 + Send {}
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `(dyn Trait1 + std::marker::Send + 'static)`

-error[E0119]: conflicting implementations of trait `Trait4d` for type `dyn std::marker::Send`:
+error[E0119]: conflicting implementations of trait `Trait4d` for type `dyn std::marker::Send`
  --> $DIR/issue-33140-hack-boundaries.rs:60:1
   |
 LL | impl<'a> Trait4d for dyn Send + 'a {}
@@ -54,7 +54,7 @@ LL | impl<'a> Trait4d for dyn Send + 'a {}
 LL | impl<'a> Trait4d for dyn Send + 'a {}
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `dyn std::marker::Send`

-error[E0119]: conflicting implementations of trait `Trait5` for type `(dyn std::marker::Send + 'static)`:
+error[E0119]: conflicting implementations of trait `Trait5` for type `(dyn std::marker::Send + 'static)`
  --> $DIR/issue-33140-hack-boundaries.rs:67:1
   |
 LL | impl Trait5 for dyn Send {}

--- a/src/test/ui/traits/issue-33140.stderr
+++ b/src/test/ui/traits/issue-33140.stderr
-error[E0119]: conflicting implementations of trait `Trait` for type `(dyn std::marker::Send + std::marker::Sync + 'static)`:
+error[E0119]: conflicting implementations of trait `Trait` for type `(dyn std::marker::Send + std::marker::Sync + 'static)`
  --> $DIR/issue-33140.rs:9:1
   |
 LL | impl Trait for dyn Send + Sync {
@@ -7,7 +7,7 @@ LL | impl Trait for dyn Send + Sync {
 LL | impl Trait for dyn Sync + Send {
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `(dyn std::marker::Send + std::marker::Sync + 'static)`

-error[E0119]: conflicting implementations of trait `Trait2` for type `(dyn std::marker::Send + std::marker::Sync + 'static)`:
+error[E0119]: conflicting implementations of trait `Trait2` for type `(dyn std::marker::Send + std::marker::Sync + 'static)`
  --> $DIR/issue-33140.rs:22:1
   |
 LL | impl Trait2 for dyn Send + Sync {

--- a/src/test/ui/traits/negative-impls/rely-on-negative-impl-in-coherence.stderr
+++ b/src/test/ui/traits/negative-impls/rely-on-negative-impl-in-coherence.stderr
-error[E0119]: conflicting implementations of trait `LocalTrait` for type `std::string::String`:
+error[E0119]: conflicting implementations of trait `LocalTrait` for type `std::string::String`
  --> $DIR/rely-on-negative-impl-in-coherence.rs:19:1
   |
 LL | impl<T: ForeignTrait> LocalTrait for T { }

--- a/src/test/ui/traits/overlap-not-permitted-for-builtin-trait.stderr
+++ b/src/test/ui/traits/overlap-not-permitted-for-builtin-trait.stderr
-error[E0119]: conflicting implementations of trait `std::marker::Send` for type `MyStruct`:
+error[E0119]: conflicting implementations of trait `std::marker::Send` for type `MyStruct`
  --> $DIR/overlap-not-permitted-for-builtin-trait.rs:7:1
   |
 LL | impl !Send for MyStruct {}

--- a/src/test/ui/traits/reservation-impl/coherence-conflict.stderr
+++ b/src/test/ui/traits/reservation-impl/coherence-conflict.stderr
-error[E0119]: conflicting implementations of trait `OtherTrait` for type `()`:
+error[E0119]: conflicting implementations of trait `OtherTrait` for type `()`
  --> $DIR/coherence-conflict.rs:11:1
   |
 LL | impl OtherTrait for () {}

--- a/src/test/ui/type-alias-impl-trait/incoherent-assoc-imp-trait.full_tait.stderr
+++ b/src/test/ui/type-alias-impl-trait/incoherent-assoc-imp-trait.full_tait.stderr
@@ -7,7 +7,7 @@ LL | #![cfg_attr(full_tait, feature(type_alias_impl_trait))]
   = note: `#[warn(incomplete_features)]` on by default
   = note: see issue #63063 <https://github.com/rust-lang/rust/issues/63063> for more information

-error[E0119]: conflicting implementations of trait `std::ops::FnOnce<()>` for type `&_`:
+error[E0119]: conflicting implementations of trait `std::ops::FnOnce<()>` for type `&_`
  --> $DIR/incoherent-assoc-imp-trait.rs:13:1
   |
 LL | impl<F> FnOnce<()> for &F {

--- a/src/test/ui/type-alias-impl-trait/incoherent-assoc-imp-trait.min_tait.stderr
+++ b/src/test/ui/type-alias-impl-trait/incoherent-assoc-imp-trait.min_tait.stderr
-error[E0119]: conflicting implementations of trait `std::ops::FnOnce<()>` for type `&_`:
+error[E0119]: conflicting implementations of trait `std::ops::FnOnce<()>` for type `&_`
  --> $DIR/incoherent-assoc-imp-trait.rs:13:1
   |
 LL | impl<F> FnOnce<()> for &F {