rust-lang
diff --git a/‎tests/test/arrays.rs
Lines changed: 8 additions & 8 deletions b/‎tests/test/arrays.rs
Lines changed: 8 additions & 8 deletions
diff --git a/‎tests/test/auto_traits.rs
Lines changed: 40 additions & 40 deletions b/‎tests/test/auto_traits.rs
Lines changed: 40 additions & 40 deletions
@@ -13,7 +13,7 @@ fn arrays_are_sized() {
                 [u32; N]: Sized
             }
         } yields {
-            "Unique"
+            expect![["Unique"]]
         }
 
     }
@@ -35,7 +35,7 @@ fn arrays_are_copy_if_element_copy() {
                 [Foo; N]: Copy
             }
         } yields {
-            "Unique"
+            expect![["Unique"]]
         }
     }
 }
@@ -55,7 +55,7 @@ fn arrays_are_not_copy_if_element_not_copy() {
                 [Foo; N]: Copy
             }
         } yields {
-            "No possible solution"
+            expect![["No possible solution"]]
         }
     }
 }
@@ -76,7 +76,7 @@ fn arrays_are_clone_if_element_clone() {
                 [Foo; N]: Clone
             }
         } yields {
-            "Unique"
+            expect![["Unique"]]
         }
     }
 }
@@ -96,7 +96,7 @@ fn arrays_are_not_clone_if_element_not_clone() {
                 [Foo; N]: Clone
             }
         } yields {
-            "No possible solution"
+            expect![["No possible solution"]]
         }
     }
 }
@@ -116,23 +116,23 @@ fn arrays_are_well_formed_if_elem_sized() {
                 }
             }
         } yields {
-            "Unique"
+            expect![["Unique"]]
         }
 
         goal {
             forall<const N, T> {
                 WellFormed([T; N])
             }
         } yields {
-            "No possible solution"
+            expect![["No possible solution"]]
         }
 
         goal {
             exists<const N, T> {
                 WellFormed([T; N])
             }
         } yields {
-            "Ambiguous; no inference guidance"
+            expect![["Ambiguous; no inference guidance"]]
         }
     }
 }
@@ -25,7 +25,7 @@ fn auto_semantics() {
                 List<T>: Send
             }
         } yields {
-            "No possible solution"
+            expect![["No possible solution"]]
         }
         goal {
             forall<T> {
@@ -34,21 +34,21 @@ fn auto_semantics() {
                 }
             }
         } yields {
-            "Unique"
+            expect![["Unique"]]
         }
 
         goal {
             List<TypeA>: Send
         } yields {
-            "Unique"
+            expect![["Unique"]]
         }
 
         goal {
             exists<T> {
                 T: Send
             }
         } yields {
-            "Ambiguous"
+            expect![["Ambiguous"]]
         }
     }
 }
@@ -71,7 +71,7 @@ fn auto_trait_without_impls() {
         goal {
             TypeA: Send
         } yields {
-            "Unique"
+            expect![["Unique"]]
         }
 
         // No fields so `Useless<T>` is `Send`.
@@ -80,7 +80,7 @@ fn auto_trait_without_impls() {
                 Useless<T>: Send
             }
         } yields {
-            "Unique"
+            expect![["Unique"]]
         }
 
         goal {
@@ -90,7 +90,7 @@ fn auto_trait_without_impls() {
                 }
             }
         } yields {
-            "Unique"
+            expect![["Unique"]]
         }
     }
 }
@@ -112,33 +112,33 @@ fn auto_trait_with_impls() {
         goal {
             TypeA: Send
         } yields {
-            "No possible solution"
+            expect![["No possible solution"]]
         }
 
         goal {
             TypeB: Send
         } yields {
-            "Unique"
+            expect![["Unique"]]
         }
 
         goal {
             Vec<TypeA>: Send
         } yields {
-            "No possible solution"
+            expect![["No possible solution"]]
         }
 
         goal {
             Vec<TypeB>: Send
         } yields {
-            "Unique"
+            expect![["Unique"]]
         }
 
         goal {
             forall<T> {
                 Vec<T>: Send
             }
         } yields {
-            "No possible solution"
+            expect![["No possible solution"]]
         }
     }
 }
