Fix clippy and rustfmt

Author: camelid

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

@@ -355,25 +355,23 @@ pub fn eq_item_kind(l: &ItemKind, r: &ItemKind) -> bool {
                 ident: li,
                 generics: lg,
                 ty: lt,
-                body_id: _,
-                expr: le,
+                body: lb,
                 define_opaque: _,
             }),
             Const(box ConstItem {
                 defaultness: rd,
                 ident: ri,
                 generics: rg,
                 ty: rt,
-                body_id: _,
-                expr: re,
+                body: rb,
                 define_opaque: _,
             }),
         ) => {
             eq_defaultness(*ld, *rd)
                 && eq_id(*li, *ri)
                 && eq_generics(lg, rg)
                 && eq_ty(lt, rt)
-                && eq_expr_opt(le.as_ref(), re.as_ref())
+                && both(lb.as_ref(), rb.as_ref(), |l, r| eq_anon_const(l, r))
         },
         (
             Fn(box ast::Fn {
@@ -597,25 +595,23 @@ pub fn eq_assoc_item_kind(l: &AssocItemKind, r: &AssocItemKind) -> bool {
                 ident: li,
                 generics: lg,
                 ty: lt,
-                body_id: _,
-                expr: le,
+                body: lb,
                 define_opaque: _,
             }),
             Const(box ConstItem {
                 defaultness: rd,
                 ident: ri,
                 generics: rg,
                 ty: rt,
-                body_id: _,
-                expr: re,
+                body: rb,
                 define_opaque: _,
             }),
         ) => {
             eq_defaultness(*ld, *rd)
                 && eq_id(*li, *ri)
                 && eq_generics(lg, rg)
                 && eq_ty(lt, rt)
-                && eq_expr_opt(le.as_ref(), re.as_ref())
+                && both(lb.as_ref(), rb.as_ref(), |l, r| eq_anon_const(l, r))
         },
         (
             Fn(box ast::Fn {

src/tools/rustfmt/src/items.rs

@@ -2029,30 +2029,30 @@ pub(crate) struct StaticParts<'a> {
 
 impl<'a> StaticParts<'a> {
     pub(crate) fn from_item(item: &'a ast::Item) -> Self {
-        let (defaultness, prefix, safety, ident, ty, mutability, expr, generics) = match &item.kind
-        {
-            ast::ItemKind::Static(s) => (
-                None,
-                "static",
-                s.safety,
-                s.ident,
-                &s.ty,
-                s.mutability,
-                &s.expr,
-                None,
-            ),
-            ast::ItemKind::Const(c) => (
-                Some(c.defaultness),
-                "const",
-                ast::Safety::Default,
-                c.ident,
-                &c.ty,
-                ast::Mutability::Not,
-                &c.expr,
-                Some(&c.generics),
-            ),
-            _ => unreachable!(),
-        };
+        let (defaultness, prefix, safety, ident, ty, mutability, expr_opt, generics) =
+            match &item.kind {
+                ast::ItemKind::Static(s) => (
+                    None,
+                    "static",
+                    s.safety,
+                    s.ident,
+                    &s.ty,
+                    s.mutability,
+                    s.expr.as_ref(),
+                    None,
+                ),
+                ast::ItemKind::Const(c) => (
+                    Some(c.defaultness),
+                    "const",
+                    ast::Safety::Default,
+                    c.ident,
+                    &c.ty,
+                    ast::Mutability::Not,
+                    c.body.as_ref().map(|ct| &ct.value),
+                    Some(&c.generics),
+                ),
+                _ => unreachable!(),
+            };
         StaticParts {
             prefix,
             safety,
@@ -2061,15 +2061,15 @@ impl<'a> StaticParts<'a> {
             generics,
             ty,
             mutability,
-            expr_opt: expr.as_ref(),
+            expr_opt,
             defaultness,
             span: item.span,
         }
     }
 
     pub(crate) fn from_trait_item(ti: &'a ast::AssocItem, ident: Ident) -> Self {
-        let (defaultness, ty, expr_opt, generics) = match &ti.kind {
-            ast::AssocItemKind::Const(c) => (c.defaultness, &c.ty, &c.expr, Some(&c.generics)),
+        let (defaultness, ty, body_opt, generics) = match &ti.kind {
+            ast::AssocItemKind::Const(c) => (c.defaultness, &c.ty, &c.body, Some(&c.generics)),
             _ => unreachable!(),
         };
         StaticParts {
@@ -2080,15 +2080,15 @@ impl<'a> StaticParts<'a> {
             generics,
             ty,
             mutability: ast::Mutability::Not,
-            expr_opt: expr_opt.as_ref(),
+            expr_opt: body_opt.as_ref().map(|ct| &ct.value),
             defaultness: Some(defaultness),
             span: ti.span,
         }
     }
 
     pub(crate) fn from_impl_item(ii: &'a ast::AssocItem, ident: Ident) -> Self {
-        let (defaultness, ty, expr, generics) = match &ii.kind {
-            ast::AssocItemKind::Const(c) => (c.defaultness, &c.ty, &c.expr, Some(&c.generics)),
+        let (defaultness, ty, body, generics) = match &ii.kind {
+            ast::AssocItemKind::Const(c) => (c.defaultness, &c.ty, &c.body, Some(&c.generics)),
             _ => unreachable!(),
         };
         StaticParts {
@@ -2099,7 +2099,7 @@ impl<'a> StaticParts<'a> {
             generics,
             ty,
             mutability: ast::Mutability::Not,
-            expr_opt: expr.as_ref(),
+            expr_opt: body.as_ref().map(|ct| &ct.value),
             defaultness: Some(defaultness),
             span: ii.span,
         }