Recurse into hir types

Author: korrat

clippy_lints/src/zero_sized_map_values.rs

@@ -10,24 +10,31 @@ use rustc_typeck::hir_ty_to_ty;
 use crate::utils::{match_type, paths, span_lint_and_help};
 
 declare_clippy_lint! {
-    /// **What it does:**
+    /// **What it does:** Checks for maps with zero-sized value types anywhere in the code.
     ///
-    /// **Why is this bad?**
+    /// **Why is this bad?** Since there is only a single value for a zero-sized type, a map
+    /// containing zero sized values is effectively a set. Using a set in that case improves
+    /// readability and communicates intent more clearly.
     ///
-    /// **Known problems:** None.
+    /// **Known problems:** A zero-sized type cannot be recovered later if it contains private
+    /// fields.
     ///
     /// **Example:**
     ///
     /// ```rust
-    /// // example code where clippy issues a warning
+    /// fn unique_words(text: &str) -> HashMap<&str, ()> {
+    ///     todo!();
+    /// }
     /// ```
     /// Use instead:
     /// ```rust
-    /// // example code which does not raise clippy warning
+    /// fn unique_words(text: &str) -> HashSet<&str> {
+    ///     todo!();
+    /// }
     /// ```
     pub ZERO_SIZED_MAP_VALUES,
     nursery,
-    "default lint description"
+    "usage of map with zero-sized value type"
 }
 
 declare_lint_pass!(ZeroSizedMapValues => [ZERO_SIZED_MAP_VALUES]);
@@ -59,7 +66,49 @@ impl ZeroSizedMapValues {
         let ty = hir_ty_to_ty(cx.tcx, hir_ty);
         self.check_ty(cx, ty, hir_ty.span);
 
-        // TODO recurse on qpath
+        match hir_ty.kind {
+            TyKind::Path(ref qpath) => match *qpath {
+                QPath::Resolved(ty, ref p) => {
+                    if let Some(ty) = ty {
+                        self.check_hir_ty(cx, ty);
+                    }
+
+                    for ty in p.segments.iter().flat_map(|seg| {
+                        seg.args
+                            .as_ref()
+                            .map_or_else(|| [].iter(), |params| params.args.iter())
+                            .filter_map(|arg| match arg {
+                                GenericArg::Type(ty) => Some(ty),
+                                _ => None,
+                            })
+                    }) {
+                        self.check_hir_ty(cx, ty);
+                    }
+                },
+                QPath::TypeRelative(ty, ref seg) => {
+                    self.check_hir_ty(cx, ty);
+
+                    if let Some(ref params) = seg.args {
+                        for ty in params.args.iter().filter_map(|arg| match arg {
+                            GenericArg::Type(ty) => Some(ty),
+                            _ => None,
+                        }) {
+                            self.check_hir_ty(cx, ty);
+                        }
+                    }
+                },
+                QPath::LangItem(..) => {},
+            },
+            TyKind::Slice(ref ty) | TyKind::Array(ref ty, _) | TyKind::Ptr(MutTy { ref ty, .. }) => {
+                self.check_hir_ty(cx, ty);
+            },
+            TyKind::Tup(tys) => {
+                for ty in tys {
+                    self.check_hir_ty(cx, ty);
+                }
+            },
+            _ => {},
+        }
     }
 
     fn check_ty<'tcx>(&mut self, cx: &LateContext<'tcx>, ty: Ty<'tcx>, span: Span) {

tests/ui/zero_sized_map_values.rs

@@ -4,6 +4,8 @@ use std::collections::HashMap;
 struct Test {
     ok: HashMap<String, usize>,
     not_ok: HashMap<String, ()>,
+
+    also_not_ok: Vec<HashMap<usize, ()>>,
 }
 
 fn test(map: HashMap<String, ()>, key: &str) -> HashMap<String, ()> {

tests/ui/zero_sized_map_values.stderr

@@ -8,36 +8,44 @@ LL |     not_ok: HashMap<String, ()>,
    = help: consider using a set instead
 
 error: map with zero-sized value type
-  --> $DIR/zero_sized_map_values.rs:9:14
+  --> $DIR/zero_sized_map_values.rs:8:22
+   |
+LL |     also_not_ok: Vec<HashMap<usize, ()>>,
+   |                      ^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using a set instead
+
+error: map with zero-sized value type
+  --> $DIR/zero_sized_map_values.rs:11:14
    |
 LL | fn test(map: HashMap<String, ()>, key: &str) -> HashMap<String, ()> {
    |              ^^^^^^^^^^^^^^^^^^^
    |
    = help: consider using a set instead
 
 error: map with zero-sized value type
-  --> $DIR/zero_sized_map_values.rs:9:49
+  --> $DIR/zero_sized_map_values.rs:11:49
    |
 LL | fn test(map: HashMap<String, ()>, key: &str) -> HashMap<String, ()> {
    |                                                 ^^^^^^^^^^^^^^^^^^^
    |
    = help: consider using a set instead
 
 error: map with zero-sized value type
-  --> $DIR/zero_sized_map_values.rs:19:9
+  --> $DIR/zero_sized_map_values.rs:21:9
    |
 LL |     let _: HashMap<String, ()> = HashMap::new();
    |         ^
    |
    = help: consider using a set instead
 
 error: map with zero-sized value type
-  --> $DIR/zero_sized_map_values.rs:22:9
+  --> $DIR/zero_sized_map_values.rs:24:9
    |
 LL |     let _: HashMap<_, _> = std::iter::empty::<(String, ())>().collect();
    |         ^
    |
    = help: consider using a set instead
 
-error: aborting due to 5 previous errors
+error: aborting due to 6 previous errors