update tests

nikomatsakis · nikomatsakis · commit 8440ed8b161c · 2018-09-14T15:45:51.000-04:00
diff --git a/src/test.rs b/src/test.rs
@@ -478,7 +478,7 @@ fn normalize_basic() {
                 }
             }
         } yields {
-            "Unique; substitution [?0 := !1], lifetime constraints []"
+            "Unique; substitution [?0 := !1_0], lifetime constraints []"
         }
 
         goal {
@@ -508,7 +508,7 @@ fn normalize_basic() {
                 }
             }
         } yields {
-            "Unique; substitution [?0 := (Iterator::Item)<!1>]"
+            "Unique; substitution [?0 := (Iterator::Item)<!1_0>]"
         }
 
         goal {
@@ -520,7 +520,7 @@ fn normalize_basic() {
                 }
             }
         } yields {
-            "Unique; substitution [?0 := (Iterator::Item)<!1>]"
+            "Unique; substitution [?0 := (Iterator::Item)<!1_0>]"
         }
 
         goal {
@@ -583,7 +583,7 @@ fn normalize_gat1() {
                 }
             }
         } yields {
-            "Unique; substitution [?0 := Iter<'!2, !1>], lifetime constraints []"
+            "Unique; substitution [?0 := Iter<'!2_0, !1_0>], lifetime constraints []"
         }
     }
 }
@@ -608,7 +608,7 @@ fn normalize_gat2() {
                 }
             }
         } yields {
-            "Unique; substitution [?0 := Span<'!1, !2>], lifetime constraints []"
+            "Unique; substitution [?0 := Span<'!1_0, !1_1>], lifetime constraints []"
         }
 
         goal {
@@ -666,7 +666,7 @@ fn normalize_gat_with_where_clause() {
                 }
             }
         } yields {
-            "Unique; substitution [?0 := Value<!1>]"
+            "Unique; substitution [?0 := Value<!1_0>]"
         }
     }
 }
@@ -705,7 +705,7 @@ fn normalize_gat_with_where_clause2() {
                 }
             }
         } yields {
-            "Unique; substitution [?0 := !2]"
+            "Unique; substitution [?0 := !1_1]"
         }
     }
 }
@@ -924,7 +924,7 @@ fn region_equality() {
         } yields {
             "Unique; substitution [],
                      lifetime constraints \
-                     [InEnvironment { environment: Env([]), goal: '!2 == '!1 }]
+                     [InEnvironment { environment: Env([]), goal: '!1_1 == '!1_0 }]
                      "
         }
 
@@ -935,7 +935,7 @@ fn region_equality() {
                 }
             }
         } yields {
-            "Unique; substitution [?0 := '!1], lifetime constraints []"
+            "Unique; substitution [?0 := '!1_0], lifetime constraints []"
         }
     }
 }
@@ -968,12 +968,12 @@ fn forall_equality() {
             // this is because the region constraints are unsolvable.
             //
             // Note that `?0` (in universe 2) must be equal to both
-            // `!1` and `!2`, which of course it cannot be.
+            // `!1_0` and `!1_1`, which of course it cannot be.
             for<'a, 'b> Ref<'a, Ref<'b, Ref<'a, Unit>>>: Eq<
                 for<'c, 'd> Ref<'c, Ref<'d, Ref<'d, Unit>>>>
         } yields {
             "Unique; substitution [], lifetime constraints [
-                 InEnvironment { environment: Env([]), goal: '!2 == '!1 }
+                 InEnvironment { environment: Env([]), goal: '!1_1 == '!1_0 }
              ]"
         }
     }
@@ -1187,7 +1187,7 @@ fn normalize_under_binder() {
                 }
             }
         } yields {
-            "Unique; substitution [?0 := Ref<'!1, I32>], lifetime constraints []"
+            "Unique; substitution [?0 := Ref<'!1_0, I32>], lifetime constraints []"
         }
 
         goal {
@@ -1199,7 +1199,7 @@ fn normalize_under_binder() {
         } yields {
             "Unique; for<?U0> { \
              substitution [?0 := Ref<'?0, I32>], \
-             lifetime constraints [InEnvironment { environment: Env([]), goal: '?0 == '!1 }] \
+             lifetime constraints [InEnvironment { environment: Env([]), goal: '?0 == '!1_0 }] \
              }"
         }
     }
