Lint for duplicate impl section

[mspiegel]

I'm a novice to rust and noticed recently that I had accidentally created two implementation sections within the same module. Both sections were impl's that did not have a trait declaration:

impl Foobar {
   ...stuff here
}

impl Foobar {
   ...more stuff here
}

It's probably a good practice to warn on duplicate impls or is there something I am not considering?

[Manishearth]

Duplicate impls aren't really an antipattern, but this could be an allow lint

[llogiq]

I see duplicate impls in conjunction with #[cfg(..)]s to unify implementations for different systems. Otherwise I consider them a net loss in readability.

[mcarton]

Different impl sections can have different generic bounds.
I also like to (ab?)use that to make sections in the documentation:

pub struct Foo;

/// # Constructors
impl Foo {
    /// Make a default `Foo`
    pub fn new() -> Foo { … }

    /// Make a `Foo` with some `Bar`
    pub fn with_bar() -> Foo { … }
}

/// # Operations on `Foo`s
impl Foo {
    /// Do something with a `Foo`
    pub fn do_sth(self) { … }
}

looks like this:

But:

pub struct Foo;

impl Foo {
    /// # Constructors
    /// Make a default `Foo`
    pub fn new() -> Foo { … }

    /// Make a `Foo` with some `Bar`
    pub fn with_bar() -> Foo { … }

    /// # Operations on `Foo`s
    /// Do something with a `Foo`
    pub fn do_sth(self) { … }
}

looks like this:

Ok for an allow-by-default lint though.

[camsteffen]

Duplicates #414