user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Move bigint helper tracking issues

Browse source
This commit is contained in:
ltdk 2026-02-02 17:34:15 -05:00
parent f60a0f1bcc
commit 28feae0c87
7 changed files with 31 additions and 30 deletions
Download patch file Download diff file Expand all files Collapse all files

4
library/core/src/lib.rs
View file

@ -97,7 +97,6 @@
// tidy-alphabetical-start
#![feature(array_ptr_get)]
#![feature(asm_experimental_arch)]
#![feature(bigint_helper_methods)]
#![feature(bstr)]
#![feature(bstr_internals)]
#![feature(cfg_select)]
@ -107,6 +106,7 @@
#![feature(const_destruct)]
#![feature(const_eval_select)]
#![feature(const_select_unpredictable)]
#![feature(const_unsigned_bigint_helpers)]
#![feature(core_intrinsics)]
#![feature(coverage_attribute)]
#![feature(disjoint_bitor)]
@ -120,6 +120,7 @@
#![feature(ptr_alignment_type)]
#![feature(ptr_metadata)]
#![feature(set_ptr_value)]
#![feature(signed_bigint_helpers)]
#![feature(slice_ptr_get)]
#![feature(str_internals)]
#![feature(str_split_inclusive_remainder)]
@ -129,6 +130,7 @@
#![feature(unsafe_pinned)]
#![feature(utf16_extra)]
#![feature(variant_count)]
#![feature(widening_mul)]
// tidy-alphabetical-end
//
// Language features:

26
library/core/src/num/int_macros.rs
View file

