error: method `eq` can be confused for the standard trait method `std::cmp::PartialEq::eq`
  --> $DIR/method_list_2.rs:27:5
   |
LL | /     pub fn eq(&self, other: &Self) -> bool {
LL | |         unimplemented!()
LL | |     }
   | |_____^
   |
   = note: `-D clippy::should-implement-trait` implied by `-D warnings`
   = help: consider implementing the trait `std::cmp::PartialEq` or choosing a less ambiguous method name

error: method `from_iter` can be confused for the standard trait method `std::iter::FromIterator::from_iter`
  --> $DIR/method_list_2.rs:31:5
   |
LL | /     pub fn from_iter<T>(iter: T) -> Self {
LL | |         unimplemented!()
LL | |     }
   | |_____^
   |
   = help: consider implementing the trait `std::iter::FromIterator` or choosing a less ambiguous method name

error: method `from_str` can be confused for the standard trait method `std::str::FromStr::from_str`
  --> $DIR/method_list_2.rs:35:5
   |
LL | /     pub fn from_str(s: &str) -> Result<Self, Self> {
LL | |         unimplemented!()
LL | |     }
   | |_____^
   |
   = help: consider implementing the trait `std::str::FromStr` or choosing a less ambiguous method name

error: method `hash` can be confused for the standard trait method `std::hash::Hash::hash`
  --> $DIR/method_list_2.rs:39:5
   |
LL | /     pub fn hash(&self, state: &mut T) {
LL | |         unimplemented!()
LL | |     }
   | |_____^
   |
   = help: consider implementing the trait `std::hash::Hash` or choosing a less ambiguous method name

error: method `index` can be confused for the standard trait method `std::ops::Index::index`
  --> $DIR/method_list_2.rs:43:5
   |
LL | /     pub fn index(&self, index: usize) -> &Self {
LL | |         unimplemented!()
LL | |     }
   | |_____^
   |
   = help: consider implementing the trait `std::ops::Index` or choosing a less ambiguous method name

error: method `index_mut` can be confused for the standard trait method `std::ops::IndexMut::index_mut`
  --> $DIR/method_list_2.rs:47:5
   |
LL | /     pub fn index_mut(&mut self, index: usize) -> &mut Self {
LL | |         unimplemented!()
LL | |     }
   | |_____^
   |
   = help: consider implementing the trait `std::ops::IndexMut` or choosing a less ambiguous method name

error: method `into_iter` can be confused for the standard trait method `std::iter::IntoIterator::into_iter`
  --> $DIR/method_list_2.rs:51:5
   |
LL | /     pub fn into_iter(self) -> Self {
LL | |         unimplemented!()
LL | |     }
   | |_____^
   |
   = help: consider implementing the trait `std::iter::IntoIterator` or choosing a less ambiguous method name

error: method `mul` can be confused for the standard trait method `std::ops::Mul::mul`
  --> $DIR/method_list_2.rs:55:5
   |
LL | /     pub fn mul(self, rhs: Self) -> Self {
LL | |         unimplemented!()
LL | |     }
   | |_____^
   |
   = help: consider implementing the trait `std::ops::Mul` or choosing a less ambiguous method name

error: method `neg` can be confused for the standard trait method `std::ops::Neg::neg`
  --> $DIR/method_list_2.rs:59:5
   |
LL | /     pub fn neg(self) -> Self {
LL | |         unimplemented!()
LL | |     }
   | |_____^
   |
   = help: consider implementing the trait `std::ops::Neg` or choosing a less ambiguous method name

error: method `next` can be confused for the standard trait method `std::iter::Iterator::next`
  --> $DIR/method_list_2.rs:63:5
   |
LL | /     pub fn next(&mut self) -> Option<Self> {
LL | |         unimplemented!()
LL | |     }
   | |_____^
   |
   = help: consider implementing the trait `std::iter::Iterator` or choosing a less ambiguous method name

error: method `not` can be confused for the standard trait method `std::ops::Not::not`
  --> $DIR/method_list_2.rs:67:5
   |
LL | /     pub fn not(self) -> Self {
LL | |         unimplemented!()
LL | |     }
   | |_____^
   |
   = help: consider implementing the trait `std::ops::Not` or choosing a less ambiguous method name

error: method `rem` can be confused for the standard trait method `std::ops::Rem::rem`
  --> $DIR/method_list_2.rs:71:5
   |
LL | /     pub fn rem(self, rhs: Self) -> Self {
LL | |         unimplemented!()
LL | |     }
   | |_____^
   |
   = help: consider implementing the trait `std::ops::Rem` or choosing a less ambiguous method name

error: method `shl` can be confused for the standard trait method `std::ops::Shl::shl`
  --> $DIR/method_list_2.rs:75:5
   |
LL | /     pub fn shl(self, rhs: Self) -> Self {
LL | |         unimplemented!()
LL | |     }
   | |_____^
   |
   = help: consider implementing the trait `std::ops::Shl` or choosing a less ambiguous method name

error: method `shr` can be confused for the standard trait method `std::ops::Shr::shr`
  --> $DIR/method_list_2.rs:79:5
   |
LL | /     pub fn shr(self, rhs: Self) -> Self {
LL | |         unimplemented!()
LL | |     }
   | |_____^
   |
   = help: consider implementing the trait `std::ops::Shr` or choosing a less ambiguous method name

error: method `sub` can be confused for the standard trait method `std::ops::Sub::sub`
  --> $DIR/method_list_2.rs:83:5
   |
LL | /     pub fn sub(self, rhs: Self) -> Self {
LL | |         unimplemented!()
LL | |     }
   | |_____^
   |
   = help: consider implementing the trait `std::ops::Sub` or choosing a less ambiguous method name

error: aborting due to 15 previous errors

