From e6ced2f9c45ee73f092d36035e4ba70300ca5516 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sun, 24 May 2020 11:58:19 +0200
Subject: [PATCH] add interesting unsizing test

---
 tests/run-pass/dyn-lcsit.rs | 68 +++++++++++++++++++++++++++++++++++++
 1 file changed, 68 insertions(+)
 create mode 100644 tests/run-pass/dyn-lcsit.rs

diff --git a/tests/run-pass/dyn-lcsit.rs b/tests/run-pass/dyn-lcsit.rs
new file mode 100644
index 00000000000..fa11e9a2a31
--- /dev/null
+++ b/tests/run-pass/dyn-lcsit.rs
@@ -0,0 +1,68 @@
+// Taken from the rustc test suite; this triggers an interesting case in unsizing.
+
+#![allow(non_upper_case_globals, incomplete_features)]
+#![feature(associated_type_bounds)]
+#![feature(impl_trait_in_bindings)]
+
+use std::ops::Add;
+
+trait Tr1 { type As1; fn mk(&self) -> Self::As1; }
+trait Tr2<'a> { fn tr2(self) -> &'a Self; }
+
+fn assert_copy<T: Copy>(x: T) { let _x = x; let _x = x; }
+fn assert_static<T: 'static>(_: T) {}
+fn assert_forall_tr2<T: for<'a> Tr2<'a>>(_: T) {}
+
+#[derive(Copy, Clone)]
+struct S1;
+#[derive(Copy, Clone)]
+struct S2;
+impl Tr1 for S1 { type As1 = S2; fn mk(&self) -> Self::As1 { S2 } }
+
+const cdef_et1: &dyn Tr1<As1: Copy> = &S1;
+const sdef_et1: &dyn Tr1<As1: Copy> = &S1;
+pub fn use_et1() { assert_copy(cdef_et1.mk()); assert_copy(sdef_et1.mk()); }
+
+const cdef_et2: &(dyn Tr1<As1: 'static> + Sync) = &S1;
+static sdef_et2: &(dyn Tr1<As1: 'static> + Sync) = &S1;
+pub fn use_et2() { assert_static(cdef_et2.mk()); assert_static(sdef_et2.mk()); }
+
+const cdef_et3: &dyn Tr1<As1: Clone + Iterator<Item: Add<u8, Output: Into<u8>>>> = {
+    struct A;
+    impl Tr1 for A {
+        type As1 = core::ops::Range<u8>;
+        fn mk(&self) -> Self::As1 { 0..10 }
+    };
+    &A
+};
+pub fn use_et3() {
+    let _0 = cdef_et3.mk().clone();
+    let mut s = 0u8;
+    for _1 in _0 {
+        let _2 = _1 + 1u8;
+        s += _2.into();
+    }
+    assert_eq!(s, (0..10).map(|x| x + 1).sum());
+}
+
+const cdef_et4: &(dyn Tr1<As1: for<'a> Tr2<'a>> + Sync) = {
+    #[derive(Copy, Clone)]
+    struct A;
+    impl Tr1 for A {
+        type As1 = A;
+        fn mk(&self) -> A { A }
+    }
+    impl<'a> Tr2<'a> for A {
+        fn tr2(self) -> &'a Self { &A }
+    }
+    &A
+};
+static sdef_et4: &(dyn Tr1<As1: for<'a> Tr2<'a>> + Sync) = cdef_et4;
+pub fn use_et4() { assert_forall_tr2(cdef_et4.mk()); assert_forall_tr2(sdef_et4.mk()); }
+
+fn main() {
+    let _ = use_et1();
+    let _ = use_et2();
+    let _ = use_et3();
+    let _ = use_et4();
+}
-- 
2.44.0