Auto merge of #120080 - cuviper:128-align-packed, r=nikic

Pack u128 in the compiler to mitigate new alignment

This is based on #116672, adding a new `#[repr(packed(8))]` wrapper on `u128` to avoid changing any of the compiler's size assertions. This is needed in two places:

* `SwitchTargets`, otherwise its `SmallVec<[u128; 1]>` gets padded up to 32 bytes.
* `LitKind::Int`, so that entire `enum` can stay 24 bytes.
  * This change definitely has far-reaching effects though, since it's public.

clippy_lints/src/casts/unnecessary_cast.rs

@@ -107,7 +107,7 @@ pub(super) fn check<'tcx>(
             && let Some(src) = snippet_opt(cx, cast_expr.span)
             && cast_to.is_floating_point()
             && let Some(num_lit) = NumericLiteral::from_lit_kind(&src, &lit.node)
-            && let from_nbits = 128 - n.leading_zeros()
+            && let from_nbits = 128 - n.get().leading_zeros()
             && let to_nbits = fp_ty_mantissa_nbits(cast_to)
             && from_nbits != 0
             && to_nbits != 0

clippy_lints/src/implicit_saturating_add.rs

@@ -3,6 +3,7 @@ use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::get_parent_expr;
 use clippy_utils::source::snippet_with_context;
 use rustc_ast::ast::{LitIntType, LitKind};
+use rustc_data_structures::packed::Pu128;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Block, Expr, ExprKind, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass};
@@ -69,7 +70,7 @@ impl<'tcx> LateLintPass<'tcx> for ImplicitSaturatingAdd {
             && clippy_utils::SpanlessEq::new(cx).eq_expr(l, target)
             && BinOpKind::Add == op1.node
             && let ExprKind::Lit(lit) = value.kind
-            && let LitKind::Int(1, LitIntType::Unsuffixed) = lit.node
+            && let LitKind::Int(Pu128(1), LitIntType::Unsuffixed) = lit.node
             && block.expr.is_none()
         {
             let mut app = Applicability::MachineApplicable;

clippy_lints/src/implicit_saturating_sub.rs

@@ -1,6 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::{higher, is_integer_literal, peel_blocks_with_stmt, SpanlessEq};
 use rustc_ast::ast::LitKind;
+use rustc_data_structures::packed::Pu128;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind, QPath};
 use rustc_lint::{LateContext, LateLintPass};
@@ -86,7 +87,7 @@ impl<'tcx> LateLintPass<'tcx> for ImplicitSaturatingSub {
             match cond_num_val.kind {
                 ExprKind::Lit(cond_lit) => {
                     // Check if the constant is zero
-                    if let LitKind::Int(0, _) = cond_lit.node {
+                    if let LitKind::Int(Pu128(0), _) = cond_lit.node {
                         if cx.typeck_results().expr_ty(cond_left).is_signed() {
                         } else {
                             print_lint_and_sugg(cx, var_name, expr);

clippy_lints/src/loops/manual_memcpy.rs

@@ -461,7 +461,7 @@ fn is_array_length_equal_to_range(cx: &LateContext<'_>, start: &Expr<'_>, end: &
         if let ExprKind::Lit(lit) = expr.kind
             && let ast::LitKind::Int(value, _) = lit.node
         {
-            Some(value)
+            Some(value.get())
         } else {
             None
         }

clippy_lints/src/loops/needless_range_loop.rs

@@ -209,8 +209,8 @@ fn is_end_eq_array_len<'tcx>(
         && let Some(arr_len) = arr_len_const.try_eval_target_usize(cx.tcx, cx.param_env)
     {
         return match limits {
-            ast::RangeLimits::Closed => end_int + 1 >= arr_len.into(),
-            ast::RangeLimits::HalfOpen => end_int >= arr_len.into(),
+            ast::RangeLimits::Closed => end_int.get() + 1 >= arr_len.into(),
+            ast::RangeLimits::HalfOpen => end_int.get() >= arr_len.into(),
         };
     }
 

clippy_lints/src/manual_bits.rs

@@ -3,6 +3,7 @@ use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::get_parent_expr;
 use clippy_utils::source::snippet_with_context;
 use rustc_ast::ast::LitKind;
+use rustc_data_structures::packed::Pu128;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind, GenericArg, QPath};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
@@ -62,7 +63,7 @@ impl<'tcx> LateLintPass<'tcx> for ManualBits {
             && let Some((real_ty, resolved_ty, other_expr)) = get_one_size_of_ty(cx, left_expr, right_expr)
             && matches!(resolved_ty.kind(), ty::Int(_) | ty::Uint(_))
             && let ExprKind::Lit(lit) = &other_expr.kind
-            && let LitKind::Int(8, _) = lit.node
+            && let LitKind::Int(Pu128(8), _) = lit.node
         {
             let mut app = Applicability::MachineApplicable;
             let ty_snip = snippet_with_context(cx, real_ty.span, ctxt, "..", &mut app).0;

clippy_lints/src/manual_range_patterns.rs

@@ -45,7 +45,7 @@ fn expr_as_i128(expr: &Expr<'_>) -> Option<i128> {
         && let LitKind::Int(num, _) = lit.node
     {
         // Intentionally not handling numbers greater than i128::MAX (for u128 literals) for now.
-        num.try_into().ok()
+        num.get().try_into().ok()
     } else {
         None
     }

clippy_lints/src/manual_strip.rs

@@ -161,7 +161,7 @@ fn eq_pattern_length<'tcx>(cx: &LateContext<'tcx>, pattern: &Expr<'_>, expr: &'t
         ..
     }) = expr.kind
     {
-        constant_length(cx, pattern).map_or(false, |length| length == *n)
+        constant_length(cx, pattern).map_or(false, |length| *n == length)
     } else {
         len_arg(cx, expr).map_or(false, |arg| eq_expr_value(cx, pattern, arg))
     }

clippy_lints/src/matches/match_same_arms.rs

@@ -293,7 +293,7 @@ impl<'a> NormalizedPat<'a> {
                     LitKind::ByteStr(ref bytes, _) | LitKind::CStr(ref bytes, _) => Self::LitBytes(bytes),
                     LitKind::Byte(val) => Self::LitInt(val.into()),
                     LitKind::Char(val) => Self::LitInt(val.into()),
-                    LitKind::Int(val, _) => Self::LitInt(val),
+                    LitKind::Int(val, _) => Self::LitInt(val.get()),
                     LitKind::Bool(val) => Self::LitBool(val),
                     LitKind::Float(..) | LitKind::Err => Self::Wild,
                 },
@@ -305,7 +305,7 @@ impl<'a> NormalizedPat<'a> {
                     None => 0,
                     Some(e) => match &e.kind {
                         ExprKind::Lit(lit) => match lit.node {
-                            LitKind::Int(val, _) => val,
+                            LitKind::Int(val, _) => val.get(),
                             LitKind::Char(val) => val.into(),
                             LitKind::Byte(val) => val.into(),
                             _ => return Self::Wild,
@@ -317,7 +317,7 @@ impl<'a> NormalizedPat<'a> {
                     None => (u128::MAX, RangeEnd::Included),
                     Some(e) => match &e.kind {
                         ExprKind::Lit(lit) => match lit.node {
-                            LitKind::Int(val, _) => (val, bounds),
+                            LitKind::Int(val, _) => (val.get(), bounds),
                             LitKind::Char(val) => (val.into(), bounds),
                             LitKind::Byte(val) => (val.into(), bounds),
                             _ => return Self::Wild,

clippy_lints/src/methods/get_first.rs

@@ -2,6 +2,7 @@ use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_ast::LitKind;
+use rustc_data_structures::packed::Pu128;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
@@ -20,7 +21,7 @@ pub(super) fn check<'tcx>(
         && let Some(impl_id) = cx.tcx.impl_of_method(method_id)
         && let identity = cx.tcx.type_of(impl_id).instantiate_identity()
         && let hir::ExprKind::Lit(Spanned {
-            node: LitKind::Int(0, _),
+            node: LitKind::Int(Pu128(0), _),
             ..
         }) = arg.kind
     {

clippy_lints/src/methods/iter_out_of_bounds.rs

@@ -13,7 +13,7 @@ fn expr_as_u128(cx: &LateContext<'_>, e: &Expr<'_>) -> Option<u128> {
     if let ExprKind::Lit(lit) = expr_or_init(cx, e).kind
         && let LitKind::Int(n, _) = lit.node
     {
-        Some(n)
+        Some(n.get())
     } else {
         None
     }

clippy_lints/src/methods/seek_from_current.rs

@@ -1,4 +1,5 @@
 use rustc_ast::ast::{LitIntType, LitKind};
+use rustc_data_structures::packed::Pu128;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::LateContext;
@@ -41,7 +42,7 @@ fn arg_is_seek_from_current<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>)
         // check if argument of `SeekFrom::Current` is `0`
         if args.len() == 1
             && let ExprKind::Lit(lit) = args[0].kind
-            && let LitKind::Int(0, LitIntType::Unsuffixed) = lit.node
+            && let LitKind::Int(Pu128(0), LitIntType::Unsuffixed) = lit.node
         {
             return true;
         }

clippy_lints/src/methods/seek_to_start_instead_of_rewind.rs

@@ -2,6 +2,7 @@ use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::ty::implements_trait;
 use clippy_utils::{is_expr_used_or_unified, match_def_path, paths};
 use rustc_ast::ast::{LitIntType, LitKind};
+use rustc_data_structures::packed::Pu128;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::LateContext;
@@ -31,7 +32,7 @@ pub(super) fn check<'tcx>(
         && match_def_path(cx, def_id, &paths::STD_IO_SEEKFROM_START)
         && args1.len() == 1
         && let ExprKind::Lit(lit) = args1[0].kind
-        && let LitKind::Int(0, LitIntType::Unsuffixed) = lit.node
+        && let LitKind::Int(Pu128(0), LitIntType::Unsuffixed) = lit.node
     {
         let method_call_span = expr.span.with_lo(name_span.lo());
         span_lint_and_then(

clippy_lints/src/methods/unnecessary_fold.rs

@@ -2,6 +2,7 @@ use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::{is_trait_method, path_to_local_id, peel_blocks, strip_pat_refs};
 use rustc_ast::ast;
+use rustc_data_structures::packed::Pu128;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::PatKind;
@@ -150,7 +151,7 @@ pub(super) fn check(
                     },
                 );
             },
-            ast::LitKind::Int(0, _) => check_fold_with_op(
+            ast::LitKind::Int(Pu128(0), _) => check_fold_with_op(
                 cx,
                 expr,
                 acc,
@@ -162,7 +163,7 @@ pub(super) fn check(
                     method_name: "sum",
                 },
             ),
-            ast::LitKind::Int(1, _) => {
+            ast::LitKind::Int(Pu128(1), _) => {
                 check_fold_with_op(
                     cx,
                     expr,

clippy_lints/src/methods/vec_resize_to_zero.rs

@@ -1,6 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_ast::LitKind;
+use rustc_data_structures::packed::Pu128;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::LateContext;
@@ -20,7 +21,7 @@ pub(super) fn check<'tcx>(
         && let Some(impl_id) = cx.tcx.impl_of_method(method_id)
         && is_type_diagnostic_item(cx, cx.tcx.type_of(impl_id).instantiate_identity(), sym::Vec)
         && let ExprKind::Lit(Spanned {
-            node: LitKind::Int(0, _),
+            node: LitKind::Int(Pu128(0), _),
             ..
         }) = count_arg.kind
         && let ExprKind::Lit(Spanned {

clippy_lints/src/missing_asserts_for_indexing.rs

@@ -7,6 +7,7 @@ use clippy_utils::source::snippet;
 use clippy_utils::visitors::for_each_expr;
 use clippy_utils::{eq_expr_value, hash_expr, higher};
 use rustc_ast::{LitKind, RangeLimits};
+use rustc_data_structures::packed::Pu128;
 use rustc_data_structures::unhash::UnhashMap;
 use rustc_errors::{Applicability, Diagnostic};
 use rustc_hir::{BinOp, Block, Body, Expr, ExprKind, UnOp};
@@ -102,8 +103,8 @@ fn len_comparison<'hir>(
 ) -> Option<(LengthComparison, usize, &'hir Expr<'hir>)> {
     macro_rules! int_lit_pat {
         ($id:ident) => {
-            ExprKind::Lit(Spanned {
-                node: LitKind::Int($id, _),
+            ExprKind::Lit(&Spanned {
+                node: LitKind::Int(Pu128($id), _),
                 ..
             })
         };
@@ -112,13 +113,13 @@ fn len_comparison<'hir>(
     // normalize comparison, `v.len() > 4` becomes `4 < v.len()`
     // this simplifies the logic a bit
     let (op, left, right) = normalize_comparison(bin_op.node, left, right)?;
-    match (op, &left.kind, &right.kind) {
-        (Rel::Lt, int_lit_pat!(left), _) => Some((LengthComparison::IntLessThanLength, *left as usize, right)),
-        (Rel::Lt, _, int_lit_pat!(right)) => Some((LengthComparison::LengthLessThanInt, *right as usize, left)),
-        (Rel::Le, int_lit_pat!(left), _) => Some((LengthComparison::IntLessThanOrEqualLength, *left as usize, right)),
-        (Rel::Le, _, int_lit_pat!(right)) => Some((LengthComparison::LengthLessThanOrEqualInt, *right as usize, left)),
-        (Rel::Eq, int_lit_pat!(left), _) => Some((LengthComparison::LengthEqualInt, *left as usize, right)),
-        (Rel::Eq, _, int_lit_pat!(right)) => Some((LengthComparison::LengthEqualInt, *right as usize, left)),
+    match (op, left.kind, right.kind) {
+        (Rel::Lt, int_lit_pat!(left), _) => Some((LengthComparison::IntLessThanLength, left as usize, right)),
+        (Rel::Lt, _, int_lit_pat!(right)) => Some((LengthComparison::LengthLessThanInt, right as usize, left)),
+        (Rel::Le, int_lit_pat!(left), _) => Some((LengthComparison::IntLessThanOrEqualLength, left as usize, right)),
+        (Rel::Le, _, int_lit_pat!(right)) => Some((LengthComparison::LengthLessThanOrEqualInt, right as usize, left)),
+        (Rel::Eq, int_lit_pat!(left), _) => Some((LengthComparison::LengthEqualInt, left as usize, right)),
+        (Rel::Eq, _, int_lit_pat!(right)) => Some((LengthComparison::LengthEqualInt, right as usize, left)),
         _ => None,
     }
 }
@@ -206,14 +207,14 @@ impl<'hir> IndexEntry<'hir> {
 /// for `..=5` this returns `Some(5)`
 fn upper_index_expr(expr: &Expr<'_>) -> Option<usize> {
     if let ExprKind::Lit(lit) = &expr.kind
-        && let LitKind::Int(index, _) = lit.node
+        && let LitKind::Int(Pu128(index), _) = lit.node
     {
         Some(index as usize)
     } else if let Some(higher::Range {
         end: Some(end), limits, ..
     }) = higher::Range::hir(expr)
         && let ExprKind::Lit(lit) = &end.kind
-        && let LitKind::Int(index @ 1.., _) = lit.node
+        && let LitKind::Int(Pu128(index @ 1..), _) = lit.node
     {
         match limits {
             RangeLimits::HalfOpen => Some(index as usize - 1),

clippy_lints/src/operators/arithmetic_side_effects.rs

@@ -151,7 +151,7 @@ impl ArithmeticSideEffects {
         if let hir::ExprKind::Lit(lit) = actual.kind
             && let ast::LitKind::Int(n, _) = lit.node
         {
-            return Some(n);
+            return Some(n.get());
         }
         if let Some(Constant::Int(n)) = constant(cx, cx.typeck_results(), expr) {
             return Some(n);

clippy_lints/src/operators/verbose_bit_mask.rs

@@ -1,6 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::sugg::Sugg;
 use rustc_ast::ast::LitKind;
+use rustc_data_structures::packed::Pu128;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::LateContext;
@@ -19,9 +20,9 @@ pub(super) fn check<'tcx>(
         && let ExprKind::Binary(op1, left1, right1) = &left.kind
         && BinOpKind::BitAnd == op1.node
         && let ExprKind::Lit(lit) = &right1.kind
-        && let LitKind::Int(n, _) = lit.node
+        && let LitKind::Int(Pu128(n), _) = lit.node
         && let ExprKind::Lit(lit1) = &right.kind
-        && let LitKind::Int(0, _) = lit1.node
+        && let LitKind::Int(Pu128(0), _) = lit1.node
         && n.leading_zeros() == n.count_zeros()
         && n > u128::from(threshold)
     {

clippy_utils/src/consts.rs

@@ -275,7 +275,7 @@ pub fn lit_to_mir_constant<'tcx>(lit: &LitKind, ty: Option<Ty<'tcx>>) -> Constan
         LitKind::Byte(b) => Constant::Int(u128::from(b)),
         LitKind::ByteStr(ref s, _) | LitKind::CStr(ref s, _) => Constant::Binary(Lrc::clone(s)),
         LitKind::Char(c) => Constant::Char(c),
-        LitKind::Int(n, _) => Constant::Int(n),
+        LitKind::Int(n, _) => Constant::Int(n.get()),
         LitKind::Float(ref is, LitFloatType::Suffixed(fty)) => match fty {
             ast::FloatTy::F32 => Constant::F32(is.as_str().parse().unwrap()),
             ast::FloatTy::F64 => Constant::F64(is.as_str().parse().unwrap()),

clippy_utils/src/lib.rs

@@ -80,6 +80,7 @@ use std::sync::{Mutex, MutexGuard, OnceLock};
 use itertools::Itertools;
 use rustc_ast::ast::{self, LitKind, RangeLimits};
 use rustc_data_structures::fx::FxHashMap;
+use rustc_data_structures::packed::Pu128;
 use rustc_data_structures::unhash::UnhashMap;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::{CrateNum, DefId, LocalDefId, LocalModDefId, LOCAL_CRATE};
@@ -838,7 +839,7 @@ pub fn is_default_equivalent_call(cx: &LateContext<'_>, repl_func: &Expr<'_>) ->
 pub fn is_default_equivalent(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
     match &e.kind {
         ExprKind::Lit(lit) => match lit.node {
-            LitKind::Bool(false) | LitKind::Int(0, _) => true,
+            LitKind::Bool(false) | LitKind::Int(Pu128(0), _) => true,
             LitKind::Str(s, _) => s.is_empty(),
             _ => false,
         },