Update all the code to pass the updated use_self lint.

jakubadamw · jakubadamw · commit 2a13e83f2baa · 2019-07-31T08:50:43.000Z
One struct required a temporary `#[allow(dead_code)]` annotation due to a bug in the Rust compiler: rust-lang/rust#63151.
diff --git a/clippy_dev/src/fmt.rs b/clippy_dev/src/fmt.rs
@@ -15,13 +15,13 @@ pub enum CliError {
 
 impl From<io::Error> for CliError {
     fn from(error: io::Error) -> Self {
-        CliError::IoError(error)
+        Self::IoError(error)
     }
 }
 
 impl From<walkdir::Error> for CliError {
     fn from(error: walkdir::Error) -> Self {
-        CliError::WalkDirError(error)
+        Self::WalkDirError(error)
     }
 }
 
diff --git a/clippy_lints/src/checked_conversions.rs b/clippy_lints/src/checked_conversions.rs
@@ -160,12 +160,12 @@ impl ConversionType {
     /// Creates a conversion type if the type is allowed & conversion is valid
     fn try_new(from: &str, to: &str) -> Option<Self> {
         if UINTS.contains(&from) {
-            Some(ConversionType::FromUnsigned)
+            Some(Self::FromUnsigned)
         } else if SINTS.contains(&from) {
             if UINTS.contains(&to) {
-                Some(ConversionType::SignedToUnsigned)
+                Some(Self::SignedToUnsigned)
             } else if SINTS.contains(&to) {
-                Some(ConversionType::SignedToSigned)
+                Some(Self::SignedToSigned)
             } else {
                 None
             }
diff --git a/clippy_lints/src/consts.rs b/clippy_lints/src/consts.rs
@@ -48,27 +48,27 @@ pub enum Constant {
 impl PartialEq for Constant {
     fn eq(&self, other: &Self) -> bool {
         match (self, other) {
-            (&Constant::Str(ref ls), &Constant::Str(ref rs)) => ls == rs,
-            (&Constant::Binary(ref l), &Constant::Binary(ref r)) => l == r,
-            (&Constant::Char(l), &Constant::Char(r)) => l == r,
-            (&Constant::Int(l), &Constant::Int(r)) => l == r,
-            (&Constant::F64(l), &Constant::F64(r)) => {
+            (&Self::Str(ref ls), &Self::Str(ref rs)) => ls == rs,
+            (&Self::Binary(ref l), &Self::Binary(ref r)) => l == r,
+            (&Self::Char(l), &Self::Char(r)) => l == r,
+            (&Self::Int(l), &Self::Int(r)) => l == r,
+            (&Self::F64(l), &Self::F64(r)) => {
                 // We want `Fw32 == FwAny` and `FwAny == Fw64`, and by transitivity we must have
                 // `Fw32 == Fw64`, so don’t compare them.
                 // `to_bits` is required to catch non-matching 0.0, -0.0, and NaNs.
                 l.to_bits() == r.to_bits()
             },
-            (&Constant::F32(l), &Constant::F32(r)) => {
+            (&Self::F32(l), &Self::F32(r)) => {
                 // We want `Fw32 == FwAny` and `FwAny == Fw64`, and by transitivity we must have
                 // `Fw32 == Fw64`, so don’t compare them.
                 // `to_bits` is required to catch non-matching 0.0, -0.0, and NaNs.
                 f64::from(l).to_bits() == f64::from(r).to_bits()
             },
-            (&Constant::Bool(l), &Constant::Bool(r)) => l == r,
-            (&Constant::Vec(ref l), &Constant::Vec(ref r)) | (&Constant::Tuple(ref l), &Constant::Tuple(ref r)) => {
+            (&Self::Bool(l), &Self::Bool(r)) => l == r,
+            (&Self::Vec(ref l), &Self::Vec(ref r)) | (&Self::Tuple(ref l), &Self::Tuple(ref r)) => {
                 l == r
             },
-            (&Constant::Repeat(ref lv, ref ls), &Constant::Repeat(ref rv, ref rs)) => ls == rs && lv == rv,
+            (&Self::Repeat(ref lv, ref ls), &Self::Repeat(ref rv, ref rs)) => ls == rs && lv == rv,
             // TODO: are there inter-type equalities?
             _ => false,
         }
@@ -82,38 +82,38 @@ impl Hash for Constant {
     {
         std::mem::discriminant(self).hash(state);
         match *self {
-            Constant::Str(ref s) => {
+            Self::Str(ref s) => {
                 s.hash(state);
             },
-            Constant::Binary(ref b) => {
+            Self::Binary(ref b) => {
                 b.hash(state);
             },
-            Constant::Char(c) => {
+            Self::Char(c) => {
                 c.hash(state);
             },
-            Constant::Int(i) => {
+            Self::Int(i) => {
                 i.hash(state);
             },
-            Constant::F32(f) => {
+            Self::F32(f) => {
                 f64::from(f).to_bits().hash(state);
             },
-            Constant::F64(f) => {
+            Self::F64(f) => {
                 f.to_bits().hash(state);
             },
-            Constant::Bool(b) => {
+            Self::Bool(b) => {
                 b.hash(state);
             },
-            Constant::Vec(ref v) | Constant::Tuple(ref v) => {
+            Self::Vec(ref v) | Self::Tuple(ref v) => {
                 v.hash(state);
             },
-            Constant::Repeat(ref c, l) => {
+            Self::Repeat(ref c, l) => {
                 c.hash(state);
                 l.hash(state);
             },
-            Constant::RawPtr(u) => {
+            Self::RawPtr(u) => {
                 u.hash(state);
             },
-            Constant::Err(ref s) => {
+            Self::Err(ref s) => {
                 s.hash(state);
             },
         }
@@ -123,25 +123,25 @@ impl Hash for Constant {
 impl Constant {
     pub fn partial_cmp(tcx: TyCtxt<'_>, cmp_type: Ty<'_>, left: &Self, right: &Self) -> Option<Ordering> {
         match (left, right) {
-            (&Constant::Str(ref ls), &Constant::Str(ref rs)) => Some(ls.cmp(rs)),
-            (&Constant::Char(ref l), &Constant::Char(ref r)) => Some(l.cmp(r)),
-            (&Constant::Int(l), &Constant::Int(r)) => {
+            (&Self::Str(ref ls), &Self::Str(ref rs)) => Some(ls.cmp(rs)),
+            (&Self::Char(ref l), &Self::Char(ref r)) => Some(l.cmp(r)),
+            (&Self::Int(l), &Self::Int(r)) => {
                 if let ty::Int(int_ty) = cmp_type.sty {
                     Some(sext(tcx, l, int_ty).cmp(&sext(tcx, r, int_ty)))
                 } else {
                     Some(l.cmp(&r))
                 }
             },
-            (&Constant::F64(l), &Constant::F64(r)) => l.partial_cmp(&r),
-            (&Constant::F32(l), &Constant::F32(r)) => l.partial_cmp(&r),
-            (&Constant::Bool(ref l), &Constant::Bool(ref r)) => Some(l.cmp(r)),
-            (&Constant::Tuple(ref l), &Constant::Tuple(ref r)) | (&Constant::Vec(ref l), &Constant::Vec(ref r)) => l
+            (&Self::F64(l), &Self::F64(r)) => l.partial_cmp(&r),
+            (&Self::F32(l), &Self::F32(r)) => l.partial_cmp(&r),
+            (&Self::Bool(ref l), &Self::Bool(ref r)) => Some(l.cmp(r)),
+            (&Self::Tuple(ref l), &Self::Tuple(ref r)) | (&Self::Vec(ref l), &Self::Vec(ref r)) => l
                 .iter()
                 .zip(r.iter())
                 .map(|(li, ri)| Self::partial_cmp(tcx, cmp_type, li, ri))
                 .find(|r| r.map_or(true, |o| o != Ordering::Equal))
                 .unwrap_or_else(|| Some(l.len().cmp(&r.len()))),
-            (&Constant::Repeat(ref lv, ref ls), &Constant::Repeat(ref rv, ref rs)) => {
+            (&Self::Repeat(ref lv, ref ls), &Self::Repeat(ref rv, ref rs)) => {
                 match Self::partial_cmp(tcx, cmp_type, lv, rv) {
                     Some(Equal) => Some(ls.cmp(rs)),
                     x => x,
diff --git a/clippy_lints/src/excessive_precision.rs b/clippy_lints/src/excessive_precision.rs
@@ -143,20 +143,20 @@ impl FloatFormat {
     fn new(s: &str) -> Self {
         s.chars()
             .find_map(|x| match x {
-                'e' => Some(FloatFormat::LowerExp),
-                'E' => Some(FloatFormat::UpperExp),
+                'e' => Some(Self::LowerExp),
+                'E' => Some(Self::UpperExp),
                 _ => None,
             })
-            .unwrap_or(FloatFormat::Normal)
+            .unwrap_or(Self::Normal)
     }
     fn format<T>(&self, f: T) -> String
     where
         T: fmt::UpperExp + fmt::LowerExp + fmt::Display,
     {
         match self {
-            FloatFormat::LowerExp => format!("{:e}", f),
-            FloatFormat::UpperExp => format!("{:E}", f),
-            FloatFormat::Normal => format!("{}", f),
+            Self::LowerExp => format!("{:e}", f),
+            Self::UpperExp => format!("{:E}", f),
+            Self::Normal => format!("{}", f),
         }
     }
 }
diff --git a/clippy_lints/src/literal_representation.rs b/clippy_lints/src/literal_representation.rs
@@ -115,8 +115,8 @@ impl Radix {
     /// Returns a reasonable digit group size for this radix.
     crate fn suggest_grouping(&self) -> usize {
         match *self {
-            Radix::Binary | Radix::Hexadecimal => 4,
-            Radix::Octal | Radix::Decimal => 3,
+            Self::Binary | Self::Hexadecimal => 4,
+            Self::Octal | Self::Decimal => 3,
         }
     }
 }
@@ -285,7 +285,7 @@ enum WarningType {
 impl WarningType {
     crate fn display(&self, grouping_hint: &str, cx: &EarlyContext<'_>, span: syntax_pos::Span) {
         match self {
-            WarningType::MistypedLiteralSuffix => span_lint_and_sugg(
+            Self::MistypedLiteralSuffix => span_lint_and_sugg(
                 cx,
                 MISTYPED_LITERAL_SUFFIXES,
                 span,
@@ -294,7 +294,7 @@ impl WarningType {
                 grouping_hint.to_string(),
                 Applicability::MaybeIncorrect,
             ),
-            WarningType::UnreadableLiteral => span_lint_and_sugg(
+            Self::UnreadableLiteral => span_lint_and_sugg(
                 cx,
                 UNREADABLE_LITERAL,
                 span,
@@ -303,7 +303,7 @@ impl WarningType {
                 grouping_hint.to_owned(),
                 Applicability::MachineApplicable,
             ),
-            WarningType::LargeDigitGroups => span_lint_and_sugg(
+            Self::LargeDigitGroups => span_lint_and_sugg(
                 cx,
                 LARGE_DIGIT_GROUPS,
                 span,
@@ -312,7 +312,7 @@ impl WarningType {
                 grouping_hint.to_owned(),
                 Applicability::MachineApplicable,
             ),
-            WarningType::InconsistentDigitGrouping => span_lint_and_sugg(
+            Self::InconsistentDigitGrouping => span_lint_and_sugg(
                 cx,
                 INCONSISTENT_DIGIT_GROUPING,
                 span,
@@ -321,7 +321,7 @@ impl WarningType {
                 grouping_hint.to_owned(),
                 Applicability::MachineApplicable,
             ),
-            WarningType::DecimalRepresentation => span_lint_and_sugg(
+            Self::DecimalRepresentation => span_lint_and_sugg(
                 cx,
                 DECIMAL_LITERAL_REPRESENTATION,
                 span,
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
@@ -2505,14 +2505,14 @@ impl SelfKind {
         let is_actually_self = |ty| is_self_ty(ty) || SpanlessEq::new(cx).eq_ty(ty, self_ty);
         if is_self(arg) {
             match self {
-                SelfKind::Value => is_actually_self(ty),
-                SelfKind::Ref | SelfKind::RefMut => {
+                Self::Value => is_actually_self(ty),
+                Self::Ref | Self::RefMut => {
                     if allow_value_for_ref && is_actually_self(ty) {
                         return true;
                     }
                     match ty.node {
                         hir::TyKind::Rptr(_, ref mt_ty) => {
-                            let mutability_match = if self == SelfKind::Ref {
+                            let mutability_match = if self == Self::Ref {
                                 mt_ty.mutbl == hir::MutImmutable
                             } else {
                                 mt_ty.mutbl == hir::MutMutable
@@ -2526,20 +2526,20 @@ impl SelfKind {
             }
         } else {
             match self {
-                SelfKind::Value => false,
-                SelfKind::Ref => is_as_ref_or_mut_trait(ty, self_ty, generics, &paths::ASREF_TRAIT),
-                SelfKind::RefMut => is_as_ref_or_mut_trait(ty, self_ty, generics, &paths::ASMUT_TRAIT),
-                SelfKind::No => true,
+                Self::Value => false,
+                Self::Ref => is_as_ref_or_mut_trait(ty, self_ty, generics, &paths::ASREF_TRAIT),
+                Self::RefMut => is_as_ref_or_mut_trait(ty, self_ty, generics, &paths::ASMUT_TRAIT),
+                Self::No => true,
             }
         }
     }
 
     fn description(self) -> &'static str {
         match self {
-            SelfKind::Value => "self by value",
-            SelfKind::Ref => "self by reference",
-            SelfKind::RefMut => "self by mutable reference",
-            SelfKind::No => "no self",
+            Self::Value => "self by value",
+            Self::Ref => "self by reference",
+            Self::RefMut => "self by mutable reference",
+            Self::No => "no self",
         }
     }
 }
@@ -2609,17 +2609,17 @@ fn single_segment_ty(ty: &hir::Ty) -> Option<&hir::PathSegment> {
 impl Convention {
     fn check(&self, other: &str) -> bool {
         match *self {
-            Convention::Eq(this) => this == other,
-            Convention::StartsWith(this) => other.starts_with(this) && this != other,
+            Self::Eq(this) => this == other,
+            Self::StartsWith(this) => other.starts_with(this) && this != other,
         }
     }
 }
 
 impl fmt::Display for Convention {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
         match *self {
-            Convention::Eq(this) => this.fmt(f),
-            Convention::StartsWith(this) => this.fmt(f).and_then(|_| '*'.fmt(f)),
+            Self::Eq(this) => this.fmt(f),
+            Self::StartsWith(this) => this.fmt(f).and_then(|_| '*'.fmt(f)),
         }
     }
 }
@@ -2636,11 +2636,11 @@ impl OutType {
     fn matches(self, cx: &LateContext<'_, '_>, ty: &hir::FunctionRetTy) -> bool {
         let is_unit = |ty: &hir::Ty| SpanlessEq::new(cx).eq_ty_kind(&ty.node, &hir::TyKind::Tup(vec![].into()));
         match (self, ty) {
-            (OutType::Unit, &hir::DefaultReturn(_)) => true,
-            (OutType::Unit, &hir::Return(ref ty)) if is_unit(ty) => true,
-            (OutType::Bool, &hir::Return(ref ty)) if is_bool(ty) => true,
-            (OutType::Any, &hir::Return(ref ty)) if !is_unit(ty) => true,
-            (OutType::Ref, &hir::Return(ref ty)) => matches!(ty.node, hir::TyKind::Rptr(_, _)),
+            (Self::Unit, &hir::DefaultReturn(_)) => true,
+            (Self::Unit, &hir::Return(ref ty)) if is_unit(ty) => true,
+            (Self::Bool, &hir::Return(ref ty)) if is_bool(ty) => true,
+            (Self::Any, &hir::Return(ref ty)) if !is_unit(ty) => true,
+            (Self::Ref, &hir::Return(ref ty)) => matches!(ty.node, hir::TyKind::Rptr(_, _)),
             _ => false,
         }
     }
diff --git a/clippy_lints/src/non_copy_const.rs b/clippy_lints/src/non_copy_const.rs
@@ -84,6 +84,7 @@ declare_clippy_lint! {
     "referencing const with interior mutability"
 }
 
+#[allow(dead_code)]
 #[derive(Copy, Clone)]
 enum Source {
     Item { item: Span },
@@ -94,12 +95,12 @@ enum Source {
 impl Source {
     fn lint(&self) -> (&'static Lint, &'static str, Span) {
         match self {
-            Source::Item { item } | Source::Assoc { item, .. } => (
+            Self::Item { item } | Self::Assoc { item, .. } => (
                 DECLARE_INTERIOR_MUTABLE_CONST,
                 "a const item should never be interior mutable",
                 *item,
             ),
-            Source::Expr { expr } => (
+            Self::Expr { expr } => (
                 BORROW_INTERIOR_MUTABLE_CONST,
                 "a const item with interior mutability should not be borrowed",
                 *expr,
diff --git a/clippy_lints/src/ptr_offset_with_cast.rs b/clippy_lints/src/ptr_offset_with_cast.rs
@@ -133,17 +133,17 @@ enum Method {
 impl Method {
     fn suggestion(self) -> &'static str {
         match self {
-            Method::Offset => "add",
-            Method::WrappingOffset => "wrapping_add",
+            Self::Offset => "add",
+            Self::WrappingOffset => "wrapping_add",
         }
     }
 }
 
 impl fmt::Display for Method {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            Method::Offset => write!(f, "offset"),
-            Method::WrappingOffset => write!(f, "wrapping_offset"),
+            Self::Offset => write!(f, "offset"),
+            Self::WrappingOffset => write!(f, "wrapping_offset"),
         }
     }
 }
diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs
@@ -1725,10 +1725,10 @@ impl PartialEq for FullInt {
 impl PartialOrd for FullInt {
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
         Some(match (self, other) {
-            (&FullInt::S(s), &FullInt::S(o)) => s.cmp(&o),
-            (&FullInt::U(s), &FullInt::U(o)) => s.cmp(&o),
-            (&FullInt::S(s), &FullInt::U(o)) => Self::cmp_s_u(s, o),
-            (&FullInt::U(s), &FullInt::S(o)) => Self::cmp_s_u(o, s).reverse(),
+            (&Self::S(s), &Self::S(o)) => s.cmp(&o),
+            (&Self::U(s), &Self::U(o)) => s.cmp(&o),
+            (&Self::S(s), &Self::U(o)) => Self::cmp_s_u(s, o),
+            (&Self::U(s), &Self::S(o)) => Self::cmp_s_u(o, s).reverse(),
         })
     }
 }
diff --git a/clippy_lints/src/utils/conf.rs b/clippy_lints/src/utils/conf.rs

Original file line number	Diff line number	Diff line change
`@@ -15,13 +15,13 @@ pub enum CliError {`
`15`	`15`
`16`	`16`	`impl From<io::Error> for CliError {`
`17`	`17`	`fn from(error: io::Error) -> Self {`
`18`		`- CliError::IoError(error)`
	`18`	`+ Self::IoError(error)`
`19`	`19`	`}`
`20`	`20`	`}`
`21`	`21`
`22`	`22`	`impl From<walkdir::Error> for CliError {`
`23`	`23`	`fn from(error: walkdir::Error) -> Self {`
`24`		`- CliError::WalkDirError(error)`
	`24`	`+ Self::WalkDirError(error)`
`25`	`25`	`}`
`26`	`26`	`}`
`27`	`27`
Original file line number	Diff line number	Diff line change
`@@ -143,20 +143,20 @@ impl FloatFormat {`
`143`	`143`	`fn new(s: &str) -> Self {`
`144`	`144`	`s.chars()`
`145`	`145`	`.find_map(\|x\| match x {`
`146`		`- 'e' => Some(FloatFormat::LowerExp),`
`147`		`- 'E' => Some(FloatFormat::UpperExp),`
	`146`	`+ 'e' => Some(Self::LowerExp),`
	`147`	`+ 'E' => Some(Self::UpperExp),`
`148`	`148`	`_ => None,`
`149`	`149`	`})`
`150`		`- .unwrap_or(FloatFormat::Normal)`
	`150`	`+ .unwrap_or(Self::Normal)`
`151`	`151`	`}`
`152`	`152`	`fn format<T>(&self, f: T) -> String`
`153`	`153`	`where`
`154`	`154`	`T: fmt::UpperExp + fmt::LowerExp + fmt::Display,`
`155`	`155`	`{`
`156`	`156`	`match self {`
`157`		`- FloatFormat::LowerExp => format!("{:e}", f),`
`158`		`- FloatFormat::UpperExp => format!("{:E}", f),`
`159`		`- FloatFormat::Normal => format!("{}", f),`
	`157`	`+ Self::LowerExp => format!("{:e}", f),`
	`158`	`+ Self::UpperExp => format!("{:E}", f),`
	`159`	`+ Self::Normal => format!("{}", f),`
`160`	`160`	`}`
`161`	`161`	`}`
`162`	`162`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2505,14 +2505,14 @@ impl SelfKind {`
`2505`	`2505`	`let is_actually_self = \|ty\| is_self_ty(ty) \|\| SpanlessEq::new(cx).eq_ty(ty, self_ty);`
`2506`	`2506`	`if is_self(arg) {`
`2507`	`2507`	`match self {`
`2508`		`- SelfKind::Value => is_actually_self(ty),`
`2509`		`- SelfKind::Ref \| SelfKind::RefMut => {`
	`2508`	`+ Self::Value => is_actually_self(ty),`
	`2509`	`+ Self::Ref \| Self::RefMut => {`
`2510`	`2510`	`if allow_value_for_ref && is_actually_self(ty) {`
`2511`	`2511`	`return true;`
`2512`	`2512`	`}`
`2513`	`2513`	`match ty.node {`
`2514`	`2514`	`hir::TyKind::Rptr(_, ref mt_ty) => {`
`2515`		`- let mutability_match = if self == SelfKind::Ref {`
	`2515`	`+ let mutability_match = if self == Self::Ref {`
`2516`	`2516`	`mt_ty.mutbl == hir::MutImmutable`
`2517`	`2517`	`} else {`
`2518`	`2518`	`mt_ty.mutbl == hir::MutMutable`
`@@ -2526,20 +2526,20 @@ impl SelfKind {`
`2526`	`2526`	`}`
`2527`	`2527`	`} else {`
`2528`	`2528`	`match self {`
`2529`		`- SelfKind::Value => false,`
`2530`		`- SelfKind::Ref => is_as_ref_or_mut_trait(ty, self_ty, generics, &paths::ASREF_TRAIT),`
`2531`		`- SelfKind::RefMut => is_as_ref_or_mut_trait(ty, self_ty, generics, &paths::ASMUT_TRAIT),`
`2532`		`- SelfKind::No => true,`
	`2529`	`+ Self::Value => false,`
	`2530`	`+ Self::Ref => is_as_ref_or_mut_trait(ty, self_ty, generics, &paths::ASREF_TRAIT),`
	`2531`	`+ Self::RefMut => is_as_ref_or_mut_trait(ty, self_ty, generics, &paths::ASMUT_TRAIT),`
	`2532`	`+ Self::No => true,`
`2533`	`2533`	`}`
`2534`	`2534`	`}`
`2535`	`2535`	`}`
`2536`	`2536`
`2537`	`2537`	`fn description(self) -> &'static str {`
`2538`	`2538`	`match self {`
`2539`		`- SelfKind::Value => "self by value",`
`2540`		`- SelfKind::Ref => "self by reference",`
`2541`		`- SelfKind::RefMut => "self by mutable reference",`
`2542`		`- SelfKind::No => "no self",`
	`2539`	`+ Self::Value => "self by value",`
	`2540`	`+ Self::Ref => "self by reference",`
	`2541`	`+ Self::RefMut => "self by mutable reference",`
	`2542`	`+ Self::No => "no self",`
`2543`	`2543`	`}`
`2544`	`2544`	`}`
`2545`	`2545`	`}`
`@@ -2609,17 +2609,17 @@ fn single_segment_ty(ty: &hir::Ty) -> Option<&hir::PathSegment> {`
`2609`	`2609`	`impl Convention {`
`2610`	`2610`	`fn check(&self, other: &str) -> bool {`
`2611`	`2611`	`match *self {`
`2612`		`- Convention::Eq(this) => this == other,`
`2613`		`- Convention::StartsWith(this) => other.starts_with(this) && this != other,`
	`2612`	`+ Self::Eq(this) => this == other,`
	`2613`	`+ Self::StartsWith(this) => other.starts_with(this) && this != other,`
`2614`	`2614`	`}`
`2615`	`2615`	`}`
`2616`	`2616`	`}`
`2617`	`2617`
`2618`	`2618`	`impl fmt::Display for Convention {`
`2619`	`2619`	`fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {`
`2620`	`2620`	`match *self {`
`2621`		`- Convention::Eq(this) => this.fmt(f),`
`2622`		`- Convention::StartsWith(this) => this.fmt(f).and_then(\|_\| '*'.fmt(f)),`
	`2621`	`+ Self::Eq(this) => this.fmt(f),`
	`2622`	`+ Self::StartsWith(this) => this.fmt(f).and_then(\|_\| '*'.fmt(f)),`
`2623`	`2623`	`}`
`2624`	`2624`	`}`
`2625`	`2625`	`}`
`@@ -2636,11 +2636,11 @@ impl OutType {`
`2636`	`2636`	`fn matches(self, cx: &LateContext<'_, '_>, ty: &hir::FunctionRetTy) -> bool {`
`2637`	`2637`	`let is_unit = \|ty: &hir::Ty\| SpanlessEq::new(cx).eq_ty_kind(&ty.node, &hir::TyKind::Tup(vec![].into()));`
`2638`	`2638`	`match (self, ty) {`
`2639`		`- (OutType::Unit, &hir::DefaultReturn(_)) => true,`
`2640`		`- (OutType::Unit, &hir::Return(ref ty)) if is_unit(ty) => true,`
`2641`		`- (OutType::Bool, &hir::Return(ref ty)) if is_bool(ty) => true,`
`2642`		`- (OutType::Any, &hir::Return(ref ty)) if !is_unit(ty) => true,`
`2643`		`- (OutType::Ref, &hir::Return(ref ty)) => matches!(ty.node, hir::TyKind::Rptr(_, _)),`
	`2639`	`+ (Self::Unit, &hir::DefaultReturn(_)) => true,`
	`2640`	`+ (Self::Unit, &hir::Return(ref ty)) if is_unit(ty) => true,`
	`2641`	`+ (Self::Bool, &hir::Return(ref ty)) if is_bool(ty) => true,`
	`2642`	`+ (Self::Any, &hir::Return(ref ty)) if !is_unit(ty) => true,`
	`2643`	`+ (Self::Ref, &hir::Return(ref ty)) => matches!(ty.node, hir::TyKind::Rptr(_, _)),`
`2644`	`2644`	`_ => false,`
`2645`	`2645`	`}`
`2646`	`2646`	`}`
Original file line number	Diff line number	Diff line change
`@@ -133,17 +133,17 @@ enum Method {`
`133`	`133`	`impl Method {`
`134`	`134`	`fn suggestion(self) -> &'static str {`
`135`	`135`	`match self {`
`136`		`- Method::Offset => "add",`
`137`		`- Method::WrappingOffset => "wrapping_add",`
	`136`	`+ Self::Offset => "add",`
	`137`	`+ Self::WrappingOffset => "wrapping_add",`
`138`	`138`	`}`
`139`	`139`	`}`
`140`	`140`	`}`
`141`	`141`
`142`	`142`	`impl fmt::Display for Method {`
`143`	`143`	`fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {`
`144`	`144`	`match self {`
`145`		`- Method::Offset => write!(f, "offset"),`
`146`		`- Method::WrappingOffset => write!(f, "wrapping_offset"),`
	`145`	`+ Self::Offset => write!(f, "offset"),`
	`146`	`+ Self::WrappingOffset => write!(f, "wrapping_offset"),`
`147`	`147`	`}`
`148`	`148`	`}`
`149`	`149`	`}`