tests/target/impls.rs

   1 impl Foo for Bar {
   2     fn foo() {
   3         "hi"
   4     }
   5 }
   6
   7 pub impl Foo for Bar {
   8     // Associated Constants
   9     const Baz: i32 = 16;
  10     // Associated Types
  11     type FooBar = usize;
  12     // Comment 1
  13     fn foo() {
  14         "hi"
  15     }
  16     // Comment 2
  17     fn foo() {
  18         "hi"
  19     }
  20     // Comment 3
  21 }
  22
  23 pub unsafe impl<'a, 'b, X, Y: Foo<Bar>> !Foo<'a, X> for Bar<'b, Y>
  24     where X: Foo<'a, Z>
  25 {
  26     fn foo() {
  27         "hi"
  28     }
  29 }
  30
  31 impl<'a, 'b, X, Y: Foo<Bar>> Foo<'a, X> for Bar<'b, Y>
  32     where X: Fooooooooooooooooooooooooooooo<'a, Z>
  33 {
  34     fn foo() {
  35         "hi"
  36     }
  37 }
  38
  39 impl<'a, 'b, X, Y: Foo<Bar>> Foo<'a, X> for Bar<'b, Y>
  40     where X: Foooooooooooooooooooooooooooo<'a, Z>
  41 {
  42     fn foo() {
  43         "hi"
  44     }
  45 }
  46
  47 impl<T> Foo for Bar<T> where T: Baz {}
  48
  49 impl<T> Foo for Bar<T>
  50     where T: Baz
  51 {
  52     // Comment
  53 }
  54
  55 impl Foo {
  56     fn foo() {}
  57 }
  58
  59 impl Boo {
  60     // BOO
  61     fn boo() {}
  62     // FOO
  63 }
  64
  65 mod a {
  66     impl Foo {
  67         // Hello!
  68         fn foo() {}
  69     }
  70 }
  71
  72
  73 mod b {
  74     mod a {
  75         impl Foo {
  76             fn foo() {}
  77         }
  78     }
  79 }
  80
  81 impl Foo {
  82     add_fun!();
  83 }
  84
  85 impl Blah {
  86     fn boop() {}
  87     add_fun!();
  88 }
  89
  90 impl X {
  91     fn do_parse(mut self: X) {}
  92 }
  93
  94 impl Y5000 {
  95     fn bar(self: X<'a, 'b>, y: Y) {}
  96
  97     fn bad(&self, (x, y): CoorT) {}
  98
  99     fn turbo_bad(self: X<'a, 'b>, (x, y): CoorT) {}
 100 }
 101
 102 pub impl<T> Foo for Bar<T>
 103     where T: Foo
 104 {
 105     fn foo() {
 106         "hi"
 107     }
 108 }
 109
 110 pub impl<T, Z> Foo for Bar<T, Z>
 111     where T: Foo,
 112           Z: Baz
 113 {
 114 }
 115
 116 mod m {
 117     impl<T> PartialEq for S<T>
 118         where T: PartialEq
 119     {
 120         fn eq(&self, other: &Self) {
 121             true
 122         }
 123     }
 124
 125     impl<T> PartialEq for S<T> where T: PartialEq {}
 126 }