No more associated type bounds in dyn trait

compiler/rustc_ast_lowering/messages.ftl

@@ -8,6 +8,9 @@ ast_lowering_arbitrary_expression_in_pattern =
 
 ast_lowering_argument = argument
 
+ast_lowering_assoc_ty_binding_in_dyn =
+    associated type bounds are not allowed in `dyn` types
+
 ast_lowering_assoc_ty_parentheses =
     parenthesized generic arguments cannot be used in associated type constraints
 
@@ -100,9 +103,6 @@ ast_lowering_match_arm_with_no_body =
     `match` arm with no body
     .suggestion = add a body after the pattern
 
-ast_lowering_misplaced_assoc_ty_binding =
-    associated type bounds are only allowed in where clauses and function signatures, not in {$position}
-
 ast_lowering_misplaced_double_dot =
     `..` patterns are not allowed here
     .note = only allowed in tuple, tuple struct, and slice patterns

compiler/rustc_ast_lowering/src/errors.rs

@@ -94,11 +94,10 @@ pub struct MisplacedImplTrait<'a> {
 }
 
 #[derive(Diagnostic)]
-#[diag(ast_lowering_misplaced_assoc_ty_binding)]
+#[diag(ast_lowering_assoc_ty_binding_in_dyn)]
-pub struct MisplacedAssocTyBinding<'a> {
+pub struct MisplacedAssocTyBinding {
     #[primary_span]
     pub span: Span,
-    pub position: DiagnosticArgFromDisplay<'a>,
 }
 
 #[derive(Diagnostic, Clone, Copy)]

compiler/rustc_ast_lowering/src/lib.rs

