add soundness, backwards-incompat test cases

`call-forall` shows the expected behavior: the where-clause proves
too much, so we can't prove it.

`backwards-incompat` shows the problem with that: we can construct
types that we ought not to be able to construct.

Author: nikomatsakis

src/test/ui/generic-associated-types/call-back-compat.rs

@@ -0,0 +1,33 @@
+// known-bug
+// check-pass
+
+#![feature(generic_associated_types)]
+
+trait LendingIterator {
+    type Item<'a>
+    where
+        Self: 'a;
+}
+
+impl<'slice> LendingIterator for &'slice [u32] {
+    type Item<'a> = &'a [u32]
+    where
+        Self: 'a;
+}
+
+impl<'slice> LendingIterator for [u32] {
+    type Item<'a> = &'a [u32]
+    where
+        Self: 'a;
+}
+
+fn broke<T: ?Sized>() -> Option<&'static [u32]>
+where
+    for<'a> T: LendingIterator<Item<'a> = &'a [u32]>,
+{
+    None::<<T as LendingIterator>::Item<'static>>
+    // FIXME: Should not compile, but does, because we are trusting the where-clauses
+    // and don't have implied bounds.
+}
+
+fn main() {}

src/test/ui/generic-associated-types/call-forall.rs

@@ -0,0 +1,43 @@
+#![feature(generic_associated_types)]
+
+trait LendingIterator {
+    type Item<'a>
+    where
+        Self: 'a;
+}
+
+impl<'slice> LendingIterator for &'slice [u32] {
+    type Item<'a> = &'a [u32]
+    where
+        Self: 'a;
+}
+
+impl<'slice> LendingIterator for [u32] {
+    type Item<'a> = &'a [u32]
+    where
+        Self: 'a;
+}
+
+fn call_me<T: ?Sized>()
+where
+    for<'a> T: LendingIterator<Item<'a> = &'a [u32]>,
+{
+    if false {
+        call_me::<T>();
+    }
+}
+
+fn ok_i_will1<'test>() {
+    // Gets an error because we cannot prove that, for all 'a, `&'test [u32]: 'a`.
+    //
+    // This is a bug -- what should happen is that there is an implied bound
+    // so that `for<'a>` really means "for all `'a` that make sense", in which case
+    // this ought to be provable.
+    call_me::<&'test [u32]>; //~ ERROR lifetime may not live long enough
+}
+
+fn ok_i_will2() {
+    // OK because, for all 'a, `[u32]: 'a`.
+    call_me::<[u32]>;
+}
+fn main() {}

src/test/ui/generic-associated-types/call-forall.stderr

@@ -0,0 +1,11 @@
+error: lifetime may not live long enough
+  --> $DIR/call-forall.rs:36:5
+   |
+LL | fn ok_i_will1<'test>() {
+   |               ----- lifetime `'test` defined here
+...
+LL |     call_me::<&'test [u32]>;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^ requires that `'test` must outlive `'static`
+
+error: aborting due to previous error
+