Fix tools

Author: BoxyUwU

compiler/rustc_codegen_cranelift/src/intrinsics/simd.rs

@@ -2,7 +2,7 @@
 
 use cranelift_codegen::ir::immediates::Offset32;
 use rustc_abi::Endian;
-use rustc_middle::ty::SimdAlign;
+use rustc_middle::ty::{SimdAlign, ValTreeKindExt};
 
 use super::*;
 use crate::prelude::*;
@@ -143,7 +143,10 @@ pub(super) fn codegen_simd_intrinsic_call<'tcx>(
 
             let total_len = lane_count * 2;
 
-            let indexes = idx.iter().map(|idx| idx.unwrap_leaf().to_u32()).collect::<Vec<u32>>();
+            let indexes = idx
+                .iter()
+                .map(|idx| idx.to_value().valtree.unwrap_leaf().to_u32())
+                .collect::<Vec<u32>>();
 
             for &idx in &indexes {
                 assert!(u64::from(idx) < total_len, "idx {} out of range 0..{}", idx, total_len);
@@ -962,6 +965,8 @@ pub(super) fn codegen_simd_intrinsic_call<'tcx>(
             let ptr_val = ptr.load_scalar(fx);
 
             let alignment = generic_args[3].expect_const().to_value().valtree.unwrap_branch()[0]
+                .to_value()
+                .valtree
                 .unwrap_leaf()
                 .to_simd_alignment();
 
@@ -1007,6 +1012,8 @@ pub(super) fn codegen_simd_intrinsic_call<'tcx>(
             let ret_lane_layout = fx.layout_of(ret_lane_ty);
 
             let alignment = generic_args[3].expect_const().to_value().valtree.unwrap_branch()[0]
+                .to_value()
+                .valtree
                 .unwrap_leaf()
                 .to_simd_alignment();
 
@@ -1060,6 +1067,8 @@ pub(super) fn codegen_simd_intrinsic_call<'tcx>(
             let ptr_val = ptr.load_scalar(fx);
 
             let alignment = generic_args[3].expect_const().to_value().valtree.unwrap_branch()[0]
+                .to_value()
+                .valtree
                 .unwrap_leaf()
                 .to_simd_alignment();
 

src/librustdoc/clean/mod.rs

@@ -319,6 +319,9 @@ pub(crate) fn clean_const<'tcx>(constant: &hir::ConstArg<'tcx>) -> ConstantKind
         hir::ConstArgKind::Path(qpath) => {
             ConstantKind::Path { path: qpath_to_string(qpath).into() }
         }
+        hir::ConstArgKind::Struct(..) => {
+            ConstantKind::Path { path: "/* STRUCT EXPR */".to_string().into() }
+        }
         hir::ConstArgKind::Anon(anon) => ConstantKind::Anonymous { body: anon.body },
         hir::ConstArgKind::Infer(..) | hir::ConstArgKind::Error(..) => ConstantKind::Infer,
     }
@@ -1806,7 +1809,7 @@ pub(crate) fn clean_ty<'tcx>(ty: &hir::Ty<'tcx>, cx: &mut DocContext<'tcx>) -> T
                     let ct = cx.tcx.normalize_erasing_regions(typing_env, ct);
                     print_const(cx, ct)
                 }
-                hir::ConstArgKind::Path(..) => {
+                hir::ConstArgKind::Struct(..) | hir::ConstArgKind::Path(..) => {
                     let ct = lower_const_arg_for_rustdoc(cx.tcx, const_arg, FeedConstTy::No);
                     print_const(cx, ct)
                 }

src/librustdoc/clean/utils.rs

@@ -12,7 +12,9 @@ use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::{DefId, LOCAL_CRATE, LocalDefId};
 use rustc_metadata::rendered_const;
 use rustc_middle::mir;
-use rustc_middle::ty::{self, GenericArgKind, GenericArgsRef, TyCtxt, TypeVisitableExt};
+use rustc_middle::ty::{
+    self, GenericArgKind, GenericArgsRef, TyCtxt, TypeVisitableExt, ValTreeKindExt,
+};
 use rustc_span::symbol::{Symbol, kw, sym};
 use tracing::{debug, warn};
 use {rustc_ast as ast, rustc_hir as hir};

src/tools/clippy/clippy_lints/src/utils/author.rs

@@ -319,6 +319,7 @@ impl<'a, 'tcx> PrintVisitor<'a, 'tcx> {
                 chain!(self, "let ConstArgKind::Anon({anon_const}) = {const_arg}.kind");
                 self.body(field!(anon_const.body));
             },
+            ConstArgKind::Struct(..) => chain!(self, "let ConstArgKind::Struct(..) = {const_arg}.kind"),
             ConstArgKind::Infer(..) => chain!(self, "let ConstArgKind::Infer(..) = {const_arg}.kind"),
             ConstArgKind::Error(..) => chain!(self, "let ConstArgKind::Error(..) = {const_arg}.kind"),
         }

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

