new lint: unnecessary `ref` in match pattern

What it does

Detects unnecessary usage of ref in match patterns, for example, making the changes in this diff:

diff --git a/spinoso-time/src/time/tzrs/error.rs b/spinoso-time/src/time/tzrs/error.rs
index ad12b461b1..406d9ef636 100644
--- a/spinoso-time/src/time/tzrs/error.rs
+++ b/spinoso-time/src/time/tzrs/error.rs
@@ -62,12 +62,12 @@ impl PartialEq for TimeError {
 impl error::Error for TimeError {
     fn source(&self) -> Option<&(dyn error::Error + 'static)> {
         match self {
-            Self::ProjectionError(ref err) => Some(err),
-            Self::ComponentOutOfRangeError(ref err) => Some(err),
-            Self::UnknownTzError(ref err) => Some(err),
-            Self::TzStringError(ref err) => Some(err),
-            Self::TzOutOfRangeError(ref err) => Some(err),
-            Self::IntOverflowError(ref err) => Some(err),
+            Self::ProjectionError(err) => Some(err),
+            Self::ComponentOutOfRangeError(err) => Some(err),
+            Self::UnknownTzError(err) => Some(err),
+            Self::TzStringError(err) => Some(err),
+            Self::TzOutOfRangeError(err) => Some(err),
+            Self::IntOverflowError(err) => Some(err),
             Self::Unknown => None,
         }
     }
@@ -79,8 +79,8 @@ impl fmt::Display for TimeError {
             Self::ProjectionError(error) => error.fmt(f),
             Self::ComponentOutOfRangeError(error) => error.fmt(f),
             Self::UnknownTzError(error) => error.fmt(f),
-            Self::TzStringError(ref error) => error.fmt(f),
-            Self::TzOutOfRangeError(ref error) => error.fmt(f),
+            Self::TzStringError(error) => error.fmt(f),
+            Self::TzOutOfRangeError(error) => error.fmt(f),
             Self::IntOverflowError(error) => error.fmt(f),
             Self::Unknown => write!(f, "An unknown error occurred"),
         }

https://github.com/artichoke/artichoke/pull/2192

Lint Name

unnecessary_ref_pattern

Category

style, complexity

Advantage

• Removes unnecessary syntax.
• Removes autoref / autoderef behavior.
• Ensures consistency of patterns in a match expression.

Drawbacks

No response

Example

use core::fmt;
use core::num::TryFromIntError;
use std::error;
use std::str::Utf8Error;

use tz::error::{DateTimeError, ProjectDateTimeError, TzError};

/// A wrapper around some of the errors provided by `tz-rs`.
#[derive(Debug)]
pub enum TimeError {
    ProjectionError(ProjectDateTimeError),
    ComponentOutOfRangeError(DateTimeError),
    UnknownTzError(TzError),
    TzStringError(TzStringError),
    TzOutOfRangeError(TzOutOfRangeError),
    IntOverflowError(IntOverflowError),
    Unknown,
}

impl error::Error for TimeError {
    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
        match self {
            Self::ProjectionError(ref err) => Some(err),
            Self::ComponentOutOfRangeError(ref err) => Some(err),
            Self::UnknownTzError(ref err) => Some(err),
            Self::TzStringError(ref err) => Some(err),
            Self::TzOutOfRangeError(ref err) => Some(err),
            Self::IntOverflowError(ref err) => Some(err),
            Self::Unknown => None,
        }
    }
}

impl fmt::Display for TimeError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::ProjectionError(error) => error.fmt(f),
            Self::ComponentOutOfRangeError(error) => error.fmt(f),
            Self::UnknownTzError(error) => error.fmt(f),
            Self::TzStringError(ref error) => error.fmt(f),
            Self::TzOutOfRangeError(ref error) => error.fmt(f),
            Self::IntOverflowError(error) => error.fmt(f),
            Self::Unknown => write!(f, "An unknown error occurred"),
        }
    }
}

Could be written as:

use core::fmt;
use core::num::TryFromIntError;
use std::error;
use std::str::Utf8Error;

use tz::error::{DateTimeError, ProjectDateTimeError, TzError};

/// A wrapper around some of the errors provided by `tz-rs`.
#[derive(Debug)]
pub enum TimeError {
    ProjectionError(ProjectDateTimeError),
    ComponentOutOfRangeError(DateTimeError),
    UnknownTzError(TzError),
    TzStringError(TzStringError),
    TzOutOfRangeError(TzOutOfRangeError),
    IntOverflowError(IntOverflowError),
    Unknown,
}

impl error::Error for TimeError {
    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
        match self {
            Self::ProjectionError(err) => Some(err),
            Self::ComponentOutOfRangeError(err) => Some(err),
            Self::UnknownTzError(err) => Some(err),
            Self::TzStringError(err) => Some(err),
            Self::TzOutOfRangeError(err) => Some(err),
            Self::IntOverflowError(err) => Some(err),
            Self::Unknown => None,
        }
    }
}

impl fmt::Display for TimeError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::ProjectionError(error) => error.fmt(f),
            Self::ComponentOutOfRangeError(error) => error.fmt(f),
            Self::UnknownTzError(error) => error.fmt(f),
            Self::TzStringError(error) => error.fmt(f),
            Self::TzOutOfRangeError(error) => error.fmt(f),
            Self::IntOverflowError(error) => error.fmt(f),
            Self::Unknown => write!(f, "An unknown error occurred"),
        }
    }
}

Start by reading the unnecessary_ref_pattern proposal and the example in spinoso-time/src/time/tzrs/error.rs, along with the linked pull request #2192. Implement the lint named unnecessary_ref_pattern and verify it detects the shown unnecessary ref patterns without flagging already-correct patterns.