Add redundant type annotations lint

AlessioC31 · AlessioC31 · commit 4770ee188682 · 2023-03-30T15:53:35.000+02:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -4854,6 +4854,7 @@ Released 2018-09-13
 [`redundant_pub_crate`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_pub_crate
 [`redundant_slicing`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_slicing
 [`redundant_static_lifetimes`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_static_lifetimes
+[`redundant_type_annotations`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_type_annotations
 [`ref_binding_to_reference`]: https://rust-lang.github.io/rust-clippy/master/index.html#ref_binding_to_reference
 [`ref_in_deref`]: https://rust-lang.github.io/rust-clippy/master/index.html#ref_in_deref
 [`ref_option_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#ref_option_ref
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
@@ -533,6 +533,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::redundant_slicing::DEREF_BY_SLICING_INFO,
     crate::redundant_slicing::REDUNDANT_SLICING_INFO,
     crate::redundant_static_lifetimes::REDUNDANT_STATIC_LIFETIMES_INFO,
+    crate::redundant_type_annotations::REDUNDANT_TYPE_ANNOTATIONS_INFO,
     crate::ref_option_ref::REF_OPTION_REF_INFO,
     crate::reference::DEREF_ADDROF_INFO,
     crate::regex::INVALID_REGEX_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
@@ -263,6 +263,7 @@ mod redundant_field_names;
 mod redundant_pub_crate;
 mod redundant_slicing;
 mod redundant_static_lifetimes;
+mod redundant_type_annotations;
 mod ref_option_ref;
 mod reference;
 mod regex;
@@ -949,6 +950,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
             avoid_breaking_exported_api,
         ))
     });
+    store.register_late_pass(|_| Box::new(redundant_type_annotations::RedundantTypeAnnotations));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 
diff --git a/clippy_lints/src/redundant_type_annotations.rs b/clippy_lints/src/redundant_type_annotations.rs
@@ -0,0 +1,143 @@
+use clippy_utils::diagnostics::span_lint;
+use rustc_hir as hir;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::Ty;
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Warns about needless / redundant type annotations.
+    ///
+    /// ### Why is this bad?
+    /// Code is more idiomatic, shorter, and easier to modify.
+    ///
+    /// ### Example
+    /// ```rust
+    /// let foo: String = String::new();
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// let foo = String::new();
+    /// ```
+    #[clippy::version = "1.70.0"]
+    pub REDUNDANT_TYPE_ANNOTATIONS,
+    pedantic,
+    "Warns about needless / redundant type annotations."
+}
+declare_lint_pass!(RedundantTypeAnnotations => [REDUNDANT_TYPE_ANNOTATIONS]);
+
+fn is_redundant_in_resolved_path<'tcx>(cx: &LateContext<'tcx>, res: hir::def::Res, func_return_type: Ty<'tcx>) -> bool {
+    // type annotation is primitive
+    if_chain! {
+        if let hir::def::Res::PrimTy(primty) = res;
+
+        if func_return_type.is_primitive();
+        if let Some(func_return_type_sym) = func_return_type.primitive_symbol();
+
+        then {
+            return primty.name() == func_return_type_sym;
+        }
+    }
+
+    // type annotation is any other non generic type
+    if_chain! {
+        if let hir::def::Res::Def(_, defid) = res;
+        if let Some(annotation_ty) = cx.tcx.type_of(defid).no_bound_vars();
+
+        then {
+            return annotation_ty == func_return_type
+        }
+    }
+
+    false
+}
+
+fn is_redundant_in_func_call<'tcx>(
+    cx: &LateContext<'tcx>,
+    res: hir::def::Res,
+    func_return_path: &hir::QPath<'tcx>,
+) -> bool {
+    // TODO: Problem with something like
+    // let a: String = StructTest::func() where func returns String::from
+    // The problem is that the DefId that I get refers to the struct itself and not to string
+
+    match func_return_path {
+        // let a: String = f(); where f: fn f() -> String
+        hir::QPath::Resolved(_, resolved_path) => {
+            if_chain! {
+                if let hir::def::Res::Def(_, defid) = resolved_path.res;
+                if let Some(middle_ty_init) = cx.tcx.type_of(defid).no_bound_vars();
+                if middle_ty_init.is_fn();
+                if let Some(init_return_type) = middle_ty_init.fn_sig(cx.tcx).output().no_bound_vars();
+                then {
+                    return is_redundant_in_resolved_path(cx, res, init_return_type);
+                }
+            }
+
+            false
+        },
+        // let a: String = String::new();
+        hir::QPath::TypeRelative(func_hir_ty, _) => {
+            if_chain! {
+                if let hir::def::Res::Def(_, defid) = res;
+                if let Some(annotation_ty) = cx.tcx.type_of(defid).no_bound_vars();
+
+                if let hir::TyKind::Path(init_ty_path) = &func_hir_ty.kind;
+                if let hir::QPath::Resolved(_, resolved_init_ty_path) = init_ty_path;
+                if let hir::def::Res::Def(_, init_defid) = resolved_init_ty_path.res;
+                if let Some(init_ty) = cx.tcx.type_of(init_defid).no_bound_vars();
+
+                then {
+                    return annotation_ty == init_ty
+                }
+            }
+
+            false
+        },
+        hir::QPath::LangItem(..) => false,
+    }
+}
+
+impl LateLintPass<'_> for RedundantTypeAnnotations {
+    fn check_local<'tcx>(&mut self, cx: &LateContext<'tcx>, local: &'tcx rustc_hir::Local<'_>) {
+        if_chain! {
+            // type annotation part
+            if let Some(ty) = &local.ty;
+            if let hir::TyKind::Path(ty_path) = &ty.kind;
+            if let hir::QPath::Resolved(_, resolved_path_ty) = ty_path;
+
+            // initialization part
+            if let Some(init) = local.init;
+
+            then {
+                match &init.kind {
+                    // When the initialization is a call to a function
+                    hir::ExprKind::Call(init_call, _) => {
+                        if let hir::ExprKind::Path(init_path) = &init_call.kind {
+                            if is_redundant_in_func_call(cx, resolved_path_ty.res, init_path) {
+                                span_lint(cx, REDUNDANT_TYPE_ANNOTATIONS, local.span, "redundant type annotation");
+                            }
+                        }
+                    },
+                    // When the initialization is a path for example u32::MAX
+                    hir::ExprKind::Path(init_path) => {
+                        if_chain! {
+                            if let hir::def::Res::PrimTy(primty) = resolved_path_ty.res;
+
+                            if let hir::QPath::TypeRelative(init_ty, _) = init_path;
+                            if let hir::TyKind::Path(init_ty_path) = &init_ty.kind;
+                            if let hir::QPath::Resolved(_, resolved_init_ty_path) = init_ty_path;
+                            if let hir::def::Res::PrimTy(primty_init) = resolved_init_ty_path.res;
+
+                            if primty == primty_init;
+                            then {
+                                span_lint(cx, REDUNDANT_TYPE_ANNOTATIONS, local.span, "redundant type annotation");
+                            }
+                        }
+                    }
+                    _ => ()
+                }
+            }
+        };
+    }
+}
diff --git a/tests/ui/redundant_type_annotations.rs b/tests/ui/redundant_type_annotations.rs
@@ -0,0 +1,67 @@
+#![allow(unused)]
+#![warn(clippy::redundant_type_annotations)]
+
+struct A;
+enum E {
+    One,
+    Two,
+}
+
+fn f() -> String {
+    String::new()
+}
+
+fn f_struct() -> A {
+    A
+}
+
+fn f_enum() -> E {
+    E::One
+}
+
+struct ATest2 {
+    inner: u32,
+}
+
+impl ATest2 {
+    fn func(&self) -> u32 {
+        self.inner
+    }
+
+    fn a(&self) {
+        let v: u32 = self.func(); // This should lint but doesn't (MethodCall)
+    }
+
+    fn get_num() -> u32 {
+        5
+    }
+
+    fn new() -> Self {
+        Self { inner: 5 }
+    }
+}
+
+fn f_prim() -> u32 {
+    5
+}
+
+fn main() {
+    let a: String = f();
+
+    let a: A = f_struct();
+
+    let a: E = f_enum();
+
+    let a: u32 = f_prim();
+
+    let a: String = String::new();
+
+    let st: ATest2 = ATest2::new();
+    let a: u32 = st.func(); // this should lint but doesn't (MethodCall)
+
+    let a: String = String::from("test");
+
+    let a: u32 = u32::MAX;
+
+    let a: u32 = ATest2::get_num(); // this should lint but doesn't (DefId refers to ATest2 and not to the func)
+}
diff --git a/tests/ui/redundant_type_annotations.stderr b/tests/ui/redundant_type_annotations.stderr
@@ -0,0 +1,52 @@
+error: redundant type annotation
+  --> $DIR/redundant_type_annotations.rs:49:5
+   |
+LL |     let a: String = f();
+   |     ^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::redundant-type-annotations` implied by `-D warnings`
+
+error: redundant type annotation
+  --> $DIR/redundant_type_annotations.rs:51:5
+   |
+LL |     let a: A = f_struct();
+   |     ^^^^^^^^^^^^^^^^^^^^^^
+
+error: redundant type annotation
+  --> $DIR/redundant_type_annotations.rs:53:5
+   |
+LL |     let a: E = f_enum();
+   |     ^^^^^^^^^^^^^^^^^^^^
+
+error: redundant type annotation
+  --> $DIR/redundant_type_annotations.rs:55:5
+   |
+LL |     let a: u32 = f_prim();
+   |     ^^^^^^^^^^^^^^^^^^^^^^
+
+error: redundant type annotation
+  --> $DIR/redundant_type_annotations.rs:57:5
+   |
+LL |     let a: String = String::new();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: redundant type annotation
+  --> $DIR/redundant_type_annotations.rs:59:5
+   |
+LL |     let st: ATest2 = ATest2::new();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: redundant type annotation
+  --> $DIR/redundant_type_annotations.rs:62:5
+   |
+LL |     let a: String = String::from("test");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: redundant type annotation
+  --> $DIR/redundant_type_annotations.rs:64:5
+   |
+LL |     let a: u32 = u32::MAX;
+   |     ^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 8 previous errors
+
