Auto merge of #149750 - Zalathar:rollup-9qjiz5r, r=Zalathar

Rollup of 8 pull requests

Successful merges:

 - #148935 (Fix division syntax in doc comments)
 - #149207 (Add `ilog10` result range hints)
 - #149676 (Tidying up tests/ui/issues tests [3/N])
 - #149710 (Move ambient gdb discovery from compiletest to bootstrap)
 - #149714 (Check associated type where-clauses for lifetimes)
 - #149722 (contracts: fix lowering final declaration without trailing semicolon)
 - #149736 (contracts: clean up feature flag warning duplicated across tests)
 - #149739 (mailmap: add binarycat)

r? `@ghost`
`@rustbot` modify labels: rollup

Author: bors

.mailmap

@@ -83,6 +83,7 @@ Ben Sago <[email protected]> <[email protected]>
 Ben Striegel <[email protected]>
 Benjamin Jackman <[email protected]>
 Benoît Cortier <[email protected]>
+binarycat <[email protected]> lolbinarycat <[email protected]> <[email protected]>
 Bheesham Persaud <[email protected]> Bheesham Persaud <[email protected]>
 bjorn3 <[email protected]> <[email protected]>
 bjorn3 <[email protected]> <[email protected]>

compiler/rustc_ast_lowering/src/contract.rs

@@ -23,7 +23,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         // The order in which things are lowered is important! I.e to
         // refer to variables in contract_decls from postcond/precond,
         // we must lower it first!
-        let contract_decls = self.lower_stmts(&contract.declarations).0;
+        let contract_decls = self.lower_decls(contract);
 
         match (&contract.requires, &contract.ensures) {
             (Some(req), Some(ens)) => {
@@ -124,6 +124,18 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         }
     }
 
+    fn lower_decls(&mut self, contract: &rustc_ast::FnContract) -> &'hir [rustc_hir::Stmt<'hir>] {
+        let (decls, decls_tail) = self.lower_stmts(&contract.declarations);
+
+        if let Some(e) = decls_tail {
+            // include the tail expression in the declaration statements
+            let tail = self.stmt_expr(e.span, *e);
+            self.arena.alloc_from_iter(decls.into_iter().map(|d| *d).chain([tail].into_iter()))
+        } else {
+            decls
+        }
+    }
+
     /// Lower the precondition check intrinsic.
     fn lower_precond(&mut self, req: &Box<rustc_ast::Expr>) -> rustc_hir::Stmt<'hir> {
         let lowered_req = self.lower_expr_mut(&req);

compiler/rustc_ast_passes/src/feature_gate.rs

@@ -301,17 +301,12 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
         visit::walk_ty(self, ty)
     }
 