@@ -1212,7 +1212,7 @@ fn unify_quantified_lifetimes() {
         }
 
         // Check that `'a` (here, `'?0`) is not unified
-        // with `'!1`, because they belong to incompatible
+        // with `'!1_0`, because they belong to incompatible
         // universes.
         goal {
             exists<'a> {
@@ -1223,7 +1223,7 @@ fn unify_quantified_lifetimes() {
         } yields {
             "Unique; for<?U0> { \
              substitution [?0 := '?0], \
-             lifetime constraints [InEnvironment { environment: Env([]), goal: '?0 == '!1 }] \
+             lifetime constraints [InEnvironment { environment: Env([]), goal: '?0 == '!1_0 }] \
              }"
         }
 
@@ -1239,8 +1239,8 @@ fn unify_quantified_lifetimes() {
             }
         } yields {
             "Unique; for<?U0> { \
-             substitution [?0 := '?0, ?1 := '!1], \
-             lifetime constraints [InEnvironment { environment: Env([]), goal: '?0 == '!1 }] \
+             substitution [?0 := '?0, ?1 := '!1_0], \
+             lifetime constraints [InEnvironment { environment: Env([]), goal: '?0 == '!1_0 }] \
              }"
         }
     }
@@ -1254,7 +1254,7 @@ fn equality_binder() {
         }
 
         // Check that `'a` (here, `'?0`) is not unified
-        // with `'!1`, because they belong to incompatible
+        // with `'!1_0`, because they belong to incompatible
         // universes.
         goal {
             forall<T> {
@@ -1265,7 +1265,7 @@ fn equality_binder() {
         } yields {
             "Unique; for<?U1> { \
                  substitution [?0 := '?0], \
-                 lifetime constraints [InEnvironment { environment: Env([]), goal: '!2 == '?0 }] \
+                 lifetime constraints [InEnvironment { environment: Env([]), goal: '!2_0 == '?0 }] \
              }"
         }
     }
@@ -2172,8 +2172,8 @@ fn overflow_universe() {
             trait Bar { }
 
             // When asked to solve X: Bar, we will produce a
-            // requirement to solve !1: Bar. And then when asked to
-            // solve that, we'll produce a requirement to solve !2:
+            // requirement to solve !1_0: Bar. And then when asked to
+            // solve that, we'll produce a requirement to solve !1_1:
             // Bar.  And so forth.
             forall<X> { X: Bar if forall<Y> { Y: Bar } }
         }
@@ -2183,7 +2183,7 @@ fn overflow_universe() {
         } yields {
             // The internal universe canonicalization in the on-demand/recursive
             // solver means that when we are asked to solve (e.g.)
-            // `!2: Bar`, we rewrite that to `!1: Bar`, identifying a
+            // `!1_1: Bar`, we rewrite that to `!1_0: Bar`, identifying a
             // cycle.
             "No possible solution"
         }
@@ -2270,9 +2270,9 @@ fn gat_unify_with_implied_wc() {
 //
 // The problem was that we wound up enumerating a goal like
 //
-//     <?0 as SliceExt>::Item = !1
+//     <?0 as SliceExt>::Item = !1_0
 //
-// which meant "find me the types that normalize to `!1`". We had no
+// which meant "find me the types that normalize to `!1_0`". We had no
 // problem finding these types, but after the first such type, we had
 // the only unique answer we would ever find, and we wanted to reach
 // the point where we could say "no more answers", so we kept
@@ -2396,7 +2396,7 @@ fn quantified_types() {
         } yields {
             // Lifetime constraints are unsatisfiable
             "Unique; substitution [], \
-            lifetime constraints [InEnvironment { environment: Env([]), goal: '!2 == '!1 }]"
+            lifetime constraints [InEnvironment { environment: Env([]), goal: '!2_0 == '!1_0 }]"
         }
     }
 }