@@ -158,7 +158,7 @@ fn auto_traits_flounder() {
         goal {
             exists<A> { A: Send }
         } yields_first[SolverChoice::slg(3, None)] {
-            "Floundered"
+            expect![["Floundered"]]
         }
     }
 }
@@ -201,19 +201,19 @@ fn enum_auto_trait() {
         goal {
             A: Send
         } yields {
-            "Unique; substitution [], lifetime constraints []"
+            expect![["Unique; substitution [], lifetime constraints []"]]
         }
 
         goal {
             B: Send
         } yields {
-            "No possible solution"
+            expect![["No possible solution"]]
         }
 
         goal {
             C: Send
         } yields {
-            "No possible solution"
+            expect![["No possible solution"]]
         }
     }
 }
@@ -239,61 +239,61 @@ fn builtin_auto_trait() {
 
         // The following types only contain AutoTrait-types, and thus implement AutoTrait themselves.
         goal { (i32, f32): AutoTrait }
-        yields { "Unique; substitution [], lifetime constraints []" }
+        yields { expect![["Unique; substitution [], lifetime constraints []"]] }
 
         goal { [(); 1]: AutoTrait }
-        yields { "Unique; substitution [], lifetime constraints []" }
+        yields { expect![["Unique; substitution [], lifetime constraints []"]] }
 
         goal { [()]: AutoTrait }
-        yields { "Unique; substitution [], lifetime constraints []" }
+        yields { expect![["Unique; substitution [], lifetime constraints []"]] }
 
         goal { u32: AutoTrait }
-        yields { "Unique; substitution [], lifetime constraints []" }
+        yields { expect![["Unique; substitution [], lifetime constraints []"]] }
 
         goal { *const (): AutoTrait }
-        yields { "Unique; substitution [], lifetime constraints []" }
+        yields { expect![["Unique; substitution [], lifetime constraints []"]] }
 
         goal { *mut (): AutoTrait }
-        yields { "Unique; substitution [], lifetime constraints []" }
+        yields { expect![["Unique; substitution [], lifetime constraints []"]] }
 
         goal { forall<'a> { &'a (): AutoTrait } }
-        yields { "Unique; substitution [], lifetime constraints []" }
+        yields { expect![["Unique; substitution [], lifetime constraints []"]] }
 
         goal { forall<'a> { &'a mut (): AutoTrait } }
-        yields { "Unique; substitution [], lifetime constraints []" }
+        yields { expect![["Unique; substitution [], lifetime constraints []"]] }
 
         goal { str: AutoTrait }
-        yields { "Unique; substitution [], lifetime constraints []" }
+        yields { expect![["Unique; substitution [], lifetime constraints []"]] }
 
         goal { !: AutoTrait }
-        yields { "Unique; substitution [], lifetime constraints []" }
+        yields { expect![["Unique; substitution [], lifetime constraints []"]] }
 
         goal { Enum: AutoTrait }
-        yields { "Unique; substitution [], lifetime constraints []" }
+        yields { expect![["Unique; substitution [], lifetime constraints []"]] }
 
         goal { func: AutoTrait }
-        yields { "Unique; substitution [], lifetime constraints []" }
+        yields { expect![["Unique; substitution [], lifetime constraints []"]] }
 
         goal { good_closure: AutoTrait }
-        yields { "Unique; substitution [], lifetime constraints []" }
+        yields { expect![["Unique; substitution [], lifetime constraints []"]] }
 
         goal { fn(Marker) -> Marker: AutoTrait }
-        yields { "Unique; substitution [], lifetime constraints []" }
+        yields { expect![["Unique; substitution [], lifetime constraints []"]] }
 
 
         // foreign types do not implement AutoTraits automatically
         goal { Ext: AutoTrait }
-        yields { "No possible solution" }
+        yields { expect![["No possible solution"]] }
 
         // The following types do contain non-AutoTrait types, and thus do not implement AutoTrait.
         goal { bad_closure: AutoTrait }
-        yields { "No possible solution" }
+        yields { expect![["No possible solution"]] }
 
         goal { ExtEnum: AutoTrait }
-        yields { "No possible solution" }
+        yields { expect![["No possible solution"]] }
 
         goal { (Struct, Marker): AutoTrait }
