Rollup merge of #120719 - compiler-errors:no-dyn-atb, r=lcnr

Remove support for `associated_type_bound` nested in `dyn` types

These necessarily desugar to `impl Trait`, which is inconsistent with the `associated_type_bound` feature after #120584.

This PR keeps the `is_in_dyn_type` hack, which kind of makes me sad. Ideally, we'd be validating that no object types have associated type bounds somewhere else. Unfortunately, we can't do this later during astconv (i think?), nor can we do it earlier during ast validation (i think?) because of the feature gating of ATB being a *warning* rather than an *error*. Let me know if you have thoughts about this.

r? lcnr

compiler/rustc_ast_lowering/messages.ftl

@@ -8,6 +8,10 @@ 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
+    .suggestion = use `impl Trait` to introduce a type instead
+
 ast_lowering_assoc_ty_parentheses =
     parenthesized generic arguments cannot be used in associated type constraints
 
@@ -100,9 +104,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,12 @@ 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>,
+    #[suggestion(code = " = impl", applicability = "maybe-incorrect", style = "verbose")]
+    pub suggestion: Option<Span>,
 }
 
 #[derive(Diagnostic, Clone, Copy)]

compiler/rustc_ast_lowering/src/lib.rs

@@ -197,7 +197,6 @@ trait ResolverAstLoweringExt {
     fn get_label_res(&self, id: NodeId) -> Option<NodeId>;
     fn get_lifetime_res(&self, id: NodeId) -> Option<LifetimeRes>;
     fn take_extra_lifetime_params(&mut self, id: NodeId) -> Vec<(Ident, NodeId, LifetimeRes)>;
-    fn remap_extra_lifetime_params(&mut self, from: NodeId, to: NodeId);
 }
 
 impl ResolverAstLoweringExt for ResolverAstLowering {
@@ -256,11 +255,6 @@ impl ResolverAstLoweringExt for ResolverAstLowering {
     fn take_extra_lifetime_params(&mut self, id: NodeId) -> Vec<(Ident, NodeId, LifetimeRes)> {
         self.extra_lifetime_params_map.remove(&id).unwrap_or_default()
     }
-
-    fn remap_extra_lifetime_params(&mut self, from: NodeId, to: NodeId) {
-        let lifetimes = self.extra_lifetime_params_map.remove(&from).unwrap_or_default();
-        self.extra_lifetime_params_map.insert(to, lifetimes);
-    }
 }
 
 /// Context of `impl Trait` in code, which determines whether it is allowed in an HIR subtree,
@@ -1084,88 +1078,38 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 hir::TypeBindingKind::Equality { term }
             }
             AssocConstraintKind::Bound { bounds } => {
-                enum DesugarKind {
+                // Disallow ATB in dyn types
-                    ImplTrait,
+                if self.is_in_dyn_type {
-                    Error(ImplTraitPosition),
+                    let suggestion = match itctx {
-                    Bound,
+                        ImplTraitContext::ReturnPositionOpaqueTy { .. }
-                }
+                        | ImplTraitContext::TypeAliasesOpaqueTy { .. }
+                        | ImplTraitContext::Universal => {
+                            let bound_end_span = constraint
+                                .gen_args
+                                .as_ref()
+                                .map_or(constraint.ident.span, |args| args.span());
+                            if bound_end_span.eq_ctxt(constraint.span) {
+                                Some(self.tcx.sess.source_map().next_point(bound_end_span))
+                            } else {
+                                None
+                            }
+                        }
+                        _ => None,
+                    };
 
-                // Piggy-back on the `impl Trait` context to figure out the correct behavior.
+                    let guar = self.dcx().emit_err(errors::MisplacedAssocTyBinding {
-                let desugar_kind = match itctx {
+                        span: constraint.span,
-                    // in an argument, RPIT, or TAIT, if we are within a dyn type:
+                        suggestion,
-                    //
+                    });
-                    //     fn foo(x: dyn Iterator<Item: Debug>)
+                    let err_ty =
-                    //
+                        &*self.arena.alloc(self.ty(constraint.span, hir::TyKind::Err(guar)));
-                    // then desugar to:
+                    hir::TypeBindingKind::Equality { term: err_ty.into() }
-                    //
+                } else {
-                    //     fn foo(x: dyn Iterator<Item = impl Debug>)
+                    // Desugar `AssocTy: Bounds` into a type binding where the
-                    //
+                    // later desugars into a trait predicate.
-                    // This is because dyn traits must have all of their associated types specified.
+                    let bounds = self.lower_param_bounds(bounds, itctx);
-                    ImplTraitContext::ReturnPositionOpaqueTy { .. }
-                    | ImplTraitContext::TypeAliasesOpaqueTy { .. }
-                    | ImplTraitContext::Universal
-                        if self.is_in_dyn_type =>
-                    {
-                        DesugarKind::ImplTrait
-                    }
 
-                    ImplTraitContext::Disallowed(position) if self.is_in_dyn_type => {
+                    hir::TypeBindingKind::Constraint { bounds }
-                        DesugarKind::Error(position)
-                    }
-
-                    // We are in the parameter position, but not within a dyn type:
-                    //
-                    //     fn foo(x: impl Iterator<Item: Debug>)
-                    //
-                    // so we leave it as is and this gets expanded in astconv to a bound like
-                    // `<T as Iterator>::Item: Debug` where `T` is the type parameter for the
-                    // `impl Iterator`.
-                    _ => DesugarKind::Bound,
-                };
-
-                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.
-                        let bounds = self.lower_param_bounds(bounds, itctx);
-
-                        hir::TypeBindingKind::Constraint { bounds }
-                    }
-                    DesugarKind::Error(position) => {
-                        let guar = self.dcx().emit_err(errors::MisplacedAssocTyBinding {
-                            span: constraint.span,
-                            position: DiagnosticArgFromDisplay(&position),
-                        });
-                        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,13 @@
-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`
+   |                            ^^^^^^^^^^^
+   |
+help: use `impl Trait` to introduce a type instead
+   |
+LL |     type Out = Box<dyn Bar<Assoc = impl Copy>>;
+   |                                  ~~~~~~
 
 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-impl-trait-type.stderr

@@ -1,12 +0,0 @@
-warning: method `tr2` is never used
-  --> $DIR/dyn-impl-trait-type.rs:8:20
-   |
-LL | trait Tr2<'a> { fn tr2(self) -> &'a Self; }
-   |       ---          ^^^
-   |       |
-   |       method in this trait
-   |
-   = note: `#[warn(dead_code)]` on by default
-
-warning: 1 warning emitted
-

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/dyn-rpit-and-let.stderr

@@ -1,12 +0,0 @@
-warning: method `tr2` is never used
-  --> $DIR/dyn-rpit-and-let.rs:10:20
-   |
-LL | trait Tr2<'a> { fn tr2(self) -> &'a Self; }
-   |       ---          ^^^
-   |       |
-   |       method in this trait
-   |
-   = note: `#[warn(dead_code)]` on by default
-
-warning: 1 warning emitted
-

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,17 @@ 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<&()>`
+help: use `impl Trait` to introduce a type instead
-              found enum `Option<impl Iterator<Item = &'_ ()>>`
+   |
+LL | fn f(x: &mut dyn Iterator<Item = impl Iterator<Item = &'_ ()>>) -> Option<&'_ ()> { x.next() }
+   |                                ~~~~~~
 
 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`.