src/test/ui/issues/issue-15763.rs

   1 // run-pass
   2 #![allow(unreachable_code)]
   3 #![feature(box_syntax)]
   4
   5 #[derive(PartialEq, Debug)]
   6 struct Bar {
   7     x: isize
   8 }
   9 impl Drop for Bar {
  10     fn drop(&mut self) {
  11         assert_eq!(self.x, 22);
  12     }
  13 }
  14
  15 #[derive(PartialEq, Debug)]
  16 struct Foo {
  17     x: Bar,
  18     a: isize
  19 }
  20
  21 fn foo() -> Result<Foo, isize> {
  22     return Ok(Foo {
  23         x: Bar { x: 22 },
  24         a: return Err(32)
  25     });
  26 }
  27
  28 fn baz() -> Result<Foo, isize> {
  29     Ok(Foo {
  30         x: Bar { x: 22 },
  31         a: return Err(32)
  32     })
  33 }
  34
  35 // explicit immediate return
  36 fn aa() -> isize {
  37     return 3;
  38 }
  39
  40 // implicit immediate return
  41 fn bb() -> isize {
  42     3
  43 }
  44
  45 // implicit outptr return
  46 fn cc() -> Result<isize, isize> {
  47     Ok(3)
  48 }
  49
  50 // explicit outptr return
  51 fn dd() -> Result<isize, isize> {
  52     return Ok(3);
  53 }
  54
  55 trait A {
  56     fn aaa(&self) -> isize {
  57         3
  58     }
  59     fn bbb(&self) -> isize {
  60         return 3;
  61     }
  62     fn ccc(&self) -> Result<isize, isize> {
  63         Ok(3)
  64     }
  65     fn ddd(&self) -> Result<isize, isize> {
  66         return Ok(3);
  67     }
  68 }
  69
  70 impl A for isize {}
  71
  72 fn main() {
  73     assert_eq!(foo(), Err(32));
  74     assert_eq!(baz(), Err(32));
  75
  76     assert_eq!(aa(), 3);
  77     assert_eq!(bb(), 3);
  78     assert_eq!(cc().unwrap(), 3);
  79     assert_eq!(dd().unwrap(), 3);
  80
  81     let i = box 32isize as Box<dyn A>;
  82     assert_eq!(i.aaa(), 3);
  83     let i = box 32isize as Box<dyn A>;
  84     assert_eq!(i.bbb(), 3);
  85     let i = box 32isize as Box<dyn A>;
  86     assert_eq!(i.ccc().unwrap(), 3);
  87     let i = box 32isize as Box<dyn A>;
  88     assert_eq!(i.ddd().unwrap(), 3);
  89 }