Rustup (#752)

Rustup

Author: RalfJung

rust-version

@@ -1 +1 @@
-81970852e172c04322cbf8ba23effabeb491c83c
+c28084ac16af4ab594b6860958df140e7c876a13

tests/run-pass/box_box_trait.rs

@@ -14,18 +14,18 @@ trait MyTrait { fn dummy(&self) { } }
 impl MyTrait for Box<DroppableStruct> {}
 
 #[allow(dead_code)]
-struct Whatever { w: Box<MyTrait+'static> }
+struct Whatever { w: Box<dyn MyTrait+'static> }
 
 impl  Whatever {
-    fn new(w: Box<MyTrait+'static>) -> Whatever {
+    fn new(w: Box<dyn MyTrait+'static>) -> Whatever {
         Whatever { w: w }
     }
 }
 
 fn main() {
     {
         let f: Box<_> = box DroppableStruct;
-        let _a = Whatever::new(box f as Box<MyTrait>);
+        let _a = Whatever::new(box f as Box<dyn MyTrait>);
     }
     assert!(unsafe { DROPPED });
 }

tests/run-pass/call_drop_on_fat_ptr_array_elements.rs

@@ -13,7 +13,7 @@ impl Drop for Bar {
 }
 
 fn main() {
-    let b: [Box<Foo>; 4] = [Box::new(Bar), Box::new(Bar), Box::new(Bar), Box::new(Bar)];
+    let b: [Box<dyn Foo>; 4] = [Box::new(Bar), Box::new(Bar), Box::new(Bar), Box::new(Bar)];
     assert_eq!(unsafe { DROP_COUNT }, 0);
     drop(b);
     assert_eq!(unsafe { DROP_COUNT }, 4);

tests/run-pass/call_drop_through_trait_object.rs

@@ -13,7 +13,7 @@ impl Drop for Bar {
 impl Foo for Bar {}
 
 fn main() {
-    let b: Box<Foo> = Box::new(Bar);
+    let b: Box<dyn Foo> = Box::new(Bar);
     assert!(unsafe { !DROP_CALLED });
     drop(b);
     assert!(unsafe { DROP_CALLED });

tests/run-pass/call_drop_through_trait_object_rc.rs

@@ -15,7 +15,7 @@ impl Foo for Bar {}
 use std::rc::Rc;
 
 fn main() {
-    let b: Rc<Foo> = Rc::new(Bar);
+    let b: Rc<dyn Foo> = Rc::new(Bar);
     assert!(unsafe { !DROP_CALLED });
     drop(b);
     assert!(unsafe { DROP_CALLED });

tests/run-pass/cast-rfc0401-vtable-kinds.rs

@@ -13,9 +13,9 @@ impl<T> Foo<T> for () {}
 impl Foo<u32> for u32 { fn foo(&self, _: u32) -> u32 { self+43 } }
 impl Bar for () {}
 
-unsafe fn round_trip_and_call<'a>(t: *const (Foo<u32>+'a)) -> u32 {
-    let foo_e : *const Foo<u16> = t as *const _;
-    let r_1 = foo_e as *mut Foo<u32>;
+unsafe fn round_trip_and_call<'a>(t: *const (dyn Foo<u32>+'a)) -> u32 {
+    let foo_e : *const dyn Foo<u16> = t as *const _;
+    let r_1 = foo_e as *mut dyn Foo<u32>;
 
     (&*r_1).foo(0)
 }
@@ -31,8 +31,8 @@ fn foo_to_bar<T:?Sized>(u: *const FooS<T>) -> *const BarS<T> {
 
 fn main() {
     let x = 4u32;
-    let y : &Foo<u32> = &x;
-    let fl = unsafe { round_trip_and_call(y as *const Foo<u32>) };
+    let y : &dyn Foo<u32> = &x;
+    let fl = unsafe { round_trip_and_call(y as *const dyn Foo<u32>) };
     assert_eq!(fl, (43+4));
 
     let s = FooS([0,1,2]);

tests/run-pass/closures.rs

@@ -44,10 +44,62 @@ fn boxed(f: Box<dyn FnOnce() -> i32>) -> i32 {
     f()
 }
 
+fn fn_item_as_closure_trait_object() {
+    fn foo() {}
+    let f: &dyn Fn() = &foo;
+    f();
+}
+
+fn fn_item_with_args_as_closure_trait_object() {
+    fn foo(i: i32) {
+        assert_eq!(i, 42);
+    }
+    let f: &dyn Fn(i32) = &foo;
+    f(42);
+}
+
+fn fn_item_with_multiple_args_as_closure_trait_object() {
+    fn foo(i: i32, j: i32) {
+        assert_eq!(i, 42);
+        assert_eq!(j, 55);
+    }
+
+    fn bar(i: i32, j: i32, k: f32) {
+        assert_eq!(i, 42);
+        assert_eq!(j, 55);
+        assert_eq!(k, 3.14159)
+    }
+    let f: &dyn Fn(i32, i32) = &foo;
+    f(42, 55);
+    let f: &dyn Fn(i32, i32, f32) = &bar;
+    f(42, 55, 3.14159);
+}
+
+fn fn_ptr_as_closure_trait_object() {
+    fn foo() {}
+    fn bar(u: u32) { assert_eq!(u, 42); }
+    fn baa(u: u32, f: f32) {
+        assert_eq!(u, 42);
+        assert_eq!(f, 3.141);
+    }
+    let f: &dyn Fn() = &(foo as fn());
+    f();
+    let f: &dyn Fn(u32) = &(bar as fn(u32));
+    f(42);
+    let f: &dyn Fn(u32, f32) = &(baa as fn(u32, f32));
+    f(42, 3.141);
+}
+
+
 fn main() {
     assert_eq!(simple(), 12);
     assert_eq!(crazy_closure(), (84, 10, 10));
     assert_eq!(closure_arg_adjustment_problem(), 3);
     assert_eq!(fn_once_closure_with_multiple_args(), 6);
     assert_eq!(boxed(Box::new({let x = 13; move || x})), 13);
+
+    fn_item_as_closure_trait_object();
+    fn_item_with_args_as_closure_trait_object();
+    fn_item_with_multiple_args_as_closure_trait_object();
+    fn_ptr_as_closure_trait_object();
 }

tests/run-pass/dst-field-align.rs

@@ -26,15 +26,15 @@ fn main() {
     // Test that zero-offset works properly
     let b : Baz<usize> = Baz { a: 7 };
     assert_eq!(b.a.get(), 7);
-    let b : &Baz<Bar> = &b;
+    let b : &Baz<dyn Bar> = &b;
     assert_eq!(b.a.get(), 7);
 
     // Test that the field is aligned properly
     let f : Foo<usize> = Foo { a: 0, b: 11 };
     assert_eq!(f.b.get(), 11);
     let ptr1 : *const u8 = &f.b as *const _ as *const u8;
 
-    let f : &Foo<Bar> = &f;
+    let f : &Foo<dyn Bar> = &f;
     let ptr2 : *const u8 = &f.b as *const _ as *const u8;
     assert_eq!(f.b.get(), 11);
 
@@ -44,13 +44,13 @@ fn main() {
     // Test that nested DSTs work properly
     let f : Foo<Foo<usize>> = Foo { a: 0, b: Foo { a: 1, b: 17 }};
     assert_eq!(f.b.b.get(), 17);
-    let f : &Foo<Foo<Bar>> = &f;
+    let f : &Foo<Foo<dyn Bar>> = &f;
     assert_eq!(f.b.b.get(), 17);
 
     // Test that get the pointer via destructuring works
 
     let f : Foo<usize> = Foo { a: 0, b: 11 };
-    let f : &Foo<Bar> = &f;
+    let f : &Foo<dyn Bar> = &f;
     let &Foo { a: _, b: ref bar } = f;
     assert_eq!(bar.get(), 11);
 

tests/run-pass/dst-raw.rs

@@ -21,15 +21,15 @@ struct Foo<T: ?Sized> {
 pub fn main() {
     // raw trait object
     let x = A { f: 42 };
-    let z: *const Trait = &x;
+    let z: *const dyn Trait = &x;
     let r = unsafe {
         (&*z).foo()
     };
     assert_eq!(r, 42);
 
     // raw DST struct
     let p = Foo {f: A { f: 42 }};
-    let o: *const Foo<Trait> = &p;
+    let o: *const Foo<dyn Trait> = &p;
     let r = unsafe {
         (&*o).f.foo()
     };
@@ -64,14 +64,14 @@ pub fn main() {
 
     // all of the above with *mut
     let mut x = A { f: 42 };
-    let z: *mut Trait = &mut x;
+    let z: *mut dyn Trait = &mut x;
     let r = unsafe {
         (&*z).foo()
     };
     assert_eq!(r, 42);
 
     let mut p = Foo {f: A { f: 42 }};
-    let o: *mut Foo<Trait> = &mut p;
+    let o: *mut Foo<dyn Trait> = &mut p;
     let r = unsafe {
         (&*o).f.foo()
     };