@@ -1085,33 +1085,13 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             }
             AssocConstraintKind::Bound { bounds } => {
                 enum DesugarKind {
-                    ImplTrait,
+                    Error,
-                    Error(ImplTraitPosition),
                     Bound,
                 }
 
                 // Piggy-back on the `impl Trait` context to figure out the correct behavior.
                 let desugar_kind = match itctx {
-                    // in an argument, RPIT, or TAIT, if we are within a dyn type:
+                    _ if self.is_in_dyn_type => DesugarKind::Error,
-                    //
-                    //     fn foo(x: dyn Iterator<Item: Debug>)
-                    //
-                    // then desugar to:
-                    //
-                    //     fn foo(x: dyn Iterator<Item = impl Debug>)
-                    //
-                    // This is because dyn traits must have all of their associated types specified.
-                    ImplTraitContext::ReturnPositionOpaqueTy { .. }
-                    | ImplTraitContext::TypeAliasesOpaqueTy { .. }
-                    | ImplTraitContext::Universal
-                        if self.is_in_dyn_type =>
-                    {
-                        DesugarKind::ImplTrait
-                    }
-
-                    ImplTraitContext::Disallowed(position) if self.is_in_dyn_type => {
-                        DesugarKind::Error(position)
-                    }
 
                     // We are in the parameter position, but not within a dyn type:
                     //
@@ -1124,32 +1104,6 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 };
 
                 match desugar_kind {
-                    DesugarKind::ImplTrait => {
-                        // Desugar `AssocTy: Bounds` into `AssocTy = impl Bounds`. We do this by
-                        // constructing the HIR for `impl bounds...` and then lowering that.
-
-                        let impl_trait_node_id = self.next_node_id();
-                        // Shift `impl Trait` lifetime captures from the associated type bound's
-                        // node id to the opaque node id, so that the opaque can actually use
-                        // these lifetime bounds.
-                        self.resolver
-                            .remap_extra_lifetime_params(constraint.id, impl_trait_node_id);
-
-                        self.with_dyn_type_scope(false, |this| {
-                            let node_id = this.next_node_id();
-                            let ty = this.lower_ty(
-                                &Ty {
-                                    id: node_id,
-                                    kind: TyKind::ImplTrait(impl_trait_node_id, bounds.clone()),
-                                    span: this.lower_span(constraint.span),
-                                    tokens: None,
-                                },
-                                itctx,
-                            );
-
-                            hir::TypeBindingKind::Equality { term: ty.into() }
-                        })
-                    }
                     DesugarKind::Bound => {
                         // Desugar `AssocTy: Bounds` into a type binding where the
                         // later desugars into a trait predicate.
@@ -1157,11 +1111,10 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
 
                         hir::TypeBindingKind::Constraint { bounds }
                     }
-                    DesugarKind::Error(position) => {
+                    DesugarKind::Error => {
-                        let guar = self.dcx().emit_err(errors::MisplacedAssocTyBinding {
+                        let guar = self
-                            span: constraint.span,
+                            .dcx()
-                            position: DiagnosticArgFromDisplay(&position),
+                            .emit_err(errors::MisplacedAssocTyBinding { span: constraint.span });
-                        });
                         let err_ty =
                             &*self.arena.alloc(self.ty(constraint.span, hir::TyKind::Err(guar)));
                         hir::TypeBindingKind::Equality { term: err_ty.into() }

tests/ui/associated-type-bounds/assoc-type-eq-with-dyn-atb-fail.rs

@@ -28,9 +28,9 @@ impl Bar for AssocNoCopy {
 
 impl Thing for AssocNoCopy {
     type Out = Box<dyn Bar<Assoc: Copy>>;
+    //~^ ERROR associated type bounds are not allowed in `dyn` types
 
     fn func() -> Self::Out {
-        //~^ ERROR the trait bound `String: Copy` is not satisfied
         Box::new(AssocNoCopy)
     }
 }

tests/ui/associated-type-bounds/assoc-type-eq-with-dyn-atb-fail.stderr

@@ -1,9 +1,8 @@
-error[E0277]: the trait bound `String: Copy` is not satisfied
+error: associated type bounds are not allowed in `dyn` types
-  --> $DIR/assoc-type-eq-with-dyn-atb-fail.rs:32:18
+  --> $DIR/assoc-type-eq-with-dyn-atb-fail.rs:30:28
    |
-LL |     fn func() -> Self::Out {
+LL |     type Out = Box<dyn Bar<Assoc: Copy>>;
-   |                  ^^^^^^^^^ the trait `Copy` is not implemented for `String`
+   |                            ^^^^^^^^^^^
 
 error: aborting due to 1 previous error
 
-For more information about this error, try `rustc --explain E0277`.

tests/ui/associated-type-bounds/bad-universal-in-dyn-in-where-clause.rs

@@ -7,7 +7,7 @@ trait B {
 fn f()
 where
     dyn for<'j> B<AssocType: 'j>:,
-    //~^ ERROR associated type bounds are only allowed in where clauses and function signatures
+    //~^ ERROR associated type bounds are not allowed in `dyn` types
 {
 }
 

tests/ui/associated-type-bounds/bad-universal-in-dyn-in-where-clause.stderr

@@ -1,4 +1,4 @@
-error: associated type bounds are only allowed in where clauses and function signatures, not in bounds
+error: associated type bounds are not allowed in `dyn` types
   --> $DIR/bad-universal-in-dyn-in-where-clause.rs:9:19
    |
 LL |     dyn for<'j> B<AssocType: 'j>:,

tests/ui/associated-type-bounds/bad-universal-in-impl-sig.rs

@@ -8,6 +8,6 @@ trait Trait2 {}
 
 // It's not possible to insert a universal `impl Trait` here!
 impl dyn Trait<Item: Trait2> {}
-//~^ ERROR associated type bounds are only allowed in where clauses and function signatures
+//~^ ERROR associated type bounds are not allowed in `dyn` types
 
 fn main() {}

tests/ui/associated-type-bounds/bad-universal-in-impl-sig.stderr

@@ -1,4 +1,4 @@
-error: associated type bounds are only allowed in where clauses and function signatures, not in impl headers
+error: associated type bounds are not allowed in `dyn` types
   --> $DIR/bad-universal-in-impl-sig.rs:10:16
    |
 LL | impl dyn Trait<Item: Trait2> {}

tests/ui/associated-type-bounds/duplicate.rs

@@ -261,11 +261,4 @@ trait TRA3 {
     //~^ ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
 }
 
-type TADyn1 = dyn Iterator<Item: Copy, Item: Send>;
-//~^ ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-type TADyn2 = Box<dyn Iterator<Item: Copy, Item: Copy>>;
-//~^ ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-type TADyn3 = dyn Iterator<Item: 'static, Item: 'static>;
-//~^ ERROR the value of the associated type `Item` in trait `Iterator` is already specified [E0719]
-
 fn main() {}

tests/ui/associated-type-bounds/duplicate.stderr

@@ -6,30 +6,6 @@ LL | struct SI1<T: Iterator<Item: Copy, Item: Send>> {
    |                        |
    |                        `Item` bound here first
 
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:264:40
-   |
-LL | type TADyn1 = dyn Iterator<Item: Copy, Item: Send>;
-   |                            ----------  ^^^^^^^^^^ re-bound here
-   |                            |
-   |                            `Item` bound here first
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:266:44
-   |
-LL | type TADyn2 = Box<dyn Iterator<Item: Copy, Item: Copy>>;
-   |                                ----------  ^^^^^^^^^^ re-bound here
-   |                                |
-   |                                `Item` bound here first
-
-error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
-  --> $DIR/duplicate.rs:268:43
-   |
-LL | type TADyn3 = dyn Iterator<Item: 'static, Item: 'static>;
-   |                            -------------  ^^^^^^^^^^^^^ re-bound here
-   |                            |
-   |                            `Item` bound here first
-
 error[E0719]: the value of the associated type `Item` in trait `Iterator` is already specified
   --> $DIR/duplicate.rs:11:36
    |
@@ -631,7 +607,7 @@ LL |     Self: Iterator<Item: 'static, Item: 'static>,
    |
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
-error: aborting due to 75 previous errors
+error: aborting due to 72 previous errors
 
 Some errors have detailed explanations: E0282, E0719.
 For more information about an error, try `rustc --explain E0282`.

tests/ui/associated-type-bounds/dyn-impl-trait-type.rs

@@ -1,66 +0,0 @@
-// run-pass
-
-#![feature(associated_type_bounds)]
-
-use std::ops::Add;
-
-trait Tr1 { type As1; fn mk(&self) -> Self::As1; }
-trait Tr2<'a> { fn tr2(self) -> &'a Self; } //~ WARN method `tr2` is never used
-
-fn assert_copy<T: Copy>(x: T) { let _x = x; let _x = x; }
-fn assert_static<T: 'static>(_: T) {}
-fn assert_forall_tr2<T: for<'a> Tr2<'a>>(_: T) {}
-
-struct S1;
-#[derive(Copy, Clone)]
-struct S2;
-impl Tr1 for S1 { type As1 = S2; fn mk(&self) -> Self::As1 { S2 } }
-
-type Et1 = Box<dyn Tr1<As1: Copy>>;
-fn def_et1() -> Et1 { Box::new(S1) }
-pub fn use_et1() { assert_copy(def_et1().mk()); }
-
-type Et2 = Box<dyn Tr1<As1: 'static>>;
-fn def_et2() -> Et2 { Box::new(S1) }
-pub fn use_et2() { assert_static(def_et2().mk()); }
-
-type Et3 = Box<dyn Tr1<As1: Clone + Iterator<Item: Add<u8, Output: Into<u8>>>>>;
-fn def_et3() -> Et3 {
-    struct A;
-    impl Tr1 for A {
-        type As1 = core::ops::Range<u8>;
-        fn mk(&self) -> Self::As1 { 0..10 }
-    }
-    Box::new(A)
-}
-pub fn use_et3() {
-    let _0 = def_et3().mk().clone();
-    let mut s = 0u8;
-    for _1 in _0 {
-        let _2 = _1 + 1u8;
-        s += _2.into();
-    }
-    assert_eq!(s, (0..10).map(|x| x + 1).sum());
-}
-
-type Et4 = Box<dyn Tr1<As1: for<'a> Tr2<'a>>>;
-fn def_et4() -> Et4 {
-    #[derive(Copy, Clone)]
-    struct A;
-    impl Tr1 for A {
-        type As1 = A;
-        fn mk(&self) -> A { A }
-    }
-    impl<'a> Tr2<'a> for A {
-        fn tr2(self) -> &'a Self { &A }
-    }
-    Box::new(A)
-}
-pub fn use_et4() { assert_forall_tr2(def_et4().mk()); }
-
-fn main() {
-    use_et1();
-    use_et2();
-    use_et3();
-    use_et4();
-}

tests/ui/associated-type-bounds/dyn-rpit-and-let.rs

@@ -1,73 +0,0 @@
-// run-pass
-
-// FIXME: uncomment let binding types below when `impl_trait_in_bindings` feature is fixed.
-
-#![feature(associated_type_bounds)]
-
-use std::ops::Add;
-
-trait Tr1 { type As1; fn mk(&self) -> Self::As1; }
-trait Tr2<'a> { fn tr2(self) -> &'a Self; } //~ WARN method `tr2` is never used
-
-fn assert_copy<T: Copy>(x: T) { let _x = x; let _x = x; }
-fn assert_static<T: 'static>(_: T) {}
-fn assert_forall_tr2<T: for<'a> Tr2<'a>>(_: T) {}
-
-struct S1;
-#[derive(Copy, Clone)]
-struct S2;
-impl Tr1 for S1 { type As1 = S2; fn mk(&self) -> Self::As1 { S2 } }
-
-fn def_et1() -> Box<dyn Tr1<As1: Copy>> {
-    let x /* : Box<dyn Tr1<As1: Copy>> */ = Box::new(S1);
-    x
-}
-pub fn use_et1() { assert_copy(def_et1().mk()); }
-
-fn def_et2() -> Box<dyn Tr1<As1: Send + 'static>> {
-    let x /* : Box<dyn Tr1<As1: Send + 'static>> */ = Box::new(S1);
-    x
-}
-pub fn use_et2() { assert_static(def_et2().mk()); }
-
-fn def_et3() -> Box<dyn Tr1<As1: Clone + Iterator<Item: Add<u8, Output: Into<u8>>>>> {
-    struct A;
-    impl Tr1 for A {
-        type As1 = core::ops::Range<u8>;
-        fn mk(&self) -> Self::As1 { 0..10 }
-    }
-    let x /* : Box<dyn Tr1<As1: Clone + Iterator<Item: Add<u8, Output: Into<u8>>>>> */
-        = Box::new(A);
-    x
-}
-pub fn use_et3() {
-    let _0 = def_et3().mk().clone();
-    let mut s = 0u8;
-    for _1 in _0 {
-        let _2 = _1 + 1u8;
-        s += _2.into();
-    }
-    assert_eq!(s, (0..10).map(|x| x + 1).sum());
-}
-
-fn def_et4() -> Box<dyn Tr1<As1: for<'a> Tr2<'a>>> {
-    #[derive(Copy, Clone)]
-    struct A;
-    impl Tr1 for A {
-        type As1 = A;
-        fn mk(&self) -> A { A }
-    }
-    impl<'a> Tr2<'a> for A {
-        fn tr2(self) -> &'a Self { &A }
-    }
-    let x /* : Box<dyn Tr1<As1: for<'a> Tr2<'a>>> */ = Box::new(A);
-    x
-}
-pub fn use_et4() { assert_forall_tr2(def_et4().mk()); }
-
-fn main() {
-    use_et1();
-    use_et2();
-    use_et3();
-    use_et4();
-}

tests/ui/associated-type-bounds/elision.rs

@@ -3,7 +3,7 @@
 
 // The same thing should happen for constraints in dyn trait.
 fn f(x: &mut dyn Iterator<Item: Iterator<Item = &'_ ()>>) -> Option<&'_ ()> { x.next() }
-//~^ ERROR missing lifetime specifier
+//~^ ERROR associated type bounds are not allowed in `dyn` types
-//~| ERROR mismatched types
+//~| ERROR missing lifetime specifier
 
 fn main() {}

tests/ui/associated-type-bounds/elision.stderr

@@ -10,19 +10,12 @@ help: consider introducing a named lifetime parameter
 LL | fn f<'a>(x: &'a mut dyn Iterator<Item: Iterator<Item = &'a ()>>) -> Option<&'a ()> { x.next() }
    |     ++++     ++                                         ~~                  ~~
 
-error[E0308]: mismatched types
+error: associated type bounds are not allowed in `dyn` types
-  --> $DIR/elision.rs:5:79
+  --> $DIR/elision.rs:5:27
    |
 LL | fn f(x: &mut dyn Iterator<Item: Iterator<Item = &'_ ()>>) -> Option<&'_ ()> { x.next() }
-   |                           -----------------------------      --------------   ^^^^^^^^ expected `Option<&()>`, found `Option<impl Iterator<Item = &'_ ()>>`
+   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |                           |                                  |
-   |                           |                                  expected `Option<&()>` because of return type
-   |                           found this type parameter
-   |
-   = note: expected enum `Option<&()>`
-              found enum `Option<impl Iterator<Item = &'_ ()>>`
 
 error: aborting due to 2 previous errors
 
-Some errors have detailed explanations: E0106, E0308.
+For more information about this error, try `rustc --explain E0106`.
-For more information about an error, try `rustc --explain E0106`.

tests/ui/associated-type-bounds/fn-dyn-apit.rs

@@ -1,61 +0,0 @@
-// run-pass
-// aux-build:fn-dyn-aux.rs
-
-#![allow(unused)]
-#![feature(associated_type_bounds)]
-
-extern crate fn_dyn_aux;
-
-use fn_dyn_aux::*;
-
-// ATB, APIT (dyn trait):
-
-fn dyn_apit_bound(beta: &dyn Beta<Gamma: Alpha>) -> usize {
-    desugared_bound(beta)
-}
-
-fn dyn_apit_bound_region(beta: &dyn Beta<Gamma: 'static>) -> usize {
-    desugared_bound_region(beta)
-}
-
-fn dyn_apit_bound_multi(
-    beta: &(dyn Beta<Gamma: Alpha + 'static + Delta> + Send)
-) -> usize {
-    desugared_bound_multi(beta)
-}
-
-fn dyn_apit_bound_region_forall(
-    beta: &dyn Beta<Gamma: Copy + for<'a> Epsilon<'a>>
-) -> usize {
-    desugared_bound_region_forall(beta)
-}
-
-fn dyn_apit_bound_region_forall2(
-    beta: &dyn Beta<Gamma: Copy + for<'a> Epsilon<'a, Zeta: Eta>>
-) -> usize {
-    desugared_bound_region_forall2(beta)
-}
-
-fn dyn_apit_bound_nested(
-    beta: &dyn Beta<Gamma: Copy + Alpha + Beta<Gamma: Delta>>
-) -> usize {
-    desugared_bound_nested(beta)
-}
-
-fn dyn_apit_bound_nested2(
-    beta: &dyn Beta<Gamma = impl Copy + Alpha + Beta<Gamma: Delta>>
-) -> usize {
-    desugared_bound_nested(beta)
-}
-
-fn main() {
-    let beta = BetaType;
-    let _gamma = beta.gamma();
-
-    assert_eq!(42, dyn_apit_bound(&beta));
-    assert_eq!(24, dyn_apit_bound_region(&beta));
-    assert_eq!(42 + 24 + 1337, dyn_apit_bound_multi(&beta));
-    assert_eq!(7331 * 2, dyn_apit_bound_region_forall(&beta));
-    assert_eq!(42 + 1337, dyn_apit_bound_nested(&beta));
-    assert_eq!(42 + 1337, dyn_apit_bound_nested2(&beta));
-}

tests/ui/associated-type-bounds/inside-adt.rs

@@ -3,24 +3,24 @@
 use std::mem::ManuallyDrop;
 
 struct S1 { f: dyn Iterator<Item: Copy> }
-//~^ ERROR associated type bounds are only allowed in where clauses and function signatures
+//~^ ERROR associated type bounds are not allowed in `dyn` types
 struct S2 { f: Box<dyn Iterator<Item: Copy>> }
-//~^ ERROR associated type bounds are only allowed in where clauses and function signatures
+//~^ ERROR associated type bounds are not allowed in `dyn` types
 struct S3 { f: dyn Iterator<Item: 'static> }
-//~^ ERROR associated type bounds are only allowed in where clauses and function signatures
+//~^ ERROR associated type bounds are not allowed in `dyn` types
 
 enum E1 { V(dyn Iterator<Item: Copy>) }
-//~^ ERROR associated type bounds are only allowed in where clauses and function signatures
+//~^ ERROR associated type bounds are not allowed in `dyn` types
 enum E2 { V(Box<dyn Iterator<Item: Copy>>) }
-//~^ ERROR associated type bounds are only allowed in where clauses and function signatures
+//~^ ERROR associated type bounds are not allowed in `dyn` types
 enum E3 { V(dyn Iterator<Item: 'static>) }
-//~^ ERROR associated type bounds are only allowed in where clauses and function signatures
+//~^ ERROR associated type bounds are not allowed in `dyn` types
 
 union U1 { f: ManuallyDrop<dyn Iterator<Item: Copy>> }
-//~^ ERROR associated type bounds are only allowed in where clauses and function signatures
+//~^ ERROR associated type bounds are not allowed in `dyn` types
 union U2 { f: ManuallyDrop<Box<dyn Iterator<Item: Copy>>> }
-//~^ ERROR associated type bounds are only allowed in where clauses and function signatures
+//~^ ERROR associated type bounds are not allowed in `dyn` types
 union U3 { f: ManuallyDrop<dyn Iterator<Item: 'static>> }
-//~^ ERROR associated type bounds are only allowed in where clauses and function signatures
+//~^ ERROR associated type bounds are not allowed in `dyn` types
 
 fn main() {}

tests/ui/associated-type-bounds/inside-adt.stderr

@@ -1,52 +1,52 @@
-error: associated type bounds are only allowed in where clauses and function signatures, not in field types
+error: associated type bounds are not allowed in `dyn` types
   --> $DIR/inside-adt.rs:5:29
    |
 LL | struct S1 { f: dyn Iterator<Item: Copy> }
    |                             ^^^^^^^^^^
 
-error: associated type bounds are only allowed in where clauses and function signatures, not in field types
+error: associated type bounds are not allowed in `dyn` types
   --> $DIR/inside-adt.rs:7:33
    |
 LL | struct S2 { f: Box<dyn Iterator<Item: Copy>> }
    |                                 ^^^^^^^^^^
 
-error: associated type bounds are only allowed in where clauses and function signatures, not in field types
+error: associated type bounds are not allowed in `dyn` types
   --> $DIR/inside-adt.rs:9:29
    |
 LL | struct S3 { f: dyn Iterator<Item: 'static> }
    |                             ^^^^^^^^^^^^^
 
-error: associated type bounds are only allowed in where clauses and function signatures, not in field types
+error: associated type bounds are not allowed in `dyn` types
   --> $DIR/inside-adt.rs:12:26
    |
 LL | enum E1 { V(dyn Iterator<Item: Copy>) }
    |                          ^^^^^^^^^^
 
-error: associated type bounds are only allowed in where clauses and function signatures, not in field types
+error: associated type bounds are not allowed in `dyn` types
   --> $DIR/inside-adt.rs:14:30
    |
 LL | enum E2 { V(Box<dyn Iterator<Item: Copy>>) }
    |                              ^^^^^^^^^^
 
-error: associated type bounds are only allowed in where clauses and function signatures, not in field types
+error: associated type bounds are not allowed in `dyn` types
   --> $DIR/inside-adt.rs:16:26
    |
 LL | enum E3 { V(dyn Iterator<Item: 'static>) }
    |                          ^^^^^^^^^^^^^
 
-error: associated type bounds are only allowed in where clauses and function signatures, not in field types
+error: associated type bounds are not allowed in `dyn` types
   --> $DIR/inside-adt.rs:19:41
    |
 LL | union U1 { f: ManuallyDrop<dyn Iterator<Item: Copy>> }
    |                                         ^^^^^^^^^^
 
-error: associated type bounds are only allowed in where clauses and function signatures, not in field types
+error: associated type bounds are not allowed in `dyn` types
   --> $DIR/inside-adt.rs:21:45
    |
 LL | union U2 { f: ManuallyDrop<Box<dyn Iterator<Item: Copy>>> }
    |                                             ^^^^^^^^^^
 
-error: associated type bounds are only allowed in where clauses and function signatures, not in field types
+error: associated type bounds are not allowed in `dyn` types
   --> $DIR/inside-adt.rs:23:41
    |
 LL | union U3 { f: ManuallyDrop<dyn Iterator<Item: 'static>> }

tests/ui/associated-type-bounds/issue-104916.rs

@@ -7,7 +7,7 @@ trait B {
 fn f()
 where
     dyn for<'j> B<AssocType: 'j>:,
-    //~^ ERROR: associated type bounds are only allowed in where clauses and function signatures
+    //~^ ERROR: associated type bounds are not allowed in `dyn` types
 {
 }
 

tests/ui/associated-type-bounds/issue-104916.stderr

@@ -1,4 +1,4 @@
-error: associated type bounds are only allowed in where clauses and function signatures, not in bounds
+error: associated type bounds are not allowed in `dyn` types
   --> $DIR/issue-104916.rs:9:19
    |
 LL |     dyn for<'j> B<AssocType: 'j>:,

tests/ui/feature-gates/feature-gate-associated_type_bounds.rs

@@ -42,31 +42,20 @@ type _TaWhere1<T> where T: Iterator<Item: Copy> = T;
 
 fn _apit(_: impl Tr1<As1: Copy>) {}
 //~^ ERROR associated type bounds are unstable
-fn _apit_dyn(_: &dyn Tr1<As1: Copy>) {}
-//~^ ERROR associated type bounds are unstable
 
 fn _rpit() -> impl Tr1<As1: Copy> { S1 }
 //~^ ERROR associated type bounds are unstable
 
-fn _rpit_dyn() -> Box<dyn Tr1<As1: Copy>> { Box::new(S1) }
-//~^ ERROR associated type bounds are unstable
-
 const _cdef: impl Tr1<As1: Copy> = S1;
 //~^ ERROR associated type bounds are unstable
 //~| ERROR `impl Trait` is not allowed in const types
-// FIXME: uncomment when `impl_trait_in_bindings` feature is fixed.
-// const _cdef_dyn: &dyn Tr1<As1: Copy> = &S1;
 
 static _sdef: impl Tr1<As1: Copy> = S1;
 //~^ ERROR associated type bounds are unstable
 //~| ERROR `impl Trait` is not allowed in static types
-// FIXME: uncomment when `impl_trait_in_bindings` feature is fixed.
-// static _sdef_dyn: &dyn Tr1<As1: Copy> = &S1;
 
 fn main() {
     let _: impl Tr1<As1: Copy> = S1;
     //~^ ERROR associated type bounds are unstable
     //~| ERROR `impl Trait` is not allowed in the type of variable bindings
-    // FIXME: uncomment when `impl_trait_in_bindings` feature is fixed.
-    // let _: &dyn Tr1<As1: Copy> = &S1;
 }

tests/ui/feature-gates/feature-gate-associated_type_bounds.stderr

@@ -69,17 +69,7 @@ LL | fn _apit(_: impl Tr1<As1: Copy>) {}
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: associated type bounds are unstable
-  --> $DIR/feature-gate-associated_type_bounds.rs:45:26
+  --> $DIR/feature-gate-associated_type_bounds.rs:46:24
-   |
-LL | fn _apit_dyn(_: &dyn Tr1<As1: Copy>) {}
-   |                          ^^^^^^^^^
-   |
-   = note: see issue #52662 <https://github.com/rust-lang/rust/issues/52662> for more information
-   = help: add `#![feature(associated_type_bounds)]` to the crate attributes to enable
-   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
-
-error[E0658]: associated type bounds are unstable
-  --> $DIR/feature-gate-associated_type_bounds.rs:48:24
    |
 LL | fn _rpit() -> impl Tr1<As1: Copy> { S1 }
    |                        ^^^^^^^^^
@@ -89,17 +79,7 @@ LL | fn _rpit() -> impl Tr1<As1: Copy> { S1 }
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: associated type bounds are unstable
-  --> $DIR/feature-gate-associated_type_bounds.rs:51:31
+  --> $DIR/feature-gate-associated_type_bounds.rs:49:23
-   |
-LL | fn _rpit_dyn() -> Box<dyn Tr1<As1: Copy>> { Box::new(S1) }
-   |                               ^^^^^^^^^
-   |
-   = note: see issue #52662 <https://github.com/rust-lang/rust/issues/52662> for more information
-   = help: add `#![feature(associated_type_bounds)]` to the crate attributes to enable
-   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
-
-error[E0658]: associated type bounds are unstable
-  --> $DIR/feature-gate-associated_type_bounds.rs:54:23
    |
 LL | const _cdef: impl Tr1<As1: Copy> = S1;
    |                       ^^^^^^^^^
@@ -109,7 +89,7 @@ LL | const _cdef: impl Tr1<As1: Copy> = S1;
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: associated type bounds are unstable
-  --> $DIR/feature-gate-associated_type_bounds.rs:60:24
+  --> $DIR/feature-gate-associated_type_bounds.rs:53:24
    |
 LL | static _sdef: impl Tr1<As1: Copy> = S1;
    |                        ^^^^^^^^^
@@ -119,7 +99,7 @@ LL | static _sdef: impl Tr1<As1: Copy> = S1;
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: associated type bounds are unstable
-  --> $DIR/feature-gate-associated_type_bounds.rs:67:21
+  --> $DIR/feature-gate-associated_type_bounds.rs:58:21
    |
 LL |     let _: impl Tr1<As1: Copy> = S1;
    |                     ^^^^^^^^^
@@ -129,7 +109,7 @@ LL |     let _: impl Tr1<As1: Copy> = S1;
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0562]: `impl Trait` is not allowed in const types
-  --> $DIR/feature-gate-associated_type_bounds.rs:54:14
+  --> $DIR/feature-gate-associated_type_bounds.rs:49:14
    |
 LL | const _cdef: impl Tr1<As1: Copy> = S1;
    |              ^^^^^^^^^^^^^^^^^^^
@@ -137,7 +117,7 @@ LL | const _cdef: impl Tr1<As1: Copy> = S1;
    = note: `impl Trait` is only allowed in arguments and return types of functions and methods
 
 error[E0562]: `impl Trait` is not allowed in static types
-  --> $DIR/feature-gate-associated_type_bounds.rs:60:15
+  --> $DIR/feature-gate-associated_type_bounds.rs:53:15
    |
 LL | static _sdef: impl Tr1<As1: Copy> = S1;
    |               ^^^^^^^^^^^^^^^^^^^
@@ -145,14 +125,14 @@ LL | static _sdef: impl Tr1<As1: Copy> = S1;
    = note: `impl Trait` is only allowed in arguments and return types of functions and methods
 
 error[E0562]: `impl Trait` is not allowed in the type of variable bindings
-  --> $DIR/feature-gate-associated_type_bounds.rs:67:12
+  --> $DIR/feature-gate-associated_type_bounds.rs:58:12
    |
 LL |     let _: impl Tr1<As1: Copy> = S1;
    |            ^^^^^^^^^^^^^^^^^^^
    |
    = note: `impl Trait` is only allowed in arguments and return types of functions and methods
 
-error: aborting due to 16 previous errors
+error: aborting due to 14 previous errors
 
 Some errors have detailed explanations: E0562, E0658.
 For more information about an error, try `rustc --explain E0562`.