explain behavior of test changes

`test_overlap_alias_not_normalizable`

Author: nikomatsakis

tests/coherence_overlap.rs

@@ -262,7 +262,7 @@ fn test_overlap_normalize_alias_to_LocalType() {
 #[test]
 fn test_overlap_alias_not_normalizable() {
     // `LocalTrait` has a blanket impl for all `T: Iterator`
-    // and then an impl for `<LocalType as Mirror>::T`...
+    // and then an impl for `<T as Mirror>::T`...
 
     let gen_program = |addl: &str| {
         const BASE_PROGRAM: &str = "[
@@ -293,14 +293,29 @@ fn test_overlap_alias_not_normalizable() {
         BASE_PROGRAM.replace("ADDITIONAL", addl)
     };
 
-    // ...on its own, this is OK. Figuring this out, though, requires proving
-    // `<LocalType as Mirror>::T: Iterator` which requires normalizing
-    // the alias to `LocalType`...
+    // ...you might expect an error here, because we have an impl for all `T` and another
+    // impl for all `T: Iterator`, but we don't flag it as one because
+    // Iterator is a local trait and we can see that nobody has implemented it...
+    //
+    // FIXME: rustc DOES flag an error here. I think this is because the trait solver
+    // refuses to solve `?X: Iterator`; we haven't implemented that rule and I haven't
+    // decided how to think about it.
 
     expect_test::expect![[r#"
         Ok(
             (),
         )
-    "#]] // FIXME
+    "#]]
     .assert_debug_eq(&test_program_ok(&gen_program("")));
+
+    // ...as long as there is at least one Iterator impl, however, we do flag an error.
+
+    expect_test::expect![[r#"
+        Err(
+            "impls may overlap: `impl <ty> LocalTrait < > for ^ty0_0 where [^ty0_0 : Iterator < >] { }` vs `impl <ty> LocalTrait < > for (alias (Mirror :: T) ^ty0_0) where [^ty0_0 : Mirror < >] { }`",
+        )
+    "#]] // FIXME
+    .assert_debug_eq(&test_program_ok(&gen_program(
+        "impl<> Iterator<> for u32 where[] {}",
+    )));
 }