impls.rs

// rustfmt-normalize_comments: true
impl Foo for Bar { fn foo() { "hi" } }

pub impl Foo for Bar {
    // Associated Constants
    const   Baz:   i32 =   16;
    // Associated Types
    type   FooBar  =   usize;
    // Comment 1
    fn foo() { "hi" }
    // Comment 2
    fn foo() { "hi" }
    // Comment 3
}

#[inherent]
impl Visible for Bar {
    pub const C: i32;
    pub type T;
    pub fn f();
    pub fn g() {}
}

pub unsafe impl<'a, 'b, X, Y: Foo<Bar>> !Foo<'a, X> for Bar<'b, Y> where X: Foo<'a, Z> {
    fn foo() { "hi" }    
}

impl<'a, 'b, X, Y: Foo<Bar>> Foo<'a, X> for Bar<'b, Y> where X: Fooooooooooooooooooooooooooooo<'a, Z>
{
    fn foo() { "hi" }    
}

impl<'a, 'b, X, Y: Foo<Bar>> Foo<'a, X> for Bar<'b, Y> where X: Foooooooooooooooooooooooooooo<'a, Z>
{
    fn foo() { "hi" }    
}

impl<T> Foo for Bar<T> where T: Baz 
{
}

impl<T> Foo for Bar<T> where T: Baz { /* Comment */ }

impl Foo {
    fn foo() {}
}

impl Boo {

    // BOO
    fn boo() {}
    // FOO

    
    
}

mod a {
    impl Foo {
        // Hello!
        fn foo() {}
    }
}


mod b {
    mod a {
        impl Foo {
            fn foo() {}
        }
    }
}

impl Foo { add_fun!(); }

impl Blah {
    fn boop() {}
    add_fun!();
}

impl X { fn do_parse(  mut  self : X ) {} }

impl Y5000 {
    fn bar(self: X< 'a ,  'b >, y: Y) {}

    fn bad(&self, ( x, y): CoorT) {}

    fn turbo_bad(self: X< 'a ,  'b >  , ( x, y): CoorT) {
        
    }
}

pub impl<T> Foo for Bar<T> where T: Foo
{
    fn foo() { "hi" }
}

pub impl<T, Z> Foo for Bar<T, Z> where T: Foo, Z: Baz {}

mod m {
    impl<T> PartialEq for S<T> where T: PartialEq {
        fn eq(&self, other: &Self) {
            true
        }
      }

        impl<T> PartialEq for S<T> where T: PartialEq {      }
 }

impl<BorrowType, K, V, NodeType, HandleType> Handle<NodeRef<BorrowType, K, V, NodeType>, HandleType> {
}

impl<BorrowType, K, V, NodeType, HandleType> PartialEq for Handle<NodeRef<BorrowType, K, V, NodeType>, HandleType> {
}

mod x {
    impl<A, B, C, D> Foo
        where A: 'static,
              B: 'static,
              C: 'static,
              D: 'static { }
}

impl<ConcreteThreadSafeLayoutNode: ThreadSafeLayoutNodeFoo> Issue1249<ConcreteThreadSafeLayoutNode> {
    // Creates a new flow constructor.
   fn foo() {}
}

// #1600
impl<#[may_dangle] K, #[may_dangle] V> Drop for RawTable<K, V> {
    fn drop() {}
}

// #1168
pub trait Number: Copy + Eq +      Not<Output = Self> + Shl<u8, Output = Self> +
    Shr<u8, Output = Self>       +
    BitAnd<Self, Output=Self> +    BitOr<Self, Output=Self>  + BitAndAssign + BitOrAssign



{
    // test
    fn zero() -> Self;
}

// #1642
pub trait SomeTrait : Clone + Eq + PartialEq + Ord + PartialOrd + Default + Hash + Debug + Display + Write + Read + FromStr {
    // comment
}

// #1995
impl Foo {
    fn f(
		    S {
			      aaaaaaaaaa: aaaaaaaaaa,
			      bbbbbbbbbb: bbbbbbbbbb,
			      cccccccccc: cccccccccc,
		    }: S
    ) -> u32{
        1
    }
}

// #2491
impl<'a, 'b, 'c> SomeThing<Something> for (&'a mut SomethingLong, &'b mut SomethingLong, &'c mut SomethingLong) {
    fn foo() {}
}

// #2746
impl<'seq1, 'seq2, 'body, 'scope, Channel> Adc12< Dual, MasterRunningDma<'seq1, 'body, 'scope, Channel>, SlaveRunningDma<'seq2, 'body, 'scope>, > where Channel: DmaChannel, {}

// #4084
impl     const       std::default::Default for Struct {
    #[inline]
    fn default() -> Self {
        Self { f: 12.5 }
    }
}