@ -2522,7 +2522,7 @@ macro_rules! int_impl {
/// # Examples
///
/// ```
/// #![feature(bigint_helper_methods)]
/// #![feature(signed_bigint_helpers)]
/// // Only the most significant word is signed.
/// //
#[doc = concat!("// 10 MAX (a = 10 × 2^", stringify!($BITS), " + 2^", stringify!($BITS), " - 1)")]
@ -2544,7 +2544,7 @@ macro_rules! int_impl {
///
/// assert_eq!((sum1, sum0), (6, 8));
/// ```
#[unstable(feature = "bigint_helper_methods", issue = "85532")]
#[unstable(feature = "signed_bigint_helpers", issue = "151989")]
#[must_use = "this returns the result of the operation, \
without modifying the original"]
#[inline]
@ -2625,7 +2625,7 @@ macro_rules! int_impl {
/// # Examples
///
/// ```
/// #![feature(bigint_helper_methods)]
/// #![feature(signed_bigint_helpers)]
/// // Only the most significant word is signed.
/// //
#[doc = concat!("// 6 8 (a = 6 × 2^", stringify!($BITS), " + 8)")]
@ -2647,7 +2647,7 @@ macro_rules! int_impl {
///
#[doc = concat!("assert_eq!((diff1, diff0), (10, ", stringify!($UnsignedT), "::MAX));")]
/// ```
#[unstable(feature = "bigint_helper_methods", issue = "85532")]
#[unstable(feature = "signed_bigint_helpers", issue = "151989")]
#[must_use = "this returns the result of the operation, \
without modifying the original"]
#[inline]
@ -2717,12 +2717,12 @@ macro_rules! int_impl {
/// Please note that this example is shared among integer types, which is why `i32` is used.
///
/// ```
/// #![feature(bigint_helper_methods)]
/// #![feature(widening_mul)]
/// assert_eq!(5i32.widening_mul(-2), (4294967286, -1));
/// assert_eq!(1_000_000_000i32.widening_mul(-10), (2884901888, -3));
/// ```
#[unstable(feature = "bigint_helper_methods", issue = "85532")]
#[rustc_const_unstable(feature = "bigint_helper_methods", issue = "85532")]
#[unstable(feature = "widening_mul", issue = "152016")]
#[rustc_const_unstable(feature = "widening_mul", issue = "152016")]
#[must_use = "this returns the result of the operation, \
without modifying the original"]
#[inline]
@ -2747,7 +2747,7 @@ macro_rules! int_impl {
/// Please note that this example is shared among integer types, which is why `i32` is used.
///
/// ```
/// #![feature(bigint_helper_methods)]
/// #![feature(signed_bigint_helpers)]
/// assert_eq!(5i32.carrying_mul(-2, 0), (4294967286, -1));
/// assert_eq!(5i32.carrying_mul(-2, 10), (0, 0));
/// assert_eq!(1_000_000_000i32.carrying_mul(-10, 0), (2884901888, -3));
@ -2757,8 +2757,8 @@ macro_rules! int_impl {
"(", stringify!($SelfT), "::MAX.unsigned_abs() + 1, ", stringify!($SelfT), "::MAX / 2));"
)]
/// ```
#[unstable(feature = "bigint_helper_methods", issue = "85532")]
#[rustc_const_unstable(feature = "bigint_helper_methods", issue = "85532")]
#[unstable(feature = "signed_bigint_helpers", issue = "151989")]
#[rustc_const_unstable(feature = "signed_bigint_helpers", issue = "151989")]
#[must_use = "this returns the result of the operation, \
without modifying the original"]
#[inline]
@ -2784,7 +2784,7 @@ macro_rules! int_impl {
/// Please note that this example is shared among integer types, which is why `i32` is used.
///
/// ```
/// #![feature(bigint_helper_methods)]
/// #![feature(signed_bigint_helpers)]
/// assert_eq!(5i32.carrying_mul_add(-2, 0, 0), (4294967286, -1));
/// assert_eq!(5i32.carrying_mul_add(-2, 10, 10), (10, 0));
/// assert_eq!(1_000_000_000i32.carrying_mul_add(-10, 0, 0), (2884901888, -3));
@ -2794,8 +2794,8 @@ macro_rules! int_impl {
"(", stringify!($UnsignedT), "::MAX, ", stringify!($SelfT), "::MAX / 2));"
)]
/// ```
#[unstable(feature = "bigint_helper_methods", issue = "85532")]
#[rustc_const_unstable(feature = "bigint_helper_methods", issue = "85532")]
#[unstable(feature = "signed_bigint_helpers", issue = "151989")]
#[rustc_const_unstable(feature = "signed_bigint_helpers", issue = "151989")]
#[must_use = "this returns the result of the operation, \
without modifying the original"]
#[inline]

24
library/core/src/num/uint_macros.rs
View file

@ -2807,7 +2807,7 @@ macro_rules! uint_impl {
/// assert_eq!((sum1, sum0), (9, 6));
/// ```
#[stable(feature = "unsigned_bigint_helpers", since = "1.91.0")]
#[rustc_const_unstable(feature = "bigint_helper_methods", issue = "85532")]
#[rustc_const_unstable(feature = "const_unsigned_bigint_helpers", issue = "152015")]
#[must_use = "this returns the result of the operation, \
without modifying the original"]
#[inline]
@ -2899,7 +2899,7 @@ macro_rules! uint_impl {
#[doc = concat!("assert_eq!((diff1, diff0), (3, ", stringify!($SelfT), "::MAX));")]
/// ```
#[stable(feature = "unsigned_bigint_helpers", since = "1.91.0")]
#[rustc_const_unstable(feature = "bigint_helper_methods", issue = "85532")]
#[rustc_const_unstable(feature = "const_unsigned_bigint_helpers", issue = "152015")]
#[must_use = "this returns the result of the operation, \
without modifying the original"]
#[inline]
@ -3011,14 +3011,14 @@ macro_rules! uint_impl {
/// # Examples
///
/// ```
/// #![feature(bigint_helper_methods)]
/// #![feature(widening_mul)]
#[doc = concat!("assert_eq!(5_", stringify!($SelfT), ".widening_mul(7), (35, 0));")]
#[doc = concat!("assert_eq!(", stringify!($SelfT), "::MAX.widening_mul(", stringify!($SelfT), "::MAX), (1, ", stringify!($SelfT), "::MAX - 1));")]
/// ```
///
/// Compared to other `*_mul` methods:
/// ```
/// #![feature(bigint_helper_methods)]
/// #![feature(widening_mul)]
#[doc = concat!("assert_eq!(", stringify!($SelfT), "::widening_mul(1 << ", stringify!($BITS_MINUS_ONE), ", 6), (0, 3));")]
#[doc = concat!("assert_eq!(", stringify!($SelfT), "::overflowing_mul(1 << ", stringify!($BITS_MINUS_ONE), ", 6), (0, true));")]
#[doc = concat!("assert_eq!(", stringify!($SelfT), "::wrapping_mul(1 << ", stringify!($BITS_MINUS_ONE), ", 6), 0);")]
@ -3028,12 +3028,12 @@ macro_rules! uint_impl {
/// Please note that this example is shared among integer types, which is why `u32` is used.
///
/// ```
/// #![feature(bigint_helper_methods)]
/// #![feature(widening_mul)]
/// assert_eq!(5u32.widening_mul(2), (10, 0));
/// assert_eq!(1_000_000_000u32.widening_mul(10), (1410065408, 2));
/// ```
#[unstable(feature = "bigint_helper_methods", issue = "85532")]
#[rustc_const_unstable(feature = "bigint_helper_methods", issue = "85532")]
#[unstable(feature = "widening_mul", issue = "152016")]
#[rustc_const_unstable(feature = "widening_mul", issue = "152016")]
#[must_use = "this returns the result of the operation, \
without modifying the original"]
#[inline]
@ -3072,7 +3072,7 @@ macro_rules! uint_impl {
/// implementing it for wider-than-native types.
///
/// ```
/// #![feature(bigint_helper_methods)]
/// #![feature(const_unsigned_bigint_helpers)]
/// fn scalar_mul_eq(little_endian_digits: &mut Vec<u16>, multiplicand: u16) {
/// let mut carry = 0;
/// for d in little_endian_digits.iter_mut() {
@ -3097,7 +3097,7 @@ macro_rules! uint_impl {
/// except that it gives the value of the overflow instead of just whether one happened:
///
/// ```
/// #![feature(bigint_helper_methods)]
/// #![feature(const_unsigned_bigint_helpers)]
/// let r = u8::carrying_mul(7, 13, 0);
/// assert_eq!((r.0, r.1 != 0), u8::overflowing_mul(7, 13));
/// let r = u8::carrying_mul(13, 42, 0);
@ -3109,14 +3109,14 @@ macro_rules! uint_impl {
/// [`wrapping_add`](Self::wrapping_add) methods:
///
/// ```
/// #![feature(bigint_helper_methods)]
/// #![feature(const_unsigned_bigint_helpers)]
/// assert_eq!(
/// 789_u16.carrying_mul(456, 123).0,
/// 789_u16.wrapping_mul(456).wrapping_add(123),
/// );
/// ```
#[stable(feature = "unsigned_bigint_helpers", since = "1.91.0")]
#[rustc_const_unstable(feature = "bigint_helper_methods", issue = "85532")]
#[rustc_const_unstable(feature = "const_unsigned_bigint_helpers", issue = "152015")]
#[must_use = "this returns the result of the operation, \
without modifying the original"]
#[inline]
@ -3182,7 +3182,7 @@ macro_rules! uint_impl {
/// );
/// ```
#[stable(feature = "unsigned_bigint_helpers", since = "1.91.0")]
#[rustc_const_unstable(feature = "bigint_helper_methods", issue = "85532")]
#[rustc_const_unstable(feature = "const_unsigned_bigint_helpers", issue = "152015")]
#[must_use = "this returns the result of the operation, \
without modifying the original"]
#[inline]

4
library/coretests/tests/lib.rs
View file

@ -8,7 +8,6 @@
#![feature(ascii_char_variants)]
#![feature(async_iter_from_iter)]
#![feature(async_iterator)]
#![feature(bigint_helper_methods)]
#![feature(bool_to_result)]
#![feature(bstr)]
#![feature(cfg_target_has_reliable_f16_f128)]
@ -34,6 +33,7 @@
#![feature(const_result_trait_fn)]
#![feature(const_select_unpredictable)]
#![feature(const_trait_impl)]
#![feature(const_unsigned_bigint_helpers)]
#![feature(control_flow_ok)]
#![feature(core_float_math)]
#![feature(core_intrinsics)]
@ -98,6 +98,7 @@
#![feature(portable_simd)]
#![feature(ptr_metadata)]
#![feature(result_option_map_or_default)]
#![feature(signed_bigint_helpers)]
#![feature(slice_from_ptr_range)]
#![feature(slice_index_methods)]
#![feature(slice_internals)]
@ -122,6 +123,7 @@
#![feature(uint_gather_scatter_bits)]
#![feature(unsize)]
#![feature(unwrap_infallible)]
#![feature(widening_mul)]
// tidy-alphabetical-end
#![allow(internal_features)]
#![deny(fuzzy_provenance_casts)]

1
library/stdarch/crates/core_arch/src/lib.rs
View file

@ -33,7 +33,6 @@
f16,
aarch64_unstable_target_feature,
target_feature_inline_always,
bigint_helper_methods,
funnel_shifts,
avx10_target_feature,
const_trait_impl,

1
tests/assembly-llvm/x86_64-bigint-helpers.rs
View file

@ -4,7 +4,6 @@
//@ compile-flags: -C llvm-args=-x86-asm-syntax=intel
#![no_std]
#![feature(bigint_helper_methods)]
// This checks that the `carrying_add` and `borrowing_sub` implementation successfully chain,
// to catch issues like <https://github.com/rust-lang/rust/issues/85532#issuecomment-2495119815>

1
tests/codegen-llvm/bigint-helpers.rs
View file

@ -1,7 +1,6 @@
//@ compile-flags: -C opt-level=3
#![crate_type = "lib"]
#![feature(bigint_helper_methods)]
// Note that there's also an assembly test for this, which is what checks for
// the `ADC` (Add with Carry) instruction on x86 now that the IR we emit uses