src/test/ui/associated-type-bounds/auxiliary/fn-aux.rs

   1 // Traits:
   2
   3 pub trait Alpha {
   4     fn alpha(self) -> usize;
   5 }
   6
   7 pub trait Beta {
   8     type Gamma;
   9     fn gamma(self) -> Self::Gamma;
  10 }
  11
  12 pub trait Delta {
  13     fn delta(self) -> usize;
  14 }
  15
  16 pub trait Epsilon<'a> {
  17     type Zeta;
  18     fn zeta(&'a self) -> Self::Zeta;
  19
  20     fn epsilon(&'a self) -> usize;
  21 }
  22
  23 pub trait Eta {
  24     fn eta(self) -> usize;
  25 }
  26
  27 // Assertions:
  28
  29 pub fn assert_alpha<T: Alpha>(x: T) -> usize { x.alpha() }
  30 pub fn assert_static<T: 'static>(_: T) -> usize { 24 }
  31 pub fn assert_delta<T: Delta>(x: T) -> usize { x.delta() }
  32 pub fn assert_epsilon_specific<'a, T: 'a + Epsilon<'a>>(x: &'a T) -> usize { x.epsilon() }
  33 pub fn assert_epsilon_forall<T: for<'a> Epsilon<'a>>() {}
  34 pub fn assert_forall_epsilon_zeta_satisfies_eta<T>(x: T) -> usize
  35 where
  36     T: for<'a> Epsilon<'a>,
  37     for<'a> <T as Epsilon<'a>>::Zeta: Eta,
  38 {
  39     x.epsilon() + x.zeta().eta()
  40 }
  41
  42 // Implementations and types:
  43
  44 #[derive(Copy, Clone)]
  45 pub struct BetaType;
  46
  47 #[derive(Copy, Clone)]
  48 pub struct GammaType;
  49
  50 #[derive(Copy, Clone)]
  51 pub struct ZetaType;
  52
  53 impl Beta for BetaType {
  54     type Gamma = GammaType;
  55     fn gamma(self) -> Self::Gamma { GammaType }
  56 }
  57
  58 impl<'a> Beta for &'a BetaType {
  59     type Gamma = GammaType;
  60     fn gamma(self) -> Self::Gamma { GammaType }
  61 }
  62
  63 impl Beta for GammaType {
  64     type Gamma = Self;
  65     fn gamma(self) -> Self::Gamma { self }
  66 }
  67
  68 impl Alpha for GammaType {
  69     fn alpha(self) -> usize { 42 }
  70 }
  71
  72 impl Delta for GammaType {
  73     fn delta(self) -> usize { 1337 }
  74 }
  75
  76 impl<'a> Epsilon<'a> for GammaType {
  77     type Zeta = ZetaType;
  78     fn zeta(&'a self) -> Self::Zeta { ZetaType }
  79
  80     fn epsilon(&'a self) -> usize { 7331 }
  81 }
  82
  83 impl Eta for ZetaType {
  84     fn eta(self) -> usize { 7 }
  85 }
  86
  87 // Desugared forms to check against:
  88
  89 pub fn desugared_bound<B>(beta: B) -> usize
  90 where
  91     B: Beta,
  92     B::Gamma: Alpha
  93 {
  94     let gamma: B::Gamma = beta.gamma();
  95     assert_alpha::<B::Gamma>(gamma)
  96 }
  97
  98 pub fn desugared_bound_region<B>(beta: B) -> usize
  99 where
 100     B: Beta,
 101     B::Gamma: 'static,
 102 {
 103     assert_static::<B::Gamma>(beta.gamma())
 104 }
 105
 106 pub fn desugared_bound_multi<B>(beta: B) -> usize
 107 where
 108     B: Copy + Beta,
 109     B::Gamma: Alpha + 'static + Delta,
 110 {
 111     assert_alpha::<B::Gamma>(beta.gamma()) +
 112     assert_static::<B::Gamma>(beta.gamma()) +
 113     assert_delta::<B::Gamma>(beta.gamma())
 114 }
 115
 116 pub fn desugared_bound_region_specific<'a, B>(gamma: &'a B::Gamma) -> usize
 117 where
 118     B: Beta,
 119     B::Gamma: 'a + Epsilon<'a>,
 120 {
 121     assert_epsilon_specific::<B::Gamma>(gamma)
 122 }
 123
 124 pub fn desugared_bound_region_forall<B>(beta: B) -> usize
 125 where
 126     B: Beta,
 127     B::Gamma: Copy + for<'a> Epsilon<'a>,
 128 {
 129     assert_epsilon_forall::<B::Gamma>();
 130     let g1: B::Gamma = beta.gamma();
 131     let g2: B::Gamma = g1;
 132     assert_epsilon_specific::<B::Gamma>(&g1) +
 133     assert_epsilon_specific::<B::Gamma>(&g2)
 134 }
 135
 136 pub fn desugared_bound_region_forall2<B>(beta: B) -> usize
 137 where
 138     B: Beta,
 139     B::Gamma: Copy + for<'a> Epsilon<'a>,
 140     for<'a> <B::Gamma as Epsilon<'a>>::Zeta: Eta,
 141 {
 142     let gamma = beta.gamma();
 143     assert_forall_epsilon_zeta_satisfies_eta::<B::Gamma>(gamma)
 144 }
 145
 146 pub fn desugared_contraint_region_forall<B>(beta: B) -> usize
 147 where
 148     for<'a> &'a B: Beta,
 149     for<'a> <&'a B as Beta>::Gamma: Alpha,
 150 {
 151     let g1 = beta.gamma();
 152     let g2 = beta.gamma();
 153     assert_alpha(g1) + assert_alpha(g2)
 154 }
 155
 156 pub fn desugared_bound_nested<B>(beta: B) -> usize
 157 where
 158     B: Beta,
 159     B::Gamma: Copy + Alpha + Beta,
 160     <B::Gamma as Beta>::Gamma: Delta,
 161 {
 162     let go = beta.gamma();
 163     let gi = go.gamma();
 164     go.alpha() + gi.delta()
 165 }
 166
 167 pub fn desugared() {
 168     let beta = BetaType;
 169     let gamma = beta.gamma();
 170
 171     assert_eq!(42, desugared_bound(beta));
 172     assert_eq!(24, desugared_bound_region(beta));
 173     assert_eq!(42 + 24 + 1337, desugared_bound_multi(beta));
 174     assert_eq!(7331, desugared_bound_region_specific::<BetaType>(&gamma));
 175     assert_eq!(7331 * 2, desugared_bound_region_forall(beta));
 176     assert_eq!(42 + 1337, desugared_bound_nested(beta));
 177 }