diff --git a/src/test/slg.rs b/src/test/slg.rs
@@ -482,7 +482,7 @@ fn subgoal_cycle_uninhabited() {
                 Answer {
                     subst: Canonical {
                         value: ConstrainedSubst {
-                            subst: [?0 := !1],
+                            subst: [?0 := !1_0],
                             constraints: []
                         },
                         binders: []
@@ -550,7 +550,7 @@ fn basic_region_constraint_from_positive_impl() {
                             constraints: [
                                 InEnvironment {
                                     environment: Env([]),
-                                    goal: '!2 == '!1
+                                    goal: '!1_1 == '!1_0
                                 }
                             ]
                         },

Original file line number	Diff line number	Diff line change
`@@ -478,7 +478,7 @@ fn normalize_basic() {`
`478`	`478`	`}`
`479`	`479`	`}`
`480`	`480`	`} yields {`
`481`		`- "Unique; substitution [?0 := !1], lifetime constraints []"`
	`481`	`+ "Unique; substitution [?0 := !1_0], lifetime constraints []"`
`482`	`482`	`}`
`483`	`483`
`484`	`484`	`goal {`
`@@ -508,7 +508,7 @@ fn normalize_basic() {`
`508`	`508`	`}`
`509`	`509`	`}`
`510`	`510`	`} yields {`
`511`		`- "Unique; substitution [?0 := (Iterator::Item)<!1>]"`
	`511`	`+ "Unique; substitution [?0 := (Iterator::Item)<!1_0>]"`
`512`	`512`	`}`
`513`	`513`
`514`	`514`	`goal {`
`@@ -520,7 +520,7 @@ fn normalize_basic() {`
`520`	`520`	`}`
`521`	`521`	`}`
`522`	`522`	`} yields {`
`523`		`- "Unique; substitution [?0 := (Iterator::Item)<!1>]"`
	`523`	`+ "Unique; substitution [?0 := (Iterator::Item)<!1_0>]"`
`524`	`524`	`}`
`525`	`525`
`526`	`526`	`goal {`
`@@ -583,7 +583,7 @@ fn normalize_gat1() {`
`583`	`583`	`}`
`584`	`584`	`}`
`585`	`585`	`} yields {`
`586`		`- "Unique; substitution [?0 := Iter<'!2, !1>], lifetime constraints []"`
	`586`	`+ "Unique; substitution [?0 := Iter<'!2_0, !1_0>], lifetime constraints []"`
`587`	`587`	`}`
`588`	`588`	`}`
`589`	`589`	`}`
`@@ -608,7 +608,7 @@ fn normalize_gat2() {`
`608`	`608`	`}`
`609`	`609`	`}`
`610`	`610`	`} yields {`
`611`		`- "Unique; substitution [?0 := Span<'!1, !2>], lifetime constraints []"`
	`611`	`+ "Unique; substitution [?0 := Span<'!1_0, !1_1>], lifetime constraints []"`
`612`	`612`	`}`
`613`	`613`
`614`	`614`	`goal {`
`@@ -666,7 +666,7 @@ fn normalize_gat_with_where_clause() {`
`666`	`666`	`}`
`667`	`667`	`}`
`668`	`668`	`} yields {`
`669`		`- "Unique; substitution [?0 := Value<!1>]"`
	`669`	`+ "Unique; substitution [?0 := Value<!1_0>]"`
`670`	`670`	`}`
`671`	`671`	`}`
`672`	`672`	`}`
`@@ -705,7 +705,7 @@ fn normalize_gat_with_where_clause2() {`
`705`	`705`	`}`
`706`	`706`	`}`
`707`	`707`	`} yields {`
`708`		`- "Unique; substitution [?0 := !2]"`
	`708`	`+ "Unique; substitution [?0 := !1_1]"`
`709`	`709`	`}`
`710`	`710`	`}`
`711`	`711`	`}`
`@@ -924,7 +924,7 @@ fn region_equality() {`
`924`	`924`	`} yields {`
`925`	`925`	`"Unique; substitution [],`
`926`	`926`	`lifetime constraints \`
`927`		`- [InEnvironment { environment: Env([]), goal: '!2 == '!1 }]`
	`927`	`+ [InEnvironment { environment: Env([]), goal: '!1_1 == '!1_0 }]`
`928`	`928`	`"`
`929`	`929`	`}`
`930`	`930`
`@@ -935,7 +935,7 @@ fn region_equality() {`
`935`	`935`	`}`
`936`	`936`	`}`
`937`	`937`	`} yields {`
`938`		`- "Unique; substitution [?0 := '!1], lifetime constraints []"`
	`938`	`+ "Unique; substitution [?0 := '!1_0], lifetime constraints []"`
`939`	`939`	`}`
`940`	`940`	`}`
`941`	`941`	`}`
`@@ -968,12 +968,12 @@ fn forall_equality() {`
`968`	`968`	`// this is because the region constraints are unsolvable.`
`969`	`969`	`//`
`970`	`970`	// Note that `?0` (in universe 2) must be equal to both
`971`		- // `!1` and `!2`, which of course it cannot be.
	`971`	+ // `!1_0` and `!1_1`, which of course it cannot be.
`972`	`972`	`for<'a, 'b> Ref<'a, Ref<'b, Ref<'a, Unit>>>: Eq<`
`973`	`973`	`for<'c, 'd> Ref<'c, Ref<'d, Ref<'d, Unit>>>>`
`974`	`974`	`} yields {`
`975`	`975`	`"Unique; substitution [], lifetime constraints [`
`976`		`- InEnvironment { environment: Env([]), goal: '!2 == '!1 }`
	`976`	`+ InEnvironment { environment: Env([]), goal: '!1_1 == '!1_0 }`
`977`	`977`	`]"`
`978`	`978`	`}`
`979`	`979`	`}`
`@@ -1187,7 +1187,7 @@ fn normalize_under_binder() {`
`1187`	`1187`	`}`
`1188`	`1188`	`}`
`1189`	`1189`	`} yields {`
`1190`		`- "Unique; substitution [?0 := Ref<'!1, I32>], lifetime constraints []"`
	`1190`	`+ "Unique; substitution [?0 := Ref<'!1_0, I32>], lifetime constraints []"`
`1191`	`1191`	`}`
`1192`	`1192`
`1193`	`1193`	`goal {`
`@@ -1199,7 +1199,7 @@ fn normalize_under_binder() {`
`1199`	`1199`	`} yields {`
`1200`	`1200`	`"Unique; for<?U0> { \`
`1201`	`1201`	`substitution [?0 := Ref<'?0, I32>], \`
`1202`		`- lifetime constraints [InEnvironment { environment: Env([]), goal: '?0 == '!1 }] \`
	`1202`	`+ lifetime constraints [InEnvironment { environment: Env([]), goal: '?0 == '!1_0 }] \`
`1203`	`1203`	`}"`
`1204`	`1204`	`}`
`1205`	`1205`	`}`
`@@ -1212,7 +1212,7 @@ fn unify_quantified_lifetimes() {`
`1212`	`1212`	`}`
`1213`	`1213`
`1214`	`1214`	// Check that `'a` (here, `'?0`) is not unified
`1215`		- // with `'!1`, because they belong to incompatible
	`1215`	+ // with `'!1_0`, because they belong to incompatible
`1216`	`1216`	`// universes.`
`1217`	`1217`	`goal {`
`1218`	`1218`	`exists<'a> {`
`@@ -1223,7 +1223,7 @@ fn unify_quantified_lifetimes() {`
`1223`	`1223`	`} yields {`
`1224`	`1224`	`"Unique; for<?U0> { \`
`1225`	`1225`	`substitution [?0 := '?0], \`
`1226`		`- lifetime constraints [InEnvironment { environment: Env([]), goal: '?0 == '!1 }] \`
	`1226`	`+ lifetime constraints [InEnvironment { environment: Env([]), goal: '?0 == '!1_0 }] \`
`1227`	`1227`	`}"`
`1228`	`1228`	`}`
`1229`	`1229`
`@@ -1239,8 +1239,8 @@ fn unify_quantified_lifetimes() {`
`1239`	`1239`	`}`
`1240`	`1240`	`} yields {`
`1241`	`1241`	`"Unique; for<?U0> { \`
`1242`		`- substitution [?0 := '?0, ?1 := '!1], \`
`1243`		`- lifetime constraints [InEnvironment { environment: Env([]), goal: '?0 == '!1 }] \`
	`1242`	`+ substitution [?0 := '?0, ?1 := '!1_0], \`
	`1243`	`+ lifetime constraints [InEnvironment { environment: Env([]), goal: '?0 == '!1_0 }] \`
`1244`	`1244`	`}"`
`1245`	`1245`	`}`
`1246`	`1246`	`}`
`@@ -1254,7 +1254,7 @@ fn equality_binder() {`
`1254`	`1254`	`}`
`1255`	`1255`
`1256`	`1256`	// Check that `'a` (here, `'?0`) is not unified
`1257`		- // with `'!1`, because they belong to incompatible
	`1257`	+ // with `'!1_0`, because they belong to incompatible
`1258`	`1258`	`// universes.`
`1259`	`1259`	`goal {`
`1260`	`1260`	`forall<T> {`
`@@ -1265,7 +1265,7 @@ fn equality_binder() {`
`1265`	`1265`	`} yields {`
`1266`	`1266`	`"Unique; for<?U1> { \`
`1267`	`1267`	`substitution [?0 := '?0], \`
`1268`		`- lifetime constraints [InEnvironment { environment: Env([]), goal: '!2 == '?0 }] \`
	`1268`	`+ lifetime constraints [InEnvironment { environment: Env([]), goal: '!2_0 == '?0 }] \`
`1269`	`1269`	`}"`
`1270`	`1270`	`}`
`1271`	`1271`	`}`
`@@ -2172,8 +2172,8 @@ fn overflow_universe() {`
`2172`	`2172`	`trait Bar { }`
`2173`	`2173`
`2174`	`2174`	`// When asked to solve X: Bar, we will produce a`
`2175`		`- // requirement to solve !1: Bar. And then when asked to`
`2176`		`- // solve that, we'll produce a requirement to solve !2:`
	`2175`	`+ // requirement to solve !1_0: Bar. And then when asked to`
	`2176`	`+ // solve that, we'll produce a requirement to solve !1_1:`
`2177`	`2177`	`// Bar. And so forth.`
`2178`	`2178`	`forall<X> { X: Bar if forall<Y> { Y: Bar } }`
`2179`	`2179`	`}`
`@@ -2183,7 +2183,7 @@ fn overflow_universe() {`
`2183`	`2183`	`} yields {`
`2184`	`2184`	`// The internal universe canonicalization in the on-demand/recursive`
`2185`	`2185`	`// solver means that when we are asked to solve (e.g.)`
`2186`		- // `!2: Bar`, we rewrite that to `!1: Bar`, identifying a
	`2186`	+ // `!1_1: Bar`, we rewrite that to `!1_0: Bar`, identifying a
`2187`	`2187`	`// cycle.`
`2188`	`2188`	`"No possible solution"`
`2189`	`2189`	`}`
`@@ -2270,9 +2270,9 @@ fn gat_unify_with_implied_wc() {`
`2270`	`2270`	`//`
`2271`	`2271`	`// The problem was that we wound up enumerating a goal like`
`2272`	`2272`	`//`
`2273`		`-// <?0 as SliceExt>::Item = !1`
	`2273`	`+// <?0 as SliceExt>::Item = !1_0`
`2274`	`2274`	`//`
`2275`		-// which meant "find me the types that normalize to `!1`". We had no
	`2275`	+// which meant "find me the types that normalize to `!1_0`". We had no
`2276`	`2276`	`// problem finding these types, but after the first such type, we had`
`2277`	`2277`	`// the only unique answer we would ever find, and we wanted to reach`
`2278`	`2278`	`// the point where we could say "no more answers", so we kept`
`@@ -2396,7 +2396,7 @@ fn quantified_types() {`
`2396`	`2396`	`} yields {`
`2397`	`2397`	`// Lifetime constraints are unsatisfiable`
`2398`	`2398`	`"Unique; substitution [], \`
`2399`		`- lifetime constraints [InEnvironment { environment: Env([]), goal: '!2 == '!1 }]"`
	`2399`	`+ lifetime constraints [InEnvironment { environment: Env([]), goal: '!2_0 == '!1_0 }]"`
`2400`	`2400`	`}`
`2401`	`2401`	`}`
`2402`	`2402`	`}`