@@ -1139,7 +1139,7 @@ pub fn const_item_rhs_to_expr<'tcx>(tcx: TyCtxt<'tcx>, ct_rhs: ConstItemRhs<'tcx
         ConstItemRhs::Body(body_id) => Some(tcx.hir_body(body_id).value),
         ConstItemRhs::TypeConst(const_arg) => match const_arg.kind {
             ConstArgKind::Anon(anon) => Some(tcx.hir_body(anon.body).value),
-            ConstArgKind::Path(_) | ConstArgKind::Error(..) | ConstArgKind::Infer(..) => None,
+            ConstArgKind::Struct(..) | ConstArgKind::Path(_) | ConstArgKind::Error(..) | ConstArgKind::Infer(..) => None,
         },
     }
 }

src/tools/clippy/clippy_utils/src/hir_utils.rs

@@ -477,11 +477,18 @@ impl HirEqInterExpr<'_, '_, '_> {
             (ConstArgKind::Path(l_p), ConstArgKind::Path(r_p)) => self.eq_qpath(l_p, r_p),
             (ConstArgKind::Anon(l_an), ConstArgKind::Anon(r_an)) => self.eq_body(l_an.body, r_an.body),
             (ConstArgKind::Infer(..), ConstArgKind::Infer(..)) => true,
+            (ConstArgKind::Struct(path_a, inits_a), ConstArgKind::Struct(path_b, inits_b)) => {
+                self.eq_qpath(path_a, path_b)
+                && inits_a.iter().zip(*inits_b).all(|(init_a, init_b)| {
+                    self.eq_const_arg(init_a.expr, init_b.expr)
+                })
+            }
             // Use explicit match for now since ConstArg is undergoing flux.
-            (ConstArgKind::Path(..), ConstArgKind::Anon(..))
-            | (ConstArgKind::Anon(..), ConstArgKind::Path(..))
-            | (ConstArgKind::Infer(..) | ConstArgKind::Error(..), _)
-            | (_, ConstArgKind::Infer(..) | ConstArgKind::Error(..)) => false,
+            (ConstArgKind::Path(..), _)
+            | (ConstArgKind::Anon(..), _)
+            | (ConstArgKind::Infer(..), _)
+            | (ConstArgKind::Struct(..), _)
+            | (ConstArgKind::Error(..), _) => false,
         }
     }
 
@@ -1332,6 +1339,12 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {
         match &const_arg.kind {
             ConstArgKind::Path(path) => self.hash_qpath(path),
             ConstArgKind::Anon(anon) => self.hash_body(anon.body),
+            ConstArgKind::Struct(path, inits) => {
+                self.hash_qpath(path);
+                for init in *inits {
+                    self.hash_const_arg(init.expr);
+                }
+            }
             ConstArgKind::Infer(..) | ConstArgKind::Error(..) => {},
         }
     }

src/tools/miri/src/intrinsics/atomic.rs

@@ -1,5 +1,5 @@
 use rustc_middle::mir::BinOp;
-use rustc_middle::ty::AtomicOrdering;
+use rustc_middle::ty::{AtomicOrdering, ValTreeKindExt};
 use rustc_middle::{mir, ty};
 
 use super::check_intrinsic_arg_count;
@@ -31,7 +31,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
 
         let get_ord_at = |i: usize| {
             let ordering = generic_args.const_at(i).to_value();
-            ordering.valtree.unwrap_branch()[0].unwrap_leaf().to_atomic_ordering()
+            ordering.valtree.unwrap_branch()[0].to_value().valtree.unwrap_leaf().to_atomic_ordering()
         };
 
         fn read_ord(ord: AtomicOrdering) -> AtomicReadOrd {