#![warn(clippy::missing_trait_methods)]
#![expect(clippy::needless_lifetimes)]
#![allow(clippy::derive_ord_xor_partial_ord)]

trait A {
    fn provided() {}
}

trait B {
    fn required();

    fn a(_: usize) -> usize {
        1
    }

    fn b<'a, T: AsRef<[u8]>>(a: &'a T) -> &'a [u8] {
        a.as_ref()
    }
}

struct Partial;

impl A for Partial {}
//~^ missing_trait_methods

impl B for Partial {
    //~^ missing_trait_methods

    fn required() {}

    fn a(_: usize) -> usize {
        2
    }
}

struct Complete;

impl A for Complete {
    fn provided() {}
}

impl B for Complete {
    fn required() {}

    fn a(_: usize) -> usize {
        2
    }

    fn b<T: AsRef<[u8]>>(a: &T) -> &[u8] {
        a.as_ref()
    }
}

trait MissingMultiple {
    fn one() {}
    fn two() {}
    fn three() {}
}

impl MissingMultiple for Partial {}
//~^ missing_trait_methods
//~| missing_trait_methods
//~| missing_trait_methods

fn main() {}

//~v missing_trait_methods
impl PartialEq<Partial> for Partial {
    fn eq(&self, other: &Partial) -> bool {
        todo!()
    }
}

#[clippy::msrv = "1.20.0"]
fn msrv0() {
    #[derive(PartialEq, Eq, PartialOrd)]
    struct S {}

    impl Ord for S {
        fn cmp(&self, other: &S) -> std::cmp::Ordering {
            unreachable!()
        }
    }
}

#[clippy::msrv = "1.21.0"]
fn msrv1() {
    #[derive(PartialEq, Eq, PartialOrd)]
    struct S {}

    impl Ord for S {
        //~^ missing_trait_methods
        //~| missing_trait_methods
        fn cmp(&self, other: &S) -> std::cmp::Ordering {
            unreachable!()
        }
    }
}