-        yields { "No possible solution" }
+        yields { expect![["No possible solution"]] }
     }
 }
 
@@ -317,35 +317,35 @@ fn adt_auto_trait() {
             Yes: AutoTrait
         }
         yields {
-            "Unique; substitution [], lifetime constraints []"
+            expect![["Unique; substitution [], lifetime constraints []"]]
         }
 
         goal {
             No: AutoTrait
         }
         yields {
-            "No possible solution"
+            expect![["No possible solution"]]
         }
 
         goal {
             X: AutoTrait
         }
         yields {
-            "Unique; substitution [], lifetime constraints []"
+            expect![["Unique; substitution [], lifetime constraints []"]]
         }
 
         goal {
             WrapperNo<Yes>: AutoTrait
         }
         yields {
-            "No possible solution"
+            expect![["No possible solution"]]
         }
 
         goal {
             WrapperYes<No>: AutoTrait
         }
         yields {
-            "No possible solution"
+            expect![["No possible solution"]]
         }
     }
 }
@@ -364,7 +364,7 @@ fn phantom_auto_trait() {
             PhantomData<Bad>: AutoTrait
         }
         yields {
-            "No possible solution"
+            expect![["No possible solution"]]
         }
     }
 }
Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@ fn arrays_are_sized() {`
`13`	`13`	`[u32; N]: Sized`
`14`	`14`	`}`
`15`	`15`	`} yields {`
`16`		`- "Unique"`
	`16`	`+ expect![["Unique"]]`
`17`	`17`	`}`
`18`	`18`
`19`	`19`	`}`
`@@ -35,7 +35,7 @@ fn arrays_are_copy_if_element_copy() {`
`35`	`35`	`[Foo; N]: Copy`
`36`	`36`	`}`
`37`	`37`	`} yields {`
`38`		`- "Unique"`
	`38`	`+ expect![["Unique"]]`
`39`	`39`	`}`
`40`	`40`	`}`
`41`	`41`	`}`
`@@ -55,7 +55,7 @@ fn arrays_are_not_copy_if_element_not_copy() {`
`55`	`55`	`[Foo; N]: Copy`
`56`	`56`	`}`
`57`	`57`	`} yields {`
`58`		`- "No possible solution"`
	`58`	`+ expect![["No possible solution"]]`
`59`	`59`	`}`
`60`	`60`	`}`
`61`	`61`	`}`
`@@ -76,7 +76,7 @@ fn arrays_are_clone_if_element_clone() {`
`76`	`76`	`[Foo; N]: Clone`
`77`	`77`	`}`
`78`	`78`	`} yields {`
`79`		`- "Unique"`
	`79`	`+ expect![["Unique"]]`
`80`	`80`	`}`
`81`	`81`	`}`
`82`	`82`	`}`
`@@ -96,7 +96,7 @@ fn arrays_are_not_clone_if_element_not_clone() {`
`96`	`96`	`[Foo; N]: Clone`
`97`	`97`	`}`
`98`	`98`	`} yields {`
`99`		`- "No possible solution"`
	`99`	`+ expect![["No possible solution"]]`
`100`	`100`	`}`
`101`	`101`	`}`
`102`	`102`	`}`
`@@ -116,23 +116,23 @@ fn arrays_are_well_formed_if_elem_sized() {`
`116`	`116`	`}`
`117`	`117`	`}`
`118`	`118`	`} yields {`
`119`		`- "Unique"`
	`119`	`+ expect![["Unique"]]`
`120`	`120`	`}`
`121`	`121`
`122`	`122`	`goal {`
`123`	`123`	`forall<const N, T> {`
`124`	`124`	`WellFormed([T; N])`
`125`	`125`	`}`
`126`	`126`	`} yields {`
`127`		`- "No possible solution"`
	`127`	`+ expect![["No possible solution"]]`
`128`	`128`	`}`
`129`	`129`
`130`	`130`	`goal {`
`131`	`131`	`exists<const N, T> {`
`132`	`132`	`WellFormed([T; N])`
`133`	`133`	`}`
`134`	`134`	`} yields {`
`135`		`- "Ambiguous; no inference guidance"`
	`135`	`+ expect![["Ambiguous; no inference guidance"]]`
`136`	`136`	`}`
`137`	`137`	`}`
`138`	`138`	`}`
Original file line number	Diff line number	Diff line change
`@@ -25,7 +25,7 @@ fn auto_semantics() {`
`25`	`25`	`List<T>: Send`
`26`	`26`	`}`
`27`	`27`	`} yields {`
`28`		`- "No possible solution"`
	`28`	`+ expect![["No possible solution"]]`
`29`	`29`	`}`
`30`	`30`	`goal {`
`31`	`31`	`forall<T> {`
`@@ -34,21 +34,21 @@ fn auto_semantics() {`
`34`	`34`	`}`
`35`	`35`	`}`
`36`	`36`	`} yields {`
`37`		`- "Unique"`
	`37`	`+ expect![["Unique"]]`
`38`	`38`	`}`
`39`	`39`
`40`	`40`	`goal {`
`41`	`41`	`List<TypeA>: Send`
`42`	`42`	`} yields {`
`43`		`- "Unique"`
	`43`	`+ expect![["Unique"]]`
`44`	`44`	`}`
`45`	`45`
`46`	`46`	`goal {`
`47`	`47`	`exists<T> {`
`48`	`48`	`T: Send`
`49`	`49`	`}`
`50`	`50`	`} yields {`
`51`		`- "Ambiguous"`
	`51`	`+ expect![["Ambiguous"]]`
`52`	`52`	`}`
`53`	`53`	`}`
`54`	`54`	`}`
`@@ -71,7 +71,7 @@ fn auto_trait_without_impls() {`
`71`	`71`	`goal {`
`72`	`72`	`TypeA: Send`
`73`	`73`	`} yields {`
`74`		`- "Unique"`
	`74`	`+ expect![["Unique"]]`
`75`	`75`	`}`
`76`	`76`
`77`	`77`	// No fields so `Useless<T>` is `Send`.
`@@ -80,7 +80,7 @@ fn auto_trait_without_impls() {`
`80`	`80`	`Useless<T>: Send`
`81`	`81`	`}`
`82`	`82`	`} yields {`
`83`		`- "Unique"`
	`83`	`+ expect![["Unique"]]`
`84`	`84`	`}`
`85`	`85`
`86`	`86`	`goal {`
`@@ -90,7 +90,7 @@ fn auto_trait_without_impls() {`
`90`	`90`	`}`
`91`	`91`	`}`
`92`	`92`	`} yields {`
`93`		`- "Unique"`
	`93`	`+ expect![["Unique"]]`
`94`	`94`	`}`
`95`	`95`	`}`
`96`	`96`	`}`
`@@ -112,33 +112,33 @@ fn auto_trait_with_impls() {`
`112`	`112`	`goal {`
`113`	`113`	`TypeA: Send`
`114`	`114`	`} yields {`
`115`		`- "No possible solution"`
	`115`	`+ expect![["No possible solution"]]`
`116`	`116`	`}`
`117`	`117`
`118`	`118`	`goal {`
`119`	`119`	`TypeB: Send`
`120`	`120`	`} yields {`
`121`		`- "Unique"`
	`121`	`+ expect![["Unique"]]`
`122`	`122`	`}`
`123`	`123`
`124`	`124`	`goal {`
`125`	`125`	`Vec<TypeA>: Send`
`126`	`126`	`} yields {`
`127`		`- "No possible solution"`
	`127`	`+ expect![["No possible solution"]]`
`128`	`128`	`}`
`129`	`129`
`130`	`130`	`goal {`
`131`	`131`	`Vec<TypeB>: Send`
`132`	`132`	`} yields {`
`133`		`- "Unique"`
	`133`	`+ expect![["Unique"]]`
`134`	`134`	`}`
`135`	`135`
`136`	`136`	`goal {`
`137`	`137`	`forall<T> {`
`138`	`138`	`Vec<T>: Send`
`139`	`139`	`}`
`140`	`140`	`} yields {`
`141`		`- "No possible solution"`
	`141`	`+ expect![["No possible solution"]]`
`142`	`142`	`}`
`143`	`143`	`}`
`144`	`144`	`}`
`@@ -158,7 +158,7 @@ fn auto_traits_flounder() {`
`158`	`158`	`goal {`
`159`	`159`	`exists<A> { A: Send }`
`160`	`160`	`} yields_first[SolverChoice::slg(3, None)] {`
`161`		`- "Floundered"`
	`161`	`+ expect![["Floundered"]]`
`162`	`162`	`}`
`163`	`163`	`}`
`164`	`164`	`}`
`@@ -201,19 +201,19 @@ fn enum_auto_trait() {`
`201`	`201`	`goal {`
`202`	`202`	`A: Send`
`203`	`203`	`} yields {`
`204`		`- "Unique; substitution [], lifetime constraints []"`
	`204`	`+ expect![["Unique; substitution [], lifetime constraints []"]]`
`205`	`205`	`}`
`206`	`206`
`207`	`207`	`goal {`
`208`	`208`	`B: Send`
`209`	`209`	`} yields {`
`210`		`- "No possible solution"`
	`210`	`+ expect![["No possible solution"]]`
`211`	`211`	`}`
`212`	`212`
`213`	`213`	`goal {`
`214`	`214`	`C: Send`
`215`	`215`	`} yields {`
`216`		`- "No possible solution"`
	`216`	`+ expect![["No possible solution"]]`
`217`	`217`	`}`
`218`	`218`	`}`
`219`	`219`	`}`
`@@ -239,61 +239,61 @@ fn builtin_auto_trait() {`
`239`	`239`
`240`	`240`	`// The following types only contain AutoTrait-types, and thus implement AutoTrait themselves.`
`241`	`241`	`goal { (i32, f32): AutoTrait }`
`242`		`- yields { "Unique; substitution [], lifetime constraints []" }`
	`242`	`+ yields { expect![["Unique; substitution [], lifetime constraints []"]] }`
`243`	`243`
`244`	`244`	`goal { [(); 1]: AutoTrait }`
`245`		`- yields { "Unique; substitution [], lifetime constraints []" }`
	`245`	`+ yields { expect![["Unique; substitution [], lifetime constraints []"]] }`
`246`	`246`
`247`	`247`	`goal { [()]: AutoTrait }`
`248`		`- yields { "Unique; substitution [], lifetime constraints []" }`
	`248`	`+ yields { expect![["Unique; substitution [], lifetime constraints []"]] }`
`249`	`249`
`250`	`250`	`goal { u32: AutoTrait }`
`251`		`- yields { "Unique; substitution [], lifetime constraints []" }`
	`251`	`+ yields { expect![["Unique; substitution [], lifetime constraints []"]] }`
`252`	`252`
`253`	`253`	`goal { *const (): AutoTrait }`
`254`		`- yields { "Unique; substitution [], lifetime constraints []" }`
	`254`	`+ yields { expect![["Unique; substitution [], lifetime constraints []"]] }`
`255`	`255`
`256`	`256`	`goal { *mut (): AutoTrait }`
`257`		`- yields { "Unique; substitution [], lifetime constraints []" }`
	`257`	`+ yields { expect![["Unique; substitution [], lifetime constraints []"]] }`
`258`	`258`
`259`	`259`	`goal { forall<'a> { &'a (): AutoTrait } }`
`260`		`- yields { "Unique; substitution [], lifetime constraints []" }`
	`260`	`+ yields { expect![["Unique; substitution [], lifetime constraints []"]] }`
`261`	`261`
`262`	`262`	`goal { forall<'a> { &'a mut (): AutoTrait } }`
`263`		`- yields { "Unique; substitution [], lifetime constraints []" }`
	`263`	`+ yields { expect![["Unique; substitution [], lifetime constraints []"]] }`
`264`	`264`
`265`	`265`	`goal { str: AutoTrait }`
`266`		`- yields { "Unique; substitution [], lifetime constraints []" }`
	`266`	`+ yields { expect![["Unique; substitution [], lifetime constraints []"]] }`
`267`	`267`
`268`	`268`	`goal { !: AutoTrait }`
`269`		`- yields { "Unique; substitution [], lifetime constraints []" }`
	`269`	`+ yields { expect![["Unique; substitution [], lifetime constraints []"]] }`
`270`	`270`
`271`	`271`	`goal { Enum: AutoTrait }`
`272`		`- yields { "Unique; substitution [], lifetime constraints []" }`
	`272`	`+ yields { expect![["Unique; substitution [], lifetime constraints []"]] }`
`273`	`273`
`274`	`274`	`goal { func: AutoTrait }`
`275`		`- yields { "Unique; substitution [], lifetime constraints []" }`
	`275`	`+ yields { expect![["Unique; substitution [], lifetime constraints []"]] }`
`276`	`276`
`277`	`277`	`goal { good_closure: AutoTrait }`
`278`		`- yields { "Unique; substitution [], lifetime constraints []" }`
	`278`	`+ yields { expect![["Unique; substitution [], lifetime constraints []"]] }`
`279`	`279`
`280`	`280`	`goal { fn(Marker) -> Marker: AutoTrait }`
`281`		`- yields { "Unique; substitution [], lifetime constraints []" }`
	`281`	`+ yields { expect![["Unique; substitution [], lifetime constraints []"]] }`
`282`	`282`
`283`	`283`
`284`	`284`	`// foreign types do not implement AutoTraits automatically`
`285`	`285`	`goal { Ext: AutoTrait }`
`286`		`- yields { "No possible solution" }`
	`286`	`+ yields { expect![["No possible solution"]] }`
`287`	`287`
`288`	`288`	`// The following types do contain non-AutoTrait types, and thus do not implement AutoTrait.`
`289`	`289`	`goal { bad_closure: AutoTrait }`
`290`		`- yields { "No possible solution" }`
	`290`	`+ yields { expect![["No possible solution"]] }`
`291`	`291`
`292`	`292`	`goal { ExtEnum: AutoTrait }`
`293`		`- yields { "No possible solution" }`
	`293`	`+ yields { expect![["No possible solution"]] }`
`294`	`294`
`295`	`295`	`goal { (Struct, Marker): AutoTrait }`
`296`		`- yields { "No possible solution" }`
	`296`	`+ yields { expect![["No possible solution"]] }`
`297`	`297`	`}`
`298`	`298`	`}`
`299`	`299`
`@@ -317,35 +317,35 @@ fn adt_auto_trait() {`
`317`	`317`	`Yes: AutoTrait`
`318`	`318`	`}`
`319`	`319`	`yields {`
`320`		`- "Unique; substitution [], lifetime constraints []"`
	`320`	`+ expect![["Unique; substitution [], lifetime constraints []"]]`
`321`	`321`	`}`
`322`	`322`
`323`	`323`	`goal {`
`324`	`324`	`No: AutoTrait`
`325`	`325`	`}`
`326`	`326`	`yields {`
`327`		`- "No possible solution"`
	`327`	`+ expect![["No possible solution"]]`
`328`	`328`	`}`
`329`	`329`
`330`	`330`	`goal {`
`331`	`331`	`X: AutoTrait`
`332`	`332`	`}`
`333`	`333`	`yields {`
`334`		`- "Unique; substitution [], lifetime constraints []"`
	`334`	`+ expect![["Unique; substitution [], lifetime constraints []"]]`
`335`	`335`	`}`
`336`	`336`
`337`	`337`	`goal {`
`338`	`338`	`WrapperNo<Yes>: AutoTrait`
`339`	`339`	`}`
`340`	`340`	`yields {`
`341`		`- "No possible solution"`
	`341`	`+ expect![["No possible solution"]]`
`342`	`342`	`}`
`343`	`343`
`344`	`344`	`goal {`
`345`	`345`	`WrapperYes<No>: AutoTrait`
`346`	`346`	`}`
`347`	`347`	`yields {`
`348`		`- "No possible solution"`
	`348`	`+ expect![["No possible solution"]]`
`349`	`349`	`}`
`350`	`350`	`}`
`351`	`351`	`}`
`@@ -364,7 +364,7 @@ fn phantom_auto_trait() {`
`364`	`364`	`PhantomData<Bad>: AutoTrait`
`365`	`365`	`}`
`366`	`366`	`yields {`
`367`		`- "No possible solution"`
	`367`	`+ expect![["No possible solution"]]`
`368`	`368`	`}`
`369`	`369`	`}`
`370`	`370`	`}`