Auto merge of #150786 - reddevilmidzy:mgca-array, r=BoxyUwU

mGCA: Support array expression as direct const arguments

tracking issue: rust-lang/rust#132980
resolve: rust-lang/rust#150612

Support array expression as direct const arguments (e. g. [1, 2, N]) in min_generic_const_args.

todo:
* [x] Rebase another mGCA PR
* [x] Add more test case
* [x] Modify clippy code

clippy_lints/src/utils/author.rs

@@ -321,6 +321,7 @@ fn const_arg(&self, const_arg: &Binding<&ConstArg<'_>>) {
             },
             ConstArgKind::Struct(..) => chain!(self, "let ConstArgKind::Struct(..) = {const_arg}.kind"),
             ConstArgKind::TupleCall(..) => chain!(self, "let ConstArgKind::TupleCall(..) = {const_arg}.kind"),
+            ConstArgKind::Array(..) => chain!(self, "let ConstArgKind::Array(..) = {const_arg}.kind"),
             ConstArgKind::Infer(..) => chain!(self, "let ConstArgKind::Infer(..) = {const_arg}.kind"),
             ConstArgKind::Error(..) => chain!(self, "let ConstArgKind::Error(..) = {const_arg}.kind"),
             ConstArgKind::Tup(..) => chain!(self, "let ConstArgKind::Tup(..) = {const_arg}.kind"),

clippy_utils/src/consts.rs

@@ -1144,6 +1144,7 @@ pub fn const_item_rhs_to_expr<'tcx>(tcx: TyCtxt<'tcx>, ct_rhs: ConstItemRhs<'tcx
             | ConstArgKind::Tup(..)
             | ConstArgKind::Literal(..)
             | ConstArgKind::TupleCall(..)
+            | ConstArgKind::Array(..)
             | ConstArgKind::Path(_)
             | ConstArgKind::Error(..)
             | ConstArgKind::Infer(..) => None,

clippy_utils/src/hir_utils.rs

@@ -687,6 +687,11 @@ fn eq_const_arg(&mut self, left: &ConstArg<'_>, right: &ConstArg<'_>) -> bool {
                         .all(|(arg_a, arg_b)| self.eq_const_arg(arg_a, arg_b))
             },
             (ConstArgKind::Literal(kind_l), ConstArgKind::Literal(kind_r)) => kind_l == kind_r,
+            (ConstArgKind::Array(l_arr), ConstArgKind::Array(r_arr)) => {
+                l_arr.elems.len() == r_arr.elems.len()
+                && l_arr.elems.iter().zip(r_arr.elems.iter())
+                    .all(|(l_elem, r_elem)| self.eq_const_arg(l_elem, r_elem))
+            }
             // Use explicit match for now since ConstArg is undergoing flux.
             (
                 ConstArgKind::Path(..)
@@ -696,6 +701,7 @@ fn eq_const_arg(&mut self, left: &ConstArg<'_>, right: &ConstArg<'_>) -> bool {
                 | ConstArgKind::Infer(..)
                 | ConstArgKind::Struct(..)
                 | ConstArgKind::Literal(..)
+                | ConstArgKind::Array(..)
                 | ConstArgKind::Error(..),
                 _,
             ) => false,
@@ -1575,6 +1581,11 @@ fn hash_const_arg(&mut self, const_arg: &ConstArg<'_>) {
                     self.hash_const_arg(arg);
                 }
             },
+            ConstArgKind::Array(array_expr) => {
+                for elem in array_expr.elems {
+                    self.hash_const_arg(elem);
+                }
+            },
             ConstArgKind::Infer(..) | ConstArgKind::Error(..) => {},
             ConstArgKind::Literal(lit) => lit.hash(&mut self.s),
         }