Add lint explicit_auto_deref

Author: Jarcho

CHANGELOG.md

@@ -2063,6 +2063,7 @@ Released 2018-09-13
 [`expect_fun_call`]: https://rust-lang.github.io/rust-clippy/master/index.html#expect_fun_call
 [`expect_used`]: https://rust-lang.github.io/rust-clippy/master/index.html#expect_used
 [`expl_impl_clone_on_copy`]: https://rust-lang.github.io/rust-clippy/master/index.html#expl_impl_clone_on_copy
+[`explicit_auto_deref`]: https://rust-lang.github.io/rust-clippy/master/index.html#explicit_auto_deref
 [`explicit_counter_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#explicit_counter_loop
 [`explicit_deref_methods`]: https://rust-lang.github.io/rust-clippy/master/index.html#explicit_deref_methods
 [`explicit_into_iter_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#explicit_into_iter_loop

clippy_lints/src/dereference.rs

@@ -601,6 +601,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &default::DEFAULT_TRAIT_ACCESS,
         &default::FIELD_REASSIGN_WITH_DEFAULT,
         &default_numeric_fallback::DEFAULT_NUMERIC_FALLBACK,
+        &dereference::EXPLICIT_AUTO_DEREF,
         &dereference::EXPLICIT_DEREF_METHODS,
         &derive::DERIVE_HASH_XOR_EQ,
         &derive::DERIVE_ORD_XOR_PARTIAL_ORD,
@@ -1466,6 +1467,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&copies::IFS_SAME_COND),
         LintId::of(&copies::IF_SAME_THEN_ELSE),
         LintId::of(&default::FIELD_REASSIGN_WITH_DEFAULT),
+        LintId::of(&dereference::EXPLICIT_AUTO_DEREF),
         LintId::of(&derive::DERIVE_HASH_XOR_EQ),
         LintId::of(&derive::DERIVE_ORD_XOR_PARTIAL_ORD),
         LintId::of(&doc::MISSING_SAFETY_DOC),
@@ -1746,6 +1748,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&collapsible_match::COLLAPSIBLE_MATCH),
         LintId::of(&comparison_chain::COMPARISON_CHAIN),
         LintId::of(&default::FIELD_REASSIGN_WITH_DEFAULT),
+        LintId::of(&dereference::EXPLICIT_AUTO_DEREF),
         LintId::of(&doc::MISSING_SAFETY_DOC),
         LintId::of(&doc::NEEDLESS_DOCTEST_MAIN),
         LintId::of(&enum_variants::ENUM_VARIANT_NAMES),

clippy_lints/src/lib.rs

@@ -70,8 +70,10 @@ use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::{LateContext, Level, Lint, LintContext};
 use rustc_middle::hir::exports::Export;
 use rustc_middle::hir::map::Map;
-use rustc_middle::ty::subst::{GenericArg, GenericArgKind};
-use rustc_middle::ty::{self, layout::IntegerExt, DefIdTree, Ty, TyCtxt, TypeFoldable};
+use rustc_middle::ty::subst::{GenericArg, GenericArgKind, Subst};
+use rustc_middle::ty::{
+    self, layout::IntegerExt, Binder, DefIdTree, FnSig, PredicateKind, Ty, TyCtxt, TypeFoldable, TypeckResults,
+};
 use rustc_semver::RustcVersion;
 use rustc_session::Session;
 use rustc_span::hygiene::{self, ExpnKind, MacroKind};
@@ -1763,6 +1765,96 @@ where
     match_expr_list
 }
 
+/// If expr is a path, resolves it. Otherwise returns `None`.
+pub fn expr_res(typeck: &TypeckResults<'_>, expr: &Expr<'_>) -> Option<Res> {
+    if let ExprKind::Path(p) = &expr.kind {
+        Some(typeck.qpath_res(p, expr.hir_id))
+    } else {
+        None
+    }
+}
+
+/// A signature for a function like type.
+pub enum ExprFnSig<'tcx> {
+    Sig(Binder<FnSig<'tcx>>),
+    Closure(Binder<FnSig<'tcx>>),
+    Trait(Binder<Ty<'tcx>>),
+}
+impl ExprFnSig<'tcx> {
+    /// Gets the argument type at the given offset.
+    pub fn input(&self, i: usize) -> Binder<Ty<'tcx>> {
+        match self {
+            Self::Sig(sig) => sig.input(i),
+            Self::Closure(sig) => sig.input(0).map_bound(|ty| ty.tuple_element_ty(i).unwrap()),
+            Self::Trait(sig) => sig.map_bound(|ty| ty.tuple_element_ty(i).unwrap()),
+        }
+    }
+}
+
+/// If expr is function like, get the signature for it.
+pub fn expr_sig(tcx: TyCtxt<'tcx>, typeck: &TypeckResults<'tcx>, expr: &Expr<'_>) -> Option<ExprFnSig<'tcx>> {
+    match expr_res(typeck, expr) {
+        Some(Res::Def(DefKind::Fn | DefKind::Ctor(_, CtorKind::Fn) | DefKind::AssocFn, id) | Res::SelfCtor(id)) => {
+            Some(ExprFnSig::Sig(tcx.fn_sig(id)))
+        },
+        _ => {
+            let ty = typeck.expr_ty_adjusted(expr).peel_refs();
+            match *ty.kind() {
+                ty::Closure(_, subs) => Some(ExprFnSig::Closure(subs.as_closure().sig())),
+                ty::FnDef(id, subs) => Some(ExprFnSig::Sig(tcx.fn_sig(id).subst(tcx, subs))),
+                ty::FnPtr(sig) => Some(ExprFnSig::Sig(sig)),
+                ty::Dynamic(bounds, _) => {
+                    let lang_items = tcx.lang_items();
+                    match bounds.principal() {
+                        Some(bound)
+                            if Some(bound.def_id()) == lang_items.fn_trait()
+                                || Some(bound.def_id()) == lang_items.fn_once_trait()
+                                || Some(bound.def_id()) == lang_items.fn_mut_trait() =>
+                        {
+                            Some(ExprFnSig::Trait(bound.map_bound(|b| b.substs.type_at(0))))
+                        },
+                        _ => None,
+                    }
+                },
+                ty::Param(_) | ty::Projection(..) => {
+                    let mut id = typeck.hir_owner.to_def_id();
+                    loop {
+                        let predicates = tcx.predicates_of(id);
+                        let lang_items = tcx.lang_items();
+                        if let Some(res) = predicates
+                            .predicates
+                            .iter()
+                            .find_map(|&(p, _)| {
+                                p.kind()
+                                    .map_bound(|kind| match kind {
+                                        PredicateKind::Trait(p, _)
+                                            if (lang_items.fn_trait() == Some(p.def_id())
+                                                || lang_items.fn_mut_trait() == Some(p.def_id())
+                                                || lang_items.fn_once_trait() == Some(p.def_id()))
+                                                && p.self_ty() == ty =>
+                                        {
+                                            Some(p.trait_ref.substs.type_at(1))
+                                        },
+                                        _ => None,
+                                    })
+                                    .transpose()
+                            })
+                            .map(ExprFnSig::Trait)
+                        {
+                            break Some(res);
+                        } else if let Some(parent_id) = predicates.parent {
+                            id = parent_id;
+                        } else {
+                            break None;
+                        }
+                    }
+                },
+                _ => None,
+            }
+        },
+    }
+}
+
 /// Peels off all references on the pattern. Returns the underlying pattern and the number of
 /// references removed.
 pub fn peel_hir_pat_refs(pat: &'a Pat<'a>) -> (&'a Pat<'a>, usize) {

clippy_utils/src/lib.rs

@@ -40,6 +40,8 @@ pub const F32_EPSILON: [&str; 4] = ["core", "f32", "<impl f32>", "EPSILON"];
 pub const F64_EPSILON: [&str; 4] = ["core", "f64", "<impl f64>", "EPSILON"];
 pub const FILE: [&str; 3] = ["std", "fs", "File"];
 pub const FILE_TYPE: [&str; 3] = ["std", "fs", "FileType"];
+pub const FORMAT_ARGS_MACRO: [&str; 4] = ["core", "macros", "builtin", "format_args"];
+pub const FORMAT_ARGS_NL_MACRO: [&str; 4] = ["core", "macros", "builtin", "format_args_nl"];
 pub const FMT_ARGUMENTS_NEW_V1: [&str; 4] = ["core", "fmt", "Arguments", "new_v1"];
 pub const FMT_ARGUMENTS_NEW_V1_FORMATTED: [&str; 4] = ["core", "fmt", "Arguments", "new_v1_formatted"];
 pub const FMT_ARGUMENTV1_NEW: [&str; 4] = ["core", "fmt", "ArgumentV1", "new"];

clippy_utils/src/paths.rs

@@ -0,0 +1,88 @@
+// run-rustfix
+
+#![allow(
+    unused_imports,
+    dead_code,
+    clippy::borrowed_box,
+    clippy::deref_addrof,
+    clippy::useless_vec
+)]
+#![warn(clippy::explicit_auto_deref)]
+
+use std::{
+    ops::{Deref, DerefMut},
+    path::{Path, PathBuf},
+};
+
+fn main() {
+    let _: &str = &String::new();
+    let _: &Path = &PathBuf::new();
+    let _: &[_] = &vec![0u32, 1u32, 2u32];
+
+    fn f2<T>(_: &[T]) {}
+    f2(&vec![0u32]);
+
+    fn f3() -> &'static str {
+        static S: String = String::new();
+        &S
+    }
+
+    fn f4<T1, T2>(_: &(T1, T2)) {}
+    f4(&Box::new((0u32, 0i32)));
+
+    let f5 = |_: &str| {};
+    f5(&String::new());
+
+    fn f6(f: impl Fn(&str)) {
+        f(&String::new());
+    }
+
+    fn f7(f: &dyn Fn(&str)) {
+        f(&String::new());
+    }
+
+    let _: &Box<_> = &*Box::new(Box::new(0));
+    let _: Box<u32> = *Box::new(Box::new(0));
+
+    fn f8<T: ?Sized>(_: &T) {}
+    f8(&*String::new());
+
+    struct S1<T>(T);
+    impl<T: Fn(&str)> S1<T> {
+        fn f(&self, f: impl Fn(&str)) {
+            f(&String::new());
+            (self.0)(&String::new());
+        }
+    }
+
+    fn f9<T>(f: &mut T)
+    where
+        T: Iterator,
+        <T as Iterator>::Item: Fn(&str),
+    {
+        f.next().unwrap()(&String::new())
+    }
+
+    struct S2<'a> {
+        x: &'a str,
+    }
+    let _ = S2 { x: &String::new() };
+
+    struct S3<'a>(&'a str);
+    let _ = S3(&String::new());
+
+    macro_rules! m1 {
+        ($e:expr) => {{
+            fn f(_: &str) {}
+            f($e);
+        }};
+    }
+    m1!(&*String::new());
+
+    macro_rules! m2 {
+        ($e:expr) => {
+            &$e
+        };
+    }
+    let _: &str = m2!(String::new());
+}

tests/ui/explicit_auto_deref.fixed

@@ -0,0 +1,88 @@
+// run-rustfix
+
+#![allow(
+    unused_imports,
+    dead_code,
+    clippy::borrowed_box,
+    clippy::deref_addrof,
+    clippy::useless_vec
+)]
+#![warn(clippy::explicit_auto_deref)]
+
+use std::{
+    ops::{Deref, DerefMut},
+    path::{Path, PathBuf},
+};
+
+fn main() {
+    let _: &str = &*String::new();
+    let _: &Path = &*PathBuf::new();
+    let _: &[_] = vec![0u32, 1u32, 2u32].deref();
+
+    fn f2<T>(_: &[T]) {}
+    f2(vec![0u32].deref());
+
+    fn f3() -> &'static str {
+        static S: String = String::new();
+        &*S
+    }
+
+    fn f4<T1, T2>(_: &(T1, T2)) {}
+    f4(Box::new((0u32, 0i32)).deref());
+
+    let f5 = |_: &str| {};
+    f5(&*String::new());
+
+    fn f6(f: impl Fn(&str)) {
+        f(&*String::new());
+    }
+
+    fn f7(f: &dyn Fn(&str)) {
+        f(&*String::new());
+    }
+
+    let _: &Box<_> = &*Box::new(Box::new(0));
+    let _: Box<u32> = *Box::new(Box::new(0));
+
+    fn f8<T: ?Sized>(_: &T) {}
+    f8(&*String::new());
+
+    struct S1<T>(T);
+    impl<T: Fn(&str)> S1<T> {
+        fn f(&self, f: impl Fn(&str)) {
+            f(&*String::new());
+            (self.0)(&*String::new());
+        }
+    }
+
+    fn f9<T>(f: &mut T)
+    where
+        T: Iterator,
+        <T as Iterator>::Item: Fn(&str),
+    {
+        f.next().unwrap()(&*String::new())
+    }
+
+    struct S2<'a> {
+        x: &'a str,
+    }
+    let _ = S2 { x: &*String::new() };
+
+    struct S3<'a>(&'a str);
+    let _ = S3(&*String::new());
+
+    macro_rules! m1 {
+        ($e:expr) => {{
+            fn f(_: &str) {}
+            f($e);
+        }};
+    }
+    m1!(&*String::new());
+
+    macro_rules! m2 {
+        ($e:expr) => {
+            &$e
+        };
+    }
+    let _: &str = &**m2!(String::new());
+}