Make Clippy understand generic consts

Author: fmease

src/tools/clippy/clippy_lints/src/large_const_arrays.rs

@@ -50,7 +50,11 @@ impl<'tcx> LateLintPass<'tcx> for LargeConstArrays {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
         if_chain! {
             if !item.span.from_expansion();
-            if let ItemKind::Const(hir_ty, _) = &item.kind;
+            if let ItemKind::Const(hir_ty, generics, _) = &item.kind;
+            // Since static items may not have generics, skip generic consts.
+            // FIXME(generic_consts): I don't think checking `generics.hwcp` suffices as it doesn't
+            // account for empty where-clauses that only consist of keyword `where` (IIRC).
+            if generics.params.is_empty() && !generics.has_where_clause_predicates;
             let ty = hir_ty_to_ty(cx.tcx, hir_ty);
             if let ty::Array(element_type, cst) = ty.kind();
             if let ConstKind::Value(ty::ValTree::Leaf(element_count)) = cst.kind();

src/tools/clippy/clippy_lints/src/loops/needless_range_loop.rs

@@ -284,6 +284,8 @@ impl<'a, 'tcx> VarVisitor<'a, 'tcx> {
                         if index_used_directly {
                             self.indexed_directly.insert(
                                 seqvar.segments[0].ident.name,
+                                // FIXME(generic_consts): Do we need to subst anything here or has
+                                // that already been taken care of?
                                 (None, self.cx.typeck_results().node_type(seqexpr.hir_id)),
                             );
                         } else {

src/tools/clippy/clippy_lints/src/non_copy_const.rs

@@ -286,7 +286,9 @@ declare_lint_pass!(NonCopyConst => [DECLARE_INTERIOR_MUTABLE_CONST, BORROW_INTER
 
 impl<'tcx> LateLintPass<'tcx> for NonCopyConst {
     fn check_item(&mut self, cx: &LateContext<'tcx>, it: &'tcx Item<'_>) {
-        if let ItemKind::Const(hir_ty, body_id) = it.kind {
+        if let ItemKind::Const(hir_ty, _generics, body_id) = it.kind {
+            // FIXME(generic_consts): Not sure if we need to handle generics explicitly here like
+            // replacing params with placeholders or can `is_unfrozen` handle params on its own?
             let ty = hir_ty_to_ty(cx.tcx, hir_ty);
             if !ignored_macro(cx, it) && is_unfrozen(cx, ty) && is_value_unfrozen_poly(cx, body_id, ty) {
                 lint(cx, Source::Item { item: it.span });
@@ -295,6 +297,7 @@ impl<'tcx> LateLintPass<'tcx> for NonCopyConst {
     }
 
     fn check_trait_item(&mut self, cx: &LateContext<'tcx>, trait_item: &'tcx TraitItem<'_>) {
+        // FIXME(generic_consts): Not sure if we need to handle generics explicitly here.
         if let TraitItemKind::Const(hir_ty, body_id_opt) = &trait_item.kind {
             let ty = hir_ty_to_ty(cx.tcx, hir_ty);
 
@@ -322,6 +325,7 @@ impl<'tcx> LateLintPass<'tcx> for NonCopyConst {
     }
 
     fn check_impl_item(&mut self, cx: &LateContext<'tcx>, impl_item: &'tcx ImplItem<'_>) {
+        // FIXME(generic_consts): Not sure if we need to handle generics explicitly here
         if let ImplItemKind::Const(hir_ty, body_id) = &impl_item.kind {
             let item_def_id = cx.tcx.hir().get_parent_item(impl_item.hir_id()).def_id;
             let item = cx.tcx.hir().expect_item(item_def_id);

src/tools/clippy/clippy_lints/src/types/mod.rs

@@ -349,7 +349,9 @@ impl<'tcx> LateLintPass<'tcx> for Types {
         let is_exported = cx.effective_visibilities.is_exported(item.owner_id.def_id);
 
         match item.kind {
-            ItemKind::Static(ty, _, _) | ItemKind::Const(ty, _) => self.check_ty(
+            // FIXME(generic_consts): Not sure if we need to handle generics explicitly here like
+            // replacing params with placeholders or can relate routines handle params on their own?
+            ItemKind::Static(ty, _, _) | ItemKind::Const(ty, _, _) => self.check_ty(
                 cx,
                 ty,
                 CheckTyContext {
@@ -364,6 +366,8 @@ impl<'tcx> LateLintPass<'tcx> for Types {
 
     fn check_impl_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx ImplItem<'_>) {
         match item.kind {
+            // FIXME(generic_consts): Not sure if we need to handle generics explicitly here like
+            // replacing params with placeholders or can relate routines handle params on their own?
             ImplItemKind::Const(ty, _) => {
                 let is_in_trait_impl = if let Some(hir::Node::Item(item)) = cx
                     .tcx
@@ -413,6 +417,8 @@ impl<'tcx> LateLintPass<'tcx> for Types {
         };
 
         match item.kind {
+            // FIXME(generic_consts): Not sure if we need to handle generics explicitly here like
+            // replacing params with placeholders or can relate routines handle params on their own?
             TraitItemKind::Const(ty, _) | TraitItemKind::Type(_, Some(ty)) => {
                 self.check_ty(cx, ty, context);
             },

src/tools/clippy/clippy_lints/src/utils/internal_lints/interning_defined_symbol.rs

@@ -77,6 +77,7 @@ impl<'tcx> LateLintPass<'tcx> for InterningDefinedSymbol {
             for def_id in def_path_def_ids(cx, module) {
                 for item in cx.tcx.module_children(def_id) {
                     if_chain! {
+                        // FIXME(generic_consts): Shouldn't we subst here now?
                         if let Res::Def(DefKind::Const, item_def_id) = item.res;
                         let ty = cx.tcx.type_of(item_def_id).subst_identity();
                         if match_type(cx, ty, &paths::SYMBOL);

src/tools/clippy/clippy_lints/src/utils/internal_lints/invalid_paths.rs

@@ -34,6 +34,7 @@ impl<'tcx> LateLintPass<'tcx> for InvalidPaths {
         if_chain! {
             if mod_name.as_str() == "paths";
             if let hir::ItemKind::Const(ty, body_id) = item.kind;
+            // FIXME(generic_consts): Is this compatible with generic consts?
             let ty = hir_ty_to_ty(cx.tcx, ty);
             if let ty::Array(el_ty, _) = &ty.kind();
             if let ty::Ref(_, el_ty, _) = &el_ty.kind();

src/tools/clippy/clippy_lints/src/utils/internal_lints/unnecessary_def_path.rs

@@ -231,6 +231,7 @@ fn path_to_matched_type(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> Option<Ve
                 cx.tcx.eval_static_initializer(def_id).ok()?.inner(),
                 cx.tcx.type_of(def_id).subst_identity(),
             ),
+            // FIXME(generic_consts): Shouldn't we subst here first before `const_eval_poly`?
             Res::Def(DefKind::Const, def_id) => match cx.tcx.const_eval_poly(def_id).ok()? {
                 ConstValue::ByRef { alloc, offset } if offset.bytes() == 0 => {
                     read_mir_alloc_def_path(cx, alloc.inner(), cx.tcx.type_of(def_id).subst_identity())

src/tools/clippy/clippy_utils/src/ast_utils.rs

@@ -301,15 +301,17 @@ pub fn eq_item_kind(l: &ItemKind, r: &ItemKind) -> bool {
         (
             Const(box ast::ConstItem {
                 defaultness: ld,
+                generics: lg,
                 ty: lt,
                 expr: le,
             }),
             Const(box ast::ConstItem {
                 defaultness: rd,
+                generics: rg,
                 ty: rt,
                 expr: re,
             }),
-        ) => eq_defaultness(*ld, *rd) && eq_ty(lt, rt) && eq_expr_opt(le, re),
+        ) => eq_defaultness(*ld, *rd) && eq_generics(lg, rg) && eq_ty(lt, rt) && eq_expr_opt(le, re),
         (
             Fn(box ast::Fn {
                 defaultness: ld,
@@ -476,15 +478,17 @@ pub fn eq_assoc_item_kind(l: &AssocItemKind, r: &AssocItemKind) -> bool {
         (
             Const(box ast::ConstItem {
                 defaultness: ld,
+                generics: lg,
                 ty: lt,
                 expr: le,
             }),
             Const(box ast::ConstItem {
                 defaultness: rd,
+                generics: rg,
                 ty: rt,
                 expr: re,
             }),
-        ) => eq_defaultness(*ld, *rd) && eq_ty(lt, rt) && eq_expr_opt(le, re),
+        ) => eq_defaultness(*ld, *rd) && eq_generics(lg, rg) && eq_ty(lt, rt) && eq_expr_opt(le, re),
         (
             Fn(box ast::Fn {
                 defaultness: ld,

src/tools/clippy/clippy_utils/src/consts.rs

@@ -463,7 +463,7 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
                 // Check if this constant is based on `cfg!(..)`,
                 // which is NOT constant for our purposes.
                 if let Some(node) = self.lcx.tcx.hir().get_if_local(def_id)
-                    && let Node::Item(Item { kind: ItemKind::Const(_, body_id), .. }) = node
+                    && let Node::Item(Item { kind: ItemKind::Const(.., body_id), .. }) = node
                     && let Node::Expr(Expr { kind: ExprKind::Lit(_), span, .. }) = self.lcx
                         .tcx
                         .hir()
@@ -473,6 +473,7 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
                     return None;
                 }
 
+                // FIXME(generic_consts): Does this already account for generic consts?
                 let substs = self.typeck_results.node_substs(id);
                 let substs = if self.substs.is_empty() {
                     substs

src/tools/clippy/clippy_utils/src/lib.rs

@@ -2385,7 +2385,7 @@ fn with_test_item_names(tcx: TyCtxt<'_>, module: LocalDefId, f: impl Fn(&[Symbol
             for id in tcx.hir().module_items(module) {
                 if matches!(tcx.def_kind(id.owner_id), DefKind::Const)
                     && let item = tcx.hir().item(id)
-                    && let ItemKind::Const(ty, _body) = item.kind {
+                    && let ItemKind::Const(ty, _generics, _body) = item.kind {
                     if let TyKind::Path(QPath::Resolved(_, path)) = ty.kind {
                         // We could also check for the type name `test::TestDescAndFn`
                         if let Res::Def(DefKind::Struct, _) = path.res {