Added tests.

Author: Alexander Regueiro

src/librustc_infer/infer/error_reporting/mod.rs

@@ -1686,7 +1686,9 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
         let trait_ref = Binder::bind(TraitRef::identity(self.tcx, exp_found.found));
         let supertraits = crate::traits::util::supertraits(self.tcx, trait_ref);
         if supertraits.into_iter().any(|trait_ref| trait_ref.def_id() == exp_found.expected) {
-            diag.note("add `#![feature(trait_upcasting)]` to the crate attributes to enable");
+            diag.note(
+                "add `#![feature(trait_upcasting)]` to the crate attributes to enable \
+                 trait upcasting");
         }
     }
 

src/test/ui/feature-gate/feature-gate-c_variadic.rs renamed to src/test/ui/feature-gates/feature-gate-c_variadic.rs

@@ -10,7 +10,8 @@ fn main() {
     let bar: &dyn Bar = &();
     let foo: &dyn Foo = bar;
     //~^ ERROR mismatched types [E0308]
-    //~| NOTE expected type `&dyn Foo`
     //~| NOTE expected trait `Foo`, found trait `Bar`
-    //~| NOTE add `#![feature(trait_upcasting)]` to the crate attributes to enable
+    //~| NOTE expected due to this
+    //~| NOTE expected reference `&dyn Foo`
+    //~| NOTE add `#![feature(trait_upcasting)]` to the crate attributes to enable trait upcasting
 }

src/test/ui/feature-gate/feature-gate-c_variadic.stderr renamed to src/test/ui/feature-gates/feature-gate-c_variadic.stderr

@@ -2,11 +2,13 @@ error[E0308]: mismatched types
   --> $DIR/feature-gate-trait_upcasting.rs:11:25
    |
 LL |     let foo: &dyn Foo = bar;
-   |                         ^^^ expected trait `Foo`, found trait `Bar`
+   |              --------   ^^^ expected trait `Foo`, found trait `Bar`
+   |              |
+   |              expected due to this
    |
-   = note: add `#![feature(trait_upcasting)]` to the crate attributes to enable
-   = note: expected type `&dyn Foo`
-              found type `&dyn Bar`
+   = note: expected reference `&dyn Foo`
+              found reference `&dyn Bar`
+   = note: add `#![feature(trait_upcasting)]` to the crate attributes to enable trait upcasting
 
 error: aborting due to previous error
 

src/test/ui/feature-gate/feature-gate-static-nobundle-2.rs renamed to src/test/ui/feature-gates/feature-gate-static-nobundle-2.rs

@@ -0,0 +1,80 @@
+// run-pass
+
+#![feature(trait_upcasting)]
+
+trait Foo: PartialEq<i32> + std::fmt::Debug + Send + Sync {
+    fn a(&self) -> i32 { 10 }
+
+    fn z(&self) -> i32 { 11 }
+
+    fn y(&self) -> i32 { 12 }
+}
+
+trait Bar: Foo {
+    fn b(&self) -> i32 { 20 }
+
+    fn w(&self) -> i32 { 21 }
+}
+
+trait Baz: Bar {
+    fn c(&self) -> i32 { 30 }
+}
+
+impl Foo for i32 {
+    fn a(&self) -> i32 { 100 }
+}
+
+impl Bar for i32 {
+    fn b(&self) -> i32 { 200 }
+}
+
+impl Baz for i32 {
+    fn c(&self) -> i32 { 300 }
+}
+
+fn main() {
+    let baz: &dyn Baz = &1;
+    let _: &dyn std::fmt::Debug = baz;
+    let _: &(dyn Send + Sync) = baz;
+    let _: &dyn Send = baz;
+    let _: &dyn Sync = baz;
+    assert_eq!(*baz, 1);
+    assert_eq!(baz.a(), 100);
+    assert_eq!(baz.b(), 200);
+    assert_eq!(baz.c(), 300);
+    assert_eq!(baz.z(), 11);
+    assert_eq!(baz.y(), 12);
+    assert_eq!(baz.w(), 21);
+
+    let bar: &dyn Bar = baz;
+    let _: &dyn std::fmt::Debug = bar;
+    let _: &(dyn Send + Sync) = bar;
+    let _: &dyn Send = bar;
+    let _: &dyn Sync = bar;
+    assert_eq!(*bar, 1);
+    assert_eq!(bar.a(), 100);
+    assert_eq!(bar.b(), 200);
+    assert_eq!(bar.z(), 11);
+    assert_eq!(bar.y(), 12);
+    assert_eq!(bar.w(), 21);
+
+    let foo: &dyn Foo = baz;
+    let _: &dyn std::fmt::Debug = foo;
+    let _: &(dyn Send + Sync) = foo;
+    let _: &dyn Send = foo;
+    let _: &dyn Sync = foo;
+    assert_eq!(*foo, 1);
+    assert_eq!(foo.a(), 100);
+    assert_eq!(foo.z(), 11);
+    assert_eq!(foo.y(), 12);
+
+    let foo: &dyn Foo = bar;
+    let _: &dyn std::fmt::Debug = foo;
+    let _: &(dyn Send + Sync) = foo;
+    let _: &dyn Send = foo;
+    let _: &dyn Sync = foo;
+    assert_eq!(*foo, 1);
+    assert_eq!(foo.a(), 100);
+    assert_eq!(foo.z(), 11);
+    assert_eq!(foo.y(), 12);
+}