src/test/run-pass/unsized2.rs

   1 #![allow(unconditional_recursion)]
   2 #![allow(dead_code)]
   3 #![allow(unused_variables)]
   4 #![allow(unused_imports)]
   5 #![feature(box_syntax)]
   6
   7 // Test sized-ness checking in substitution.
   8
   9 use std::marker;
  10
  11 // Unbounded.
  12 fn f1<X: ?Sized>(x: &X) {
  13     f1::<X>(x);
  14 }
  15 fn f2<X>(x: &X) {
  16     f1::<X>(x);
  17     f2::<X>(x);
  18 }
  19
  20 // Bounded.
  21 trait T { fn dummy(&self) { } }
  22 fn f3<X: T+?Sized>(x: &X) {
  23     f3::<X>(x);
  24 }
  25 fn f4<X: T>(x: &X) {
  26     f3::<X>(x);
  27     f4::<X>(x);
  28 }
  29
  30 // Self type.
  31 trait T2 {
  32     fn f() -> Box<Self>;
  33 }
  34 struct S;
  35 impl T2 for S {
  36     fn f() -> Box<S> {
  37         box S
  38     }
  39 }
  40 fn f5<X: ?Sized+T2>(x: &X) {
  41     let _: Box<X> = T2::f();
  42 }
  43 fn f6<X: T2>(x: &X) {
  44     let _: Box<X> = T2::f();
  45 }
  46
  47 trait T3 {
  48     fn f() -> Box<Self>;
  49 }
  50 impl T3 for S {
  51     fn f() -> Box<S> {
  52         box S
  53     }
  54 }
  55 fn f7<X: ?Sized+T3>(x: &X) {
  56     // This is valid, but the unsized bound on X is irrelevant because any type
  57     // which implements T3 must have statically known size.
  58     let _: Box<X> = T3::f();
  59 }
  60
  61 trait T4<X> {
  62     fn dummy(&self) { }
  63     fn m1(&self, x: &T4<X>, y: X);
  64     fn m2(&self, x: &T5<X>, y: X);
  65 }
  66 trait T5<X: ?Sized> {
  67     fn dummy(&self) { }
  68     // not an error (for now)
  69     fn m1(&self, x: &T4<X>);
  70     fn m2(&self, x: &T5<X>);
  71 }
  72
  73 trait T6<X: T> {
  74     fn dummy(&self) { }
  75     fn m1(&self, x: &T4<X>);
  76     fn m2(&self, x: &T5<X>);
  77 }
  78 trait T7<X: ?Sized+T> {
  79     fn dummy(&self) { }
  80     // not an error (for now)
  81     fn m1(&self, x: &T4<X>);
  82     fn m2(&self, x: &T5<X>);
  83 }
  84
  85 // The last field in a struct may be unsized
  86 struct S2<X: ?Sized> {
  87     f: X,
  88 }
  89 struct S3<X: ?Sized> {
  90     f1: isize,
  91     f2: X,
  92 }
  93
  94 pub fn main() {
  95 }