-    fn visit_generics(&mut self, g: &'a ast::Generics) {
-        for predicate in &g.where_clause.predicates {
-            match &predicate.kind {
-                ast::WherePredicateKind::BoundPredicate(bound_pred) => {
-                    // A type bound (e.g., `for<'c> Foo: Send + Clone + 'c`).
-                    self.check_late_bound_lifetime_defs(&bound_pred.bound_generic_params);
-                }
-                _ => {}
-            }
+    fn visit_where_predicate_kind(&mut self, kind: &'a ast::WherePredicateKind) {
+        if let ast::WherePredicateKind::BoundPredicate(bound) = kind {
+            // A type bound (e.g., `for<'c> Foo: Send + Clone + 'c`).
+            self.check_late_bound_lifetime_defs(&bound.bound_generic_params);
         }
-        visit::walk_generics(self, g);
+        visit::walk_where_predicate_kind(self, kind);
     }
 
     fn visit_fn_ret_ty(&mut self, ret_ty: &'a ast::FnRetTy) {

library/core/src/num/f128.rs

@@ -1753,7 +1753,8 @@ impl f128 {
         q
     }
 
-    /// Calculates the least nonnegative remainder of `self (mod rhs)`.
+    /// Calculates the least nonnegative remainder of `self` when
+    /// divided by `rhs`.
     ///
     /// In particular, the return value `r` satisfies `0.0 <= r < rhs.abs()` in
     /// most cases. However, due to a floating point round-off error it can

library/core/src/num/f16.rs

@@ -1728,7 +1728,8 @@ impl f16 {
         q
     }
 
-    /// Calculates the least nonnegative remainder of `self (mod rhs)`.
+    /// Calculates the least nonnegative remainder of `self` when
+    /// divided by `rhs`.
     ///
     /// In particular, the return value `r` satisfies `0.0 <= r < rhs.abs()` in
     /// most cases. However, due to a floating point round-off error it can

library/core/src/num/int_log10.rs

@@ -1,9 +1,11 @@
 //! These functions compute the integer logarithm of their type, assuming
 //! that someone has already checked that the value is strictly positive.
 
+use crate::num::NonZero;
+
 // 0 < val <= u8::MAX
 #[inline]
-pub(super) const fn u8(val: u8) -> u32 {
+const fn u8_impl(val: u8) -> u32 {
     let val = val as u32;
 
     // For better performance, avoid branches by assembling the solution
@@ -45,13 +47,13 @@ const fn less_than_5(val: u32) -> u32 {
 
 // 0 < val <= u16::MAX
 #[inline]
-pub(super) const fn u16(val: u16) -> u32 {
+const fn u16_impl(val: u16) -> u32 {
     less_than_5(val as u32)
 }
 
 // 0 < val <= u32::MAX
 #[inline]
-pub(super) const fn u32(mut val: u32) -> u32 {
+const fn u32_impl(mut val: u32) -> u32 {
     let mut log = 0;
     if val >= 100_000 {
         val /= 100_000;
@@ -62,7 +64,7 @@ pub(super) const fn u32(mut val: u32) -> u32 {
 
 // 0 < val <= u64::MAX
 #[inline]
-pub(super) const fn u64(mut val: u64) -> u32 {
+const fn u64_impl(mut val: u64) -> u32 {
     let mut log = 0;
     if val >= 10_000_000_000 {
         val /= 10_000_000_000;
@@ -77,66 +79,87 @@ pub(super) const fn u64(mut val: u64) -> u32 {
 
 // 0 < val <= u128::MAX
 #[inline]
-pub(super) const fn u128(mut val: u128) -> u32 {
+const fn u128_impl(mut val: u128) -> u32 {
     let mut log = 0;
     if val >= 100_000_000_000_000_000_000_000_000_000_000 {
         val /= 100_000_000_000_000_000_000_000_000_000_000;
         log += 32;
-        return log + u32(val as u32);
+        return log + u32_impl(val as u32);
     }
     if val >= 10_000_000_000_000_000 {
         val /= 10_000_000_000_000_000;
         log += 16;
     }
-    log + u64(val as u64)
+    log + u64_impl(val as u64)
 }
 
-#[cfg(target_pointer_width = "16")]
-#[inline]
-pub(super) const fn usize(val: usize) -> u32 {
-    u16(val as _)
-}
+macro_rules! define_unsigned_ilog10 {
+    ($($ty:ident => $impl_fn:ident,)*) => {$(
+        #[inline]
+        pub(super) const fn $ty(val: NonZero<$ty>) -> u32 {
+            let result = $impl_fn(val.get());
 
-#[cfg(target_pointer_width = "32")]
-#[inline]
-pub(super) const fn usize(val: usize) -> u32 {
-    u32(val as _)
-}
+            // SAFETY: Integer logarithm is monotonic non-decreasing, so the computed `result` cannot
+            // exceed the value produced for the maximum input.
+            unsafe { crate::hint::assert_unchecked(result <= const { $impl_fn($ty::MAX) }) };
 
-#[cfg(target_pointer_width = "64")]
-#[inline]
-pub(super) const fn usize(val: usize) -> u32 {
-    u64(val as _)
+            result
+        }
+    )*};
 }
 
-// 0 < val <= i8::MAX
-#[inline]
-pub(super) const fn i8(val: i8) -> u32 {
-    u8(val as u8)
+define_unsigned_ilog10! {
+    u8 => u8_impl,
+    u16 => u16_impl,
+    u32 => u32_impl,
+    u64 => u64_impl,
+    u128 => u128_impl,
 }
 
-// 0 < val <= i16::MAX
 #[inline]
-pub(super) const fn i16(val: i16) -> u32 {
-    u16(val as u16)
-}
+pub(super) const fn usize(val: NonZero<usize>) -> u32 {
+    #[cfg(target_pointer_width = "16")]
+    let impl_fn = u16;
 
-// 0 < val <= i32::MAX
-#[inline]
-pub(super) const fn i32(val: i32) -> u32 {
-    u32(val as u32)
+    #[cfg(target_pointer_width = "32")]
+    let impl_fn = u32;
+
+    #[cfg(target_pointer_width = "64")]
+    let impl_fn = u64;
+
+    // SAFETY: We have selected the correct `impl_fn`, so the converting `val` to the argument is
+    // safe.
+    impl_fn(unsafe { NonZero::new_unchecked(val.get() as _) })
 }
 
-// 0 < val <= i64::MAX
-#[inline]
-pub(super) const fn i64(val: i64) -> u32 {
-    u64(val as u64)
+macro_rules! define_signed_ilog10 {
+    ($($ty:ident => $impl_fn:ident,)*) => {$(
+        // 0 < val <= $ty::MAX
+        #[inline]
+        pub(super) const fn $ty(val: $ty) -> Option<u32> {
+            if val > 0 {
+                let result = $impl_fn(val.cast_unsigned());
+
+                // SAFETY: Integer logarithm is monotonic non-decreasing, so the computed `result`
+                // cannot exceed the value produced for the maximum input.
+                unsafe {
+                    crate::hint::assert_unchecked(result <= const { $impl_fn($ty::MAX.cast_unsigned()) });
+                }
+
+                Some(result)
+            } else {
+                None
+            }
+        }
+    )*};
 }
 
-// 0 < val <= i128::MAX
-#[inline]
-pub(super) const fn i128(val: i128) -> u32 {
-    u128(val as u128)
+define_signed_ilog10! {
+    i8 => u8_impl,
+    i16 => u16_impl,
+    i32 => u32_impl,
+    i64 => u64_impl,
+    i128 => u128_impl,
 }
 
 /// Instantiate this panic logic once, rather than for all the ilog methods

library/core/src/num/int_macros.rs

@@ -3147,7 +3147,8 @@ macro_rules! int_impl {
         }
 
 
-        /// Calculates the least nonnegative remainder of `self (mod rhs)`.
+        /// Calculates the least nonnegative remainder of `self` when
+        /// divided by `rhs`.
         ///
         /// This is done as if by the Euclidean division algorithm -- given
         /// `r = self.rem_euclid(rhs)`, the result satisfies
@@ -3527,11 +3528,7 @@ macro_rules! int_impl {
                       without modifying the original"]
         #[inline]
         pub const fn checked_ilog10(self) -> Option<u32> {
-            if self > 0 {
-                Some(int_log10::$ActualT(self as $ActualT))
-            } else {
-                None
-            }
+            int_log10::$ActualT(self as $ActualT)
         }
 
         /// Computes the absolute value of `self`.

library/core/src/num/nonzero.rs

@@ -1657,7 +1657,7 @@ macro_rules! nonzero_integer_signedness_dependent_methods {
                       without modifying the original"]
         #[inline]
         pub const fn ilog10(self) -> u32 {
-            super::int_log10::$Int(self.get())
+            super::int_log10::$Int(self)
         }
 
         /// Calculates the midpoint (average) between `self` and `rhs`.

library/core/src/num/uint_macros.rs

@@ -3481,7 +3481,8 @@ macro_rules! uint_impl {
         }
 
 
-        /// Calculates the least remainder of `self (mod rhs)`.
+        /// Calculates the least remainder of `self` when divided by
+        /// `rhs`.
         ///
         /// Since, for the positive integers, all common
         /// definitions of division are equal, this

library/std/src/num/f32.rs

@@ -252,7 +252,8 @@ impl f32 {
         core::f32::math::div_euclid(self, rhs)
     }
 
-    /// Calculates the least nonnegative remainder of `self (mod rhs)`.
+    /// Calculates the least nonnegative remainder of `self` when divided by
+    /// `rhs`.
     ///
     /// In particular, the return value `r` satisfies `0.0 <= r < rhs.abs()` in
     /// most cases. However, due to a floating point round-off error it can