Rename ui test items

Jules-Bertholet · Jules-Bertholet · commit 5de617e71f7a · 2025-09-25T23:57:59.000-04:00
diff --git a/tests/ui/associated-type-bounds/duplicate-bound-err.rs b/tests/ui/associated-type-bounds/duplicate-bound-err.rs
@@ -5,31 +5,31 @@
 
 use std::iter;
 
-fn frpit1() -> impl Iterator<Item: Copy, Item: Send> {
+fn rpit1() -> impl Iterator<Item: Copy, Item: Send> {
     iter::empty()
     //~^ ERROR type annotations needed
 }
-fn frpit2() -> impl Iterator<Item: Copy, Item: Copy> {
+fn rpit2() -> impl Iterator<Item: Copy, Item: Copy> {
     iter::empty()
     //~^ ERROR type annotations needed
 }
-fn frpit3() -> impl Iterator<Item: 'static, Item: 'static> {
+fn rpit3() -> impl Iterator<Item: 'static, Item: 'static> {
     iter::empty()
     //~^ ERROR type annotations needed
 }
 
-type ETAI1<T: Iterator<Item: Copy, Item: Send>> = impl Copy;
+type Tait1<T: Iterator<Item: Copy, Item: Send>> = impl Copy;
 //~^ ERROR unconstrained opaque type
-type ETAI2<T: Iterator<Item: Copy, Item: Copy>> = impl Copy;
+type Tait2<T: Iterator<Item: Copy, Item: Copy>> = impl Copy;
 //~^ ERROR unconstrained opaque type
-type ETAI3<T: Iterator<Item: 'static, Item: 'static>> = impl Copy;
+type Tait3<T: Iterator<Item: 'static, Item: 'static>> = impl Copy;
 //~^ ERROR unconstrained opaque type
 
-type ETAI4 = impl Iterator<Item: Copy, Item: Send>;
+type Tait4 = impl Iterator<Item: Copy, Item: Send>;
 //~^ ERROR unconstrained opaque type
-type ETAI5 = impl Iterator<Item: Copy, Item: Copy>;
+type Tait5 = impl Iterator<Item: Copy, Item: Copy>;
 //~^ ERROR unconstrained opaque type
-type ETAI6 = impl Iterator<Item: 'static, Item: 'static>;
+type Tait6 = impl Iterator<Item: 'static, Item: 'static>;
 //~^ ERROR unconstrained opaque type
 
 fn mismatch() -> impl Iterator<Item: Copy, Item: Send> {
diff --git a/tests/ui/associated-type-bounds/duplicate-bound-err.stderr b/tests/ui/associated-type-bounds/duplicate-bound-err.stderr
@@ -34,50 +34,50 @@ LL |     iter::empty::<T>()
 error: unconstrained opaque type
   --> $DIR/duplicate-bound-err.rs:21:51
    |
-LL | type ETAI1<T: Iterator<Item: Copy, Item: Send>> = impl Copy;
+LL | type Tait1<T: Iterator<Item: Copy, Item: Send>> = impl Copy;
    |                                                   ^^^^^^^^^
    |
-   = note: `ETAI1` must be used in combination with a concrete type within the same crate
+   = note: `Tait1` must be used in combination with a concrete type within the same crate
 
 error: unconstrained opaque type
   --> $DIR/duplicate-bound-err.rs:23:51
    |
-LL | type ETAI2<T: Iterator<Item: Copy, Item: Copy>> = impl Copy;
+LL | type Tait2<T: Iterator<Item: Copy, Item: Copy>> = impl Copy;
    |                                                   ^^^^^^^^^
    |
-   = note: `ETAI2` must be used in combination with a concrete type within the same crate
+   = note: `Tait2` must be used in combination with a concrete type within the same crate
 
 error: unconstrained opaque type
   --> $DIR/duplicate-bound-err.rs:25:57
    |
-LL | type ETAI3<T: Iterator<Item: 'static, Item: 'static>> = impl Copy;
+LL | type Tait3<T: Iterator<Item: 'static, Item: 'static>> = impl Copy;
    |                                                         ^^^^^^^^^
    |
-   = note: `ETAI3` must be used in combination with a concrete type within the same crate
+   = note: `Tait3` must be used in combination with a concrete type within the same crate
 
 error: unconstrained opaque type
   --> $DIR/duplicate-bound-err.rs:28:14
    |
-LL | type ETAI4 = impl Iterator<Item: Copy, Item: Send>;
+LL | type Tait4 = impl Iterator<Item: Copy, Item: Send>;
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: `ETAI4` must be used in combination with a concrete type within the same crate
+   = note: `Tait4` must be used in combination with a concrete type within the same crate
 
 error: unconstrained opaque type
   --> $DIR/duplicate-bound-err.rs:30:14
    |
-LL | type ETAI5 = impl Iterator<Item: Copy, Item: Copy>;
+LL | type Tait5 = impl Iterator<Item: Copy, Item: Copy>;
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: `ETAI5` must be used in combination with a concrete type within the same crate
+   = note: `Tait5` must be used in combination with a concrete type within the same crate
 
 error: unconstrained opaque type
   --> $DIR/duplicate-bound-err.rs:32:14
    |
-LL | type ETAI6 = impl Iterator<Item: 'static, Item: 'static>;
+LL | type Tait6 = impl Iterator<Item: 'static, Item: 'static>;
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: `ETAI6` must be used in combination with a concrete type within the same crate
+   = note: `Tait6` must be used in combination with a concrete type within the same crate
 
 error[E0277]: `*const ()` cannot be sent between threads safely
   --> $DIR/duplicate-bound-err.rs:35:18
diff --git a/tests/ui/associated-type-bounds/duplicate-bound.rs b/tests/ui/associated-type-bounds/duplicate-bound.rs
@@ -7,84 +7,84 @@
 use std::iter;
 use std::mem::ManuallyDrop;
 
-struct SI1<T: Iterator<Item: Copy, Item: Send>> {
+struct Si1<T: Iterator<Item: Copy, Item: Send>> {
     f: T,
 }
-struct SI2<T: Iterator<Item: Copy, Item: Copy>> {
+struct Si2<T: Iterator<Item: Copy, Item: Copy>> {
     f: T,
 }
-struct SI3<T: Iterator<Item: 'static, Item: 'static>> {
+struct Si3<T: Iterator<Item: 'static, Item: 'static>> {
     f: T,
 }
-struct SW1<T>
+struct Sw1<T>
 where
     T: Iterator<Item: Copy, Item: Send>,
 {
     f: T,
 }
-struct SW2<T>
+struct Sw2<T>
 where
     T: Iterator<Item: Copy, Item: Copy>,
 {
     f: T,
 }
-struct SW3<T>
+struct Sw3<T>
 where
     T: Iterator<Item: 'static, Item: 'static>,
 {
     f: T,
 }
 
-enum EI1<T: Iterator<Item: Copy, Item: Send>> {
+enum Ei1<T: Iterator<Item: Copy, Item: Send>> {
     V(T),
 }
-enum EI2<T: Iterator<Item: Copy, Item: Copy>> {
+enum Ei2<T: Iterator<Item: Copy, Item: Copy>> {
     V(T),
 }
-enum EI3<T: Iterator<Item: 'static, Item: 'static>> {
+enum Ei3<T: Iterator<Item: 'static, Item: 'static>> {
     V(T),
 }
-enum EW1<T>
+enum Ew1<T>
 where
     T: Iterator<Item: Copy, Item: Send>,
 {
     V(T),
 }
-enum EW2<T>
+enum Ew2<T>
 where
     T: Iterator<Item: Copy, Item: Copy>,
 {
     V(T),
 }
-enum EW3<T>
+enum Ew3<T>
 where
     T: Iterator<Item: 'static, Item: 'static>,
 {
     V(T),
 }
 
-union UI1<T: Iterator<Item: Copy, Item: Send>> {
+union Ui1<T: Iterator<Item: Copy, Item: Send>> {
     f: ManuallyDrop<T>,
 }
-union UI2<T: Iterator<Item: Copy, Item: Copy>> {
+union Ui2<T: Iterator<Item: Copy, Item: Copy>> {
     f: ManuallyDrop<T>,
 }
-union UI3<T: Iterator<Item: 'static, Item: 'static>> {
+union Ui3<T: Iterator<Item: 'static, Item: 'static>> {
     f: ManuallyDrop<T>,
 }
-union UW1<T>
+union Uw1<T>
 where
     T: Iterator<Item: Copy, Item: Send>,
 {
     f: ManuallyDrop<T>,
 }
-union UW2<T>
+union Uw2<T>
 where
     T: Iterator<Item: Copy, Item: Copy>,
 {
     f: ManuallyDrop<T>,
 }
-union UW3<T>
+union Uw3<T>
 where
     T: Iterator<Item: 'static, Item: 'static>,
 {
@@ -110,78 +110,78 @@ where
 {
 }
 
-fn frpit1() -> impl Iterator<Item: Copy, Item: Send> {
+fn rpit1() -> impl Iterator<Item: Copy, Item: Send> {
     iter::empty::<u32>()
 }
-fn frpit2() -> impl Iterator<Item: Copy, Item: Copy> {
+fn rpit2() -> impl Iterator<Item: Copy, Item: Copy> {
     iter::empty::<u32>()
 }
-fn frpit3() -> impl Iterator<Item: 'static, Item: 'static> {
+fn rpit3() -> impl Iterator<Item: 'static, Item: 'static> {
     iter::empty::<u32>()
 }
-fn fapit1(_: impl Iterator<Item: Copy, Item: Send>) {}
-fn fapit2(_: impl Iterator<Item: Copy, Item: Copy>) {}
-fn fapit3(_: impl Iterator<Item: 'static, Item: 'static>) {}
+fn apit1(_: impl Iterator<Item: Copy, Item: Send>) {}
+fn apit2(_: impl Iterator<Item: Copy, Item: Copy>) {}
+fn apit3(_: impl Iterator<Item: 'static, Item: 'static>) {}
 
-type TAI1<T: Iterator<Item: Copy, Item: Send>> = T;
-type TAI2<T: Iterator<Item: Copy, Item: Copy>> = T;
-type TAI3<T: Iterator<Item: 'static, Item: 'static>> = T;
-type TAW1<T>
+type Tait1<T: Iterator<Item: Copy, Item: Send>> = T;
+type Tait2<T: Iterator<Item: Copy, Item: Copy>> = T;
+type Tait3<T: Iterator<Item: 'static, Item: 'static>> = T;
+type Taw1<T>
 where
     T: Iterator<Item: Copy, Item: Send>,
 = T;
-type TAW2<T>
+type Taw2<T>
 where
     T: Iterator<Item: Copy, Item: Copy>,
 = T;
-type TAW3<T>
+type Taw3<T>
 where
     T: Iterator<Item: 'static, Item: 'static>,
 = T;
 
-trait TRI1<T: Iterator<Item: Copy, Item: Send>> {}
-trait TRI2<T: Iterator<Item: Copy, Item: Copy>> {}
-trait TRI3<T: Iterator<Item: 'static, Item: 'static>> {}
-trait TRS1: Iterator<Item: Copy, Item: Send> {}
-trait TRS2: Iterator<Item: Copy, Item: Copy> {}
-trait TRS3: Iterator<Item: 'static, Item: 'static> {}
-trait TRW1<T>
+trait Tri1<T: Iterator<Item: Copy, Item: Send>> {}
+trait Tri2<T: Iterator<Item: Copy, Item: Copy>> {}
+trait Tri3<T: Iterator<Item: 'static, Item: 'static>> {}
+trait Trs1: Iterator<Item: Copy, Item: Send> {}
+trait Trs2: Iterator<Item: Copy, Item: Copy> {}
+trait Trs3: Iterator<Item: 'static, Item: 'static> {}
+trait Trw1<T>
 where
     T: Iterator<Item: Copy, Item: Send>,
 {
 }
-trait TRW2<T>
+trait Trw2<T>
 where
     T: Iterator<Item: Copy, Item: Copy>,
 {
 }
-trait TRW3<T>
+trait Trw3<T>
 where
     T: Iterator<Item: 'static, Item: 'static>,
 {
 }
-trait TRSW1
+trait Trsw1
 where
     Self: Iterator<Item: Copy, Item: Send>,
 {
 }
-trait TRSW2
+trait Trsw2
 where
     Self: Iterator<Item: Copy, Item: Copy>,
 {
 }
-trait TRSW3
+trait Trsw3
 where
     Self: Iterator<Item: 'static, Item: 'static>,
 {
 }
-trait TRA1 {
+trait Tra1 {
     type A: Iterator<Item: Copy, Item: Send>;
 }
-trait TRA2 {
+trait Tra2 {
     type A: Iterator<Item: Copy, Item: Copy>;
 }
-trait TRA3 {
+trait Tra3 {
     type A: Iterator<Item: 'static, Item: 'static>;
 }
 

Original file line number	Diff line number	Diff line change
`@@ -34,50 +34,50 @@ LL \| iter::empty::<T>()`
`34`	`34`	`error: unconstrained opaque type`
`35`	`35`	`--> $DIR/duplicate-bound-err.rs:21:51`
`36`	`36`	`\|`
`37`		`-LL \| type ETAI1<T: Iterator<Item: Copy, Item: Send>> = impl Copy;`
	`37`	`+LL \| type Tait1<T: Iterator<Item: Copy, Item: Send>> = impl Copy;`
`38`	`38`	`\| ^^^^^^^^^`
`39`	`39`	`\|`
`40`		- = note: `ETAI1` must be used in combination with a concrete type within the same crate
	`40`	+ = note: `Tait1` must be used in combination with a concrete type within the same crate
`41`	`41`
`42`	`42`	`error: unconstrained opaque type`
`43`	`43`	`--> $DIR/duplicate-bound-err.rs:23:51`
`44`	`44`	`\|`
`45`		`-LL \| type ETAI2<T: Iterator<Item: Copy, Item: Copy>> = impl Copy;`
	`45`	`+LL \| type Tait2<T: Iterator<Item: Copy, Item: Copy>> = impl Copy;`
`46`	`46`	`\| ^^^^^^^^^`
`47`	`47`	`\|`
`48`		- = note: `ETAI2` must be used in combination with a concrete type within the same crate
	`48`	+ = note: `Tait2` must be used in combination with a concrete type within the same crate
`49`	`49`
`50`	`50`	`error: unconstrained opaque type`
`51`	`51`	`--> $DIR/duplicate-bound-err.rs:25:57`
`52`	`52`	`\|`
`53`		`-LL \| type ETAI3<T: Iterator<Item: 'static, Item: 'static>> = impl Copy;`
	`53`	`+LL \| type Tait3<T: Iterator<Item: 'static, Item: 'static>> = impl Copy;`
`54`	`54`	`\| ^^^^^^^^^`
`55`	`55`	`\|`
`56`		- = note: `ETAI3` must be used in combination with a concrete type within the same crate
	`56`	+ = note: `Tait3` must be used in combination with a concrete type within the same crate
`57`	`57`
`58`	`58`	`error: unconstrained opaque type`
`59`	`59`	`--> $DIR/duplicate-bound-err.rs:28:14`
`60`	`60`	`\|`
`61`		`-LL \| type ETAI4 = impl Iterator<Item: Copy, Item: Send>;`
	`61`	`+LL \| type Tait4 = impl Iterator<Item: Copy, Item: Send>;`
`62`	`62`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^`
`63`	`63`	`\|`
`64`		- = note: `ETAI4` must be used in combination with a concrete type within the same crate
	`64`	+ = note: `Tait4` must be used in combination with a concrete type within the same crate
`65`	`65`
`66`	`66`	`error: unconstrained opaque type`
`67`	`67`	`--> $DIR/duplicate-bound-err.rs:30:14`
`68`	`68`	`\|`
`69`		`-LL \| type ETAI5 = impl Iterator<Item: Copy, Item: Copy>;`
	`69`	`+LL \| type Tait5 = impl Iterator<Item: Copy, Item: Copy>;`
`70`	`70`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^`
`71`	`71`	`\|`
`72`		- = note: `ETAI5` must be used in combination with a concrete type within the same crate
	`72`	+ = note: `Tait5` must be used in combination with a concrete type within the same crate
`73`	`73`
`74`	`74`	`error: unconstrained opaque type`
`75`	`75`	`--> $DIR/duplicate-bound-err.rs:32:14`
`76`	`76`	`\|`
`77`		`-LL \| type ETAI6 = impl Iterator<Item: 'static, Item: 'static>;`
	`77`	`+LL \| type Tait6 = impl Iterator<Item: 'static, Item: 'static>;`
`78`	`78`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^`
`79`	`79`	`\|`
`80`		- = note: `ETAI6` must be used in combination with a concrete type within the same crate
	`80`	+ = note: `Tait6` must be used in combination with a concrete type within the same crate
`81`	`81`
`82`	`82`	error[E0277]: `*const ()` cannot be sent between threads safely
`83`	`83`	`--> $DIR/duplicate-bound-err.rs:35:18`
Original file line number	Diff line number	Diff line change
`@@ -7,84 +7,84 @@`
`7`	`7`	`use std::iter;`
`8`	`8`	`use std::mem::ManuallyDrop;`
`9`	`9`
`10`		`-struct SI1<T: Iterator<Item: Copy, Item: Send>> {`
	`10`	`+struct Si1<T: Iterator<Item: Copy, Item: Send>> {`
`11`	`11`	`f: T,`
`12`	`12`	`}`
`13`		`-struct SI2<T: Iterator<Item: Copy, Item: Copy>> {`
	`13`	`+struct Si2<T: Iterator<Item: Copy, Item: Copy>> {`
`14`	`14`	`f: T,`
`15`	`15`	`}`
`16`		`-struct SI3<T: Iterator<Item: 'static, Item: 'static>> {`
	`16`	`+struct Si3<T: Iterator<Item: 'static, Item: 'static>> {`
`17`	`17`	`f: T,`
`18`	`18`	`}`
`19`		`-struct SW1<T>`
	`19`	`+struct Sw1<T>`
`20`	`20`	`where`
`21`	`21`	`T: Iterator<Item: Copy, Item: Send>,`
`22`	`22`	`{`
`23`	`23`	`f: T,`
`24`	`24`	`}`
`25`		`-struct SW2<T>`
	`25`	`+struct Sw2<T>`
`26`	`26`	`where`
`27`	`27`	`T: Iterator<Item: Copy, Item: Copy>,`
`28`	`28`	`{`
`29`	`29`	`f: T,`
`30`	`30`	`}`
`31`		`-struct SW3<T>`
	`31`	`+struct Sw3<T>`
`32`	`32`	`where`
`33`	`33`	`T: Iterator<Item: 'static, Item: 'static>,`
`34`	`34`	`{`
`35`	`35`	`f: T,`
`36`	`36`	`}`
`37`	`37`
`38`		`-enum EI1<T: Iterator<Item: Copy, Item: Send>> {`
	`38`	`+enum Ei1<T: Iterator<Item: Copy, Item: Send>> {`
`39`	`39`	`V(T),`
`40`	`40`	`}`
`41`		`-enum EI2<T: Iterator<Item: Copy, Item: Copy>> {`
	`41`	`+enum Ei2<T: Iterator<Item: Copy, Item: Copy>> {`
`42`	`42`	`V(T),`
`43`	`43`	`}`
`44`		`-enum EI3<T: Iterator<Item: 'static, Item: 'static>> {`
	`44`	`+enum Ei3<T: Iterator<Item: 'static, Item: 'static>> {`
`45`	`45`	`V(T),`
`46`	`46`	`}`
`47`		`-enum EW1<T>`
	`47`	`+enum Ew1<T>`
`48`	`48`	`where`
`49`	`49`	`T: Iterator<Item: Copy, Item: Send>,`
`50`	`50`	`{`
`51`	`51`	`V(T),`
`52`	`52`	`}`
`53`		`-enum EW2<T>`
	`53`	`+enum Ew2<T>`
`54`	`54`	`where`
`55`	`55`	`T: Iterator<Item: Copy, Item: Copy>,`
`56`	`56`	`{`
`57`	`57`	`V(T),`
`58`	`58`	`}`
`59`		`-enum EW3<T>`
	`59`	`+enum Ew3<T>`
`60`	`60`	`where`
`61`	`61`	`T: Iterator<Item: 'static, Item: 'static>,`
`62`	`62`	`{`
`63`	`63`	`V(T),`
`64`	`64`	`}`
`65`	`65`
`66`		`-union UI1<T: Iterator<Item: Copy, Item: Send>> {`
	`66`	`+union Ui1<T: Iterator<Item: Copy, Item: Send>> {`
`67`	`67`	`f: ManuallyDrop<T>,`
`68`	`68`	`}`
`69`		`-union UI2<T: Iterator<Item: Copy, Item: Copy>> {`
	`69`	`+union Ui2<T: Iterator<Item: Copy, Item: Copy>> {`
`70`	`70`	`f: ManuallyDrop<T>,`
`71`	`71`	`}`
`72`		`-union UI3<T: Iterator<Item: 'static, Item: 'static>> {`
	`72`	`+union Ui3<T: Iterator<Item: 'static, Item: 'static>> {`
`73`	`73`	`f: ManuallyDrop<T>,`
`74`	`74`	`}`
`75`		`-union UW1<T>`
	`75`	`+union Uw1<T>`
`76`	`76`	`where`
`77`	`77`	`T: Iterator<Item: Copy, Item: Send>,`
`78`	`78`	`{`
`79`	`79`	`f: ManuallyDrop<T>,`
`80`	`80`	`}`
`81`		`-union UW2<T>`
	`81`	`+union Uw2<T>`
`82`	`82`	`where`
`83`	`83`	`T: Iterator<Item: Copy, Item: Copy>,`
`84`	`84`	`{`
`85`	`85`	`f: ManuallyDrop<T>,`
`86`	`86`	`}`
`87`		`-union UW3<T>`
	`87`	`+union Uw3<T>`
`88`	`88`	`where`
`89`	`89`	`T: Iterator<Item: 'static, Item: 'static>,`
`90`	`90`	`{`
`@@ -110,78 +110,78 @@ where`
`110`	`110`	`{`
`111`	`111`	`}`
`112`	`112`
`113`		`-fn frpit1() -> impl Iterator<Item: Copy, Item: Send> {`
	`113`	`+fn rpit1() -> impl Iterator<Item: Copy, Item: Send> {`
`114`	`114`	`iter::empty::<u32>()`
`115`	`115`	`}`
`116`		`-fn frpit2() -> impl Iterator<Item: Copy, Item: Copy> {`
	`116`	`+fn rpit2() -> impl Iterator<Item: Copy, Item: Copy> {`
`117`	`117`	`iter::empty::<u32>()`
`118`	`118`	`}`
`119`		`-fn frpit3() -> impl Iterator<Item: 'static, Item: 'static> {`
	`119`	`+fn rpit3() -> impl Iterator<Item: 'static, Item: 'static> {`
`120`	`120`	`iter::empty::<u32>()`
`121`	`121`	`}`
`122`		`-fn fapit1(_: impl Iterator<Item: Copy, Item: Send>) {}`
`123`		`-fn fapit2(_: impl Iterator<Item: Copy, Item: Copy>) {}`
`124`		`-fn fapit3(_: impl Iterator<Item: 'static, Item: 'static>) {}`
	`122`	`+fn apit1(_: impl Iterator<Item: Copy, Item: Send>) {}`
	`123`	`+fn apit2(_: impl Iterator<Item: Copy, Item: Copy>) {}`
	`124`	`+fn apit3(_: impl Iterator<Item: 'static, Item: 'static>) {}`
`125`	`125`
`126`		`-type TAI1<T: Iterator<Item: Copy, Item: Send>> = T;`
`127`		`-type TAI2<T: Iterator<Item: Copy, Item: Copy>> = T;`
`128`		`-type TAI3<T: Iterator<Item: 'static, Item: 'static>> = T;`
`129`		`-type TAW1<T>`
	`126`	`+type Tait1<T: Iterator<Item: Copy, Item: Send>> = T;`
	`127`	`+type Tait2<T: Iterator<Item: Copy, Item: Copy>> = T;`
	`128`	`+type Tait3<T: Iterator<Item: 'static, Item: 'static>> = T;`
	`129`	`+type Taw1<T>`
`130`	`130`	`where`
`131`	`131`	`T: Iterator<Item: Copy, Item: Send>,`
`132`	`132`	`= T;`
`133`		`-type TAW2<T>`
	`133`	`+type Taw2<T>`
`134`	`134`	`where`
`135`	`135`	`T: Iterator<Item: Copy, Item: Copy>,`
`136`	`136`	`= T;`
`137`		`-type TAW3<T>`
	`137`	`+type Taw3<T>`
`138`	`138`	`where`
`139`	`139`	`T: Iterator<Item: 'static, Item: 'static>,`
`140`	`140`	`= T;`
`141`	`141`
`142`		`-trait TRI1<T: Iterator<Item: Copy, Item: Send>> {}`
`143`		`-trait TRI2<T: Iterator<Item: Copy, Item: Copy>> {}`
`144`		`-trait TRI3<T: Iterator<Item: 'static, Item: 'static>> {}`
`145`		`-trait TRS1: Iterator<Item: Copy, Item: Send> {}`
`146`		`-trait TRS2: Iterator<Item: Copy, Item: Copy> {}`
`147`		`-trait TRS3: Iterator<Item: 'static, Item: 'static> {}`
`148`		`-trait TRW1<T>`
	`142`	`+trait Tri1<T: Iterator<Item: Copy, Item: Send>> {}`
	`143`	`+trait Tri2<T: Iterator<Item: Copy, Item: Copy>> {}`
	`144`	`+trait Tri3<T: Iterator<Item: 'static, Item: 'static>> {}`
	`145`	`+trait Trs1: Iterator<Item: Copy, Item: Send> {}`
	`146`	`+trait Trs2: Iterator<Item: Copy, Item: Copy> {}`
	`147`	`+trait Trs3: Iterator<Item: 'static, Item: 'static> {}`
	`148`	`+trait Trw1<T>`
`149`	`149`	`where`
`150`	`150`	`T: Iterator<Item: Copy, Item: Send>,`
`151`	`151`	`{`
`152`	`152`	`}`
`153`		`-trait TRW2<T>`
	`153`	`+trait Trw2<T>`
`154`	`154`	`where`
`155`	`155`	`T: Iterator<Item: Copy, Item: Copy>,`
`156`	`156`	`{`
`157`	`157`	`}`
`158`		`-trait TRW3<T>`
	`158`	`+trait Trw3<T>`
`159`	`159`	`where`
`160`	`160`	`T: Iterator<Item: 'static, Item: 'static>,`
`161`	`161`	`{`
`162`	`162`	`}`
`163`		`-trait TRSW1`
	`163`	`+trait Trsw1`
`164`	`164`	`where`
`165`	`165`	`Self: Iterator<Item: Copy, Item: Send>,`
`166`	`166`	`{`
`167`	`167`	`}`
`168`		`-trait TRSW2`
	`168`	`+trait Trsw2`
`169`	`169`	`where`
`170`	`170`	`Self: Iterator<Item: Copy, Item: Copy>,`
`171`	`171`	`{`
`172`	`172`	`}`
`173`		`-trait TRSW3`
	`173`	`+trait Trsw3`
`174`	`174`	`where`
`175`	`175`	`Self: Iterator<Item: 'static, Item: 'static>,`
`176`	`176`	`{`
`177`	`177`	`}`
`178`		`-trait TRA1 {`
	`178`	`+trait Tra1 {`
`179`	`179`	`type A: Iterator<Item: Copy, Item: Send>;`
`180`	`180`	`}`
`181`		`-trait TRA2 {`
	`181`	`+trait Tra2 {`
`182`	`182`	`type A: Iterator<Item: Copy, Item: Copy>;`
`183`	`183`	`}`
`184`		`-trait TRA3 {`
	`184`	`+trait Tra3 {`
`185`	`185`	`type A: Iterator<Item: 'static, Item: 'static>;`
`186`	`186`	`}`
`187`	`187`