Support literals

Author: AlessioC31

clippy_lints/src/redundant_type_annotations.rs

@@ -1,4 +1,5 @@
 use clippy_utils::diagnostics::span_lint;
+use rustc_ast::LitKind;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::Ty;
@@ -115,21 +116,25 @@ impl LateLintPass<'_> for RedundantTypeAnnotations {
         // type annotation part
         if !local.span.from_expansion()
             && let Some(ty) = &local.ty
-            && let hir::TyKind::Path(ty_path) = &ty.kind
-            && let hir::QPath::Resolved(_, resolved_path_ty) = ty_path
 
             // initialization part
             && let Some(init) = local.init
         {
             match &init.kind {
                 // When the initialization is a call to a function
                 hir::ExprKind::Call(init_call, _) => {
-                    if is_redundant_in_func_call(cx, resolved_path_ty.res, init_call) {
+                    if let hir::TyKind::Path(ty_path) = &ty.kind
+                        && let hir::QPath::Resolved(_, resolved_path_ty) = ty_path
+
+                        && is_redundant_in_func_call(cx, resolved_path_ty.res, init_call) {
                         span_lint(cx, REDUNDANT_TYPE_ANNOTATIONS, local.span, "redundant type annotation");
                     }
                 },
                 hir::ExprKind::MethodCall(_, _, _, _) => {
-                    if let Some(func_ty) = func_hir_id_to_func_ty(cx, init.hir_id)
+                    if let hir::TyKind::Path(ty_path) = &ty.kind
+                        && let hir::QPath::Resolved(_, resolved_path_ty) = ty_path
+
+                        && let Some(func_ty) = func_hir_id_to_func_ty(cx, init.hir_id)
                         && let Some(return_type) = func_ty_to_return_type(cx, func_ty)
                         && is_same_type(cx, resolved_path_ty.res, return_type)
                     {
@@ -139,7 +144,9 @@ impl LateLintPass<'_> for RedundantTypeAnnotations {
                 // When the initialization is a path for example u32::MAX
                 hir::ExprKind::Path(init_path) => {
                     // TODO: check for non primty
-                    if let hir::def::Res::PrimTy(primty) = resolved_path_ty.res
+                    if let hir::TyKind::Path(ty_path) = &ty.kind
+                        && let hir::QPath::Resolved(_, resolved_path_ty) = ty_path
+                        && let hir::def::Res::PrimTy(primty) = resolved_path_ty.res
 
                         && let hir::QPath::TypeRelative(init_ty, _) = init_path
                         && let hir::TyKind::Path(init_ty_path) = &init_ty.kind
@@ -151,6 +158,25 @@ impl LateLintPass<'_> for RedundantTypeAnnotations {
                         span_lint(cx, REDUNDANT_TYPE_ANNOTATIONS, local.span, "redundant type annotation");
                     }
                 },
+                hir::ExprKind::Lit(init_lit) => {
+                    match init_lit.node {
+                        // In these cases the annotation is redundant
+                        LitKind::Str(..)
+                        | LitKind::ByteStr(..)
+                        | LitKind::Byte(..)
+                        | LitKind::Char(..)
+                        | LitKind::Bool(..) => {
+                            span_lint(cx, REDUNDANT_TYPE_ANNOTATIONS, local.span, "redundant type annotation");
+                        },
+                        LitKind::Int(..) | LitKind::Float(..) => {
+                            // If the initialization value is a suffixed literal we lint
+                            if init_lit.node.is_suffixed() {
+                                span_lint(cx, REDUNDANT_TYPE_ANNOTATIONS, local.span, "redundant type annotation");
+                            }
+                        },
+                        LitKind::Err => (),
+                    }
+                }
                 _ => ()
             }
         };

tests/ui/redundant_type_annotations.rs

@@ -142,8 +142,17 @@ fn test_functions() {
 fn test_simple_types() {
     let _var: u32 = u32::MAX;
 
-    // Should lint (doesn't)
+    // Should lint
     let _var: u32 = 5_u32;
+
+    // Should lint
+    let _var: &str = "test";
+
+    // Should lint
+    let _var: &[u8] = b"test";
+
+    // Should lint
+    let _var: bool = false;
 }
 
 fn main() {}

tests/ui/redundant_type_annotations.stderr

@@ -66,5 +66,29 @@ error: redundant type annotation
 LL |     let _var: u32 = u32::MAX;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 11 previous errors
+error: redundant type annotation
+  --> $DIR/redundant_type_annotations.rs:146:5
+   |
+LL |     let _var: u32 = 5_u32;
+   |     ^^^^^^^^^^^^^^^^^^^^^^
+
+error: redundant type annotation
+  --> $DIR/redundant_type_annotations.rs:149:5
+   |
+LL |     let _var: &str = "test";
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: redundant type annotation
+  --> $DIR/redundant_type_annotations.rs:152:5
+   |
+LL |     let _var: &[u8] = b"test";
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: redundant type annotation
+  --> $DIR/redundant_type_annotations.rs:155:5
+   |
+LL |     let _var: bool = false;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 15 previous errors