Implement strict integer operations that panic on overflow by rmehri01 · Pull Request #116090 · rust-lang/rust

rmehri01 · 2023-09-23T04:50:25Z

This PR implements the first part of the ACP for adding panic on overflow style arithmetic operations (rust-lang/libs-team#270), mentioned in #116064.

It adds the following operations on both signed and unsigned integers:

strict_add
strict_sub
strict_mul
strict_div
strict_div_euclid
strict_rem
strict_rem_euclid
strict_neg
strict_shl
strict_shr
strict_pow

Additionally, signed integers have:

strict_add_unsigned
strict_sub_unsigned
strict_abs

And unsigned integers have:

strict_add_signed

The div and rem operations are the same as normal division and remainder but are added for completeness similar to the corresponding wrapping_* operations.

I'm not sure if I missed any operations, I basically found them from the wrapping_* and checked_* operations on both integer types.

rustbot · 2023-09-23T04:50:33Z

r? @m-ou-se

(rustbot has picked a reviewer for you, use r? to override)

asquared31415 · 2023-09-23T17:44:05Z

All of the exposed methods should probably be #[track_caller] to improve the panic locations.

bors · 2023-09-29T10:24:23Z

☔ The latest upstream changes (presumably #116176) made this pull request unmergeable. Please resolve the merge conflicts.

bors · 2023-11-01T14:55:55Z

☔ The latest upstream changes (presumably #117482) made this pull request unmergeable. Please resolve the merge conflicts.

eduardosm · 2023-11-24T17:00:58Z

cc @RalfJung (I didn't know if you were aware of this PR)

RalfJung · 2023-11-24T19:01:09Z

+        /// #![feature(strict_overflow_ops)]
+        #[doc = concat!("let _ = (", stringify!($SelfT), "::MAX - 2).strict_add(3);")]
+        /// ```
+        #[unstable(feature = "strict_overflow_ops", issue = "116064")]


It's probably better to create a new tracking issue for this, with the tracking issue template.

Good point, I created #118260.

m-ou-se · 2023-11-28T15:00:40Z

+        ///
+        /// ## Overflow behavior
+        ///
+        /// This function will always panic on overflow, regardless of if overflow checks are enabled.


Suggested change

/// This function will always panic on overflow, regardless of if overflow checks are enabled.

/// This function will always panic on overflow, regardless of whether overflow checks are enabled.

m-ou-se · 2023-11-28T15:14:37Z

It'd be useful to add a comment to this file to note that these functions are used by the strict_ methods.

m-ou-se · 2023-11-28T15:17:20Z

@RalfJung How would you feel about removing the descriptions from rustc_middle and instead of calling the panic lang item, making each of the functions below a lang item and calling those? (In a follow-up PR.)

I think description is used in a bunch of places where we really need a string, e.g. for MIR dumping.

But if there's some way to reduce the redundancy here, I'm all for it. This duplication of the panic message in 3 or 4 places has bothered me for a while, I just never found a great way to fix it.

m-ou-se · 2023-11-28T15:18:28Z

+        #[track_caller]
+        pub const fn strict_add(self, rhs: Self) -> Self {
+            let (a, b) = self.overflowing_add(rhs);
+            if unlikely!(b) {overflow_panic::add()} else {a}


Suggested change

if unlikely!(b) {overflow_panic::add()} else {a}

if unlikely!(b) { overflow_panic::add() } else { a }

rmehri01 · 2023-12-02T18:22:39Z

@rustbot review

RalfJung · 2024-01-19T07:09:35Z

@m-ou-se just a reminder that there's a PR waiting for review here :)

m-ou-se · 2024-01-19T15:38:18Z

@bors r+

bors · 2024-01-19T15:38:21Z

📌 Commit 6d17169 has been approved by m-ou-se

It is now in the queue for this repository.

…u-se Implement strict integer operations that panic on overflow This PR implements the first part of the ACP for adding panic on overflow style arithmetic operations (rust-lang/libs-team#270), mentioned in rust-lang#116064. It adds the following operations on both signed and unsigned integers: - `strict_add` - `strict_sub` - `strict_mul` - `strict_div` - `strict_div_euclid` - `strict_rem` - `strict_rem_euclid` - `strict_neg` - `strict_shl` - `strict_shr` - `strict_pow` Additionally, signed integers have: - `strict_add_unsigned` - `strict_sub_unsigned` - `strict_abs` And unsigned integers have: - `strict_add_signed` The `div` and `rem` operations are the same as normal division and remainder but are added for completeness similar to the corresponding `wrapping_*` operations. I'm not sure if I missed any operations, I basically found them from the `wrapping_*` and `checked_*` operations on both integer types.

Rollup of 8 pull requests Successful merges: - rust-lang#116090 (Implement strict integer operations that panic on overflow) - rust-lang#118811 (Use `bool` instead of `PartiolOrd` as return value of the comparison closure in `{slice,Iteraotr}::is_sorted_by`) - rust-lang#119081 (Add Ipv6Addr::is_ipv4_mapped) - rust-lang#119461 (Use an interpreter in MIR jump threading) - rust-lang#119996 (Move OS String implementation into `sys`) - rust-lang#120015 (coverage: Format all coverage tests with `rustfmt`) - rust-lang#120027 (pattern_analysis: Remove `Ty: Copy` bound) - rust-lang#120084 (fix(rust-analyzer): use new pkgid spec to compare) r? `@ghost` `@rustbot` modify labels: rollup

Rollup merge of rust-lang#116090 - rmehri01:strict_integer_ops, r=m-ou-se Implement strict integer operations that panic on overflow This PR implements the first part of the ACP for adding panic on overflow style arithmetic operations (rust-lang/libs-team#270), mentioned in rust-lang#116064. It adds the following operations on both signed and unsigned integers: - `strict_add` - `strict_sub` - `strict_mul` - `strict_div` - `strict_div_euclid` - `strict_rem` - `strict_rem_euclid` - `strict_neg` - `strict_shl` - `strict_shr` - `strict_pow` Additionally, signed integers have: - `strict_add_unsigned` - `strict_sub_unsigned` - `strict_abs` And unsigned integers have: - `strict_add_signed` The `div` and `rem` operations are the same as normal division and remainder but are added for completeness similar to the corresponding `wrapping_*` operations. I'm not sure if I missed any operations, I basically found them from the `wrapping_*` and `checked_*` operations on both integer types.

Add `uX::strict_sub_signed` rust-lang#116090 missed `strict_sub_signed`, adding it here. Part of rust-lang#118260. r? `@m-ou-se`

Add `uX::strict_sub_signed` rust-lang#116090 missed `strict_sub_signed`, adding it here. Part of rust-lang#118260. r? ``@m-ou-se``

Rollup merge of #143282 - nxsaken:strict_sub_signed, r=jhpratt Add `uX::strict_sub_signed` #116090 missed `strict_sub_signed`, adding it here. Part of #118260. r? ``@m-ou-se``

Add `uX::strict_sub_signed` rust-lang/rust#116090 missed `strict_sub_signed`, adding it here. Part of rust-lang/rust#118260. r? ``@m-ou-se``

Add `uX::strict_sub_signed` rust-lang#116090 missed `strict_sub_signed`, adding it here. Part of rust-lang#118260. r? ``@m-ou-se``

@rmehri01

signed strict division: just use normal division For some reason, rust-lang#116090 picked an unnecessarily complicated implementation for this. I don't know if there was any specific reason for this;. Cc @rmehri01 @m-ou-se in case someone remembers. This was pointed out on IRLO: https://internals.rust-lang.org/t/why-is-strict-div-implemented-in-terms-of-overflowing-div-for-signed-integers/24387 Let's just use regular division here, which is consistent with what we do for unsigned types.

@rmehri01

signed strict division: just use normal division For some reason, rust-lang#116090 picked an unnecessarily complicated implementation for this. I don't know if there was any specific reason for this;. Cc @rmehri01 @m-ou-se in case someone remembers. This was pointed out on IRLO: https://internals.rust-lang.org/t/why-is-strict-div-implemented-in-terms-of-overflowing-div-for-signed-integers/24387 Let's just use regular division here, which is consistent with what we do for unsigned types.

@rmehri01

Rollup merge of #158483 - RalfJung:signed-strict-div, r=jhpratt signed strict division: just use normal division For some reason, #116090 picked an unnecessarily complicated implementation for this. I don't know if there was any specific reason for this;. Cc @rmehri01 @m-ou-se in case someone remembers. This was pointed out on IRLO: https://internals.rust-lang.org/t/why-is-strict-div-implemented-in-terms-of-overflowing-div-for-signed-integers/24387 Let's just use regular division here, which is consistent with what we do for unsigned types.

@rmehri01

signed strict division: just use normal division For some reason, rust-lang/rust#116090 picked an unnecessarily complicated implementation for this. I don't know if there was any specific reason for this;. Cc @rmehri01 @m-ou-se in case someone remembers. This was pointed out on IRLO: https://internals.rust-lang.org/t/why-is-strict-div-implemented-in-terms-of-overflowing-div-for-signed-integers/24387 Let's just use regular division here, which is consistent with what we do for unsigned types.

rustbot assigned m-ou-se Sep 23, 2023

rustbot added S-waiting-on-review Status: Awaiting review from the assignee but also interested parties. T-libs Relevant to the library team, which will review and decide on the PR/issue. labels Sep 23, 2023

RalfJung reviewed Nov 24, 2023

View reviewed changes

rmehri01 mentioned this pull request Nov 24, 2023

Tracking Issue for arithmetic that panics on overflow (strict_* operations) #118260

Closed

6 tasks

rmehri01 added 3 commits November 24, 2023 11:45

implement strict_* operations for signed integer types

27f419b

implement strict_* operations for unsigned integer types

fb349a2

add #[track_caller] to improve panic locations

8c7a5b0

m-ou-se reviewed Nov 28, 2023

View reviewed changes

m-ou-se added S-waiting-on-author Status: This is awaiting some action (such as code changes or more information) from the author. and removed S-waiting-on-review Status: Awaiting review from the assignee but also interested parties. labels Nov 28, 2023

reword panic comments and add spaces to unlikely branches

6d17169

rustbot added S-waiting-on-review Status: Awaiting review from the assignee but also interested parties. and removed S-waiting-on-author Status: This is awaiting some action (such as code changes or more information) from the author. labels Dec 2, 2023

RalfJung mentioned this pull request Jan 19, 2024

Add operations for easy arithmetic that panics on overflow #116064

Closed

bors added S-waiting-on-bors Status: Waiting on bors to run and complete tests. Bors will change the label on completion. and removed S-waiting-on-review Status: Awaiting review from the assignee but also interested parties. labels Jan 19, 2024

GuillaumeGomez mentioned this pull request Jan 20, 2024

Rollup of 8 pull requests #120162

Closed

Nadrieril mentioned this pull request Jan 21, 2024

Rollup of 8 pull requests #120187

Merged

bors merged commit b661cd6 into rust-lang:master Jan 21, 2024

rustbot added this to the 1.77.0 milestone Jan 21, 2024

nxsaken mentioned this pull request Jul 1, 2025

Add uX::strict_sub_signed #143282

Merged

rust-timer added a commit that referenced this pull request Jul 20, 2025

Unrolled build for #143282

8de864e

Rollup merge of #143282 - nxsaken:strict_sub_signed, r=jhpratt Add `uX::strict_sub_signed` #116090 missed `strict_sub_signed`, adding it here. Part of #118260. r? ``@m-ou-se``

RalfJung mentioned this pull request Jun 27, 2026

signed strict division: just use normal division #158483

Merged

	/// This function will always panic on overflow, regardless of if overflow checks are enabled.
	/// This function will always panic on overflow, regardless of whether overflow checks are enabled.

	if unlikely!(b) {overflow_panic::add()} else {a}
	if unlikely!(b) { overflow_panic::add() } else { a }

Uh oh!

Uh oh!

Conversation

rmehri01 commented Sep 23, 2023 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

rustbot commented Sep 23, 2023

Uh oh!

asquared31415 commented Sep 23, 2023

Uh oh!

bors commented Sep 29, 2023

Uh oh!

bors commented Nov 1, 2023

Uh oh!

eduardosm commented Nov 24, 2023

Uh oh!

RalfJung Nov 24, 2023

Choose a reason for hiding this comment

Uh oh!

rmehri01 Nov 24, 2023

Choose a reason for hiding this comment

Uh oh!

m-ou-se Nov 28, 2023

Choose a reason for hiding this comment

Uh oh!

m-ou-se Nov 28, 2023

Choose a reason for hiding this comment

Uh oh!

m-ou-se Nov 28, 2023 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

RalfJung Nov 28, 2023 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

m-ou-se Nov 28, 2023

Choose a reason for hiding this comment

Uh oh!

rmehri01 commented Dec 2, 2023

Uh oh!

RalfJung commented Jan 19, 2024

Uh oh!

m-ou-se commented Jan 19, 2024

Uh oh!

bors commented Jan 19, 2024

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

7 participants

rmehri01 commented Sep 23, 2023 •

edited

Loading

m-ou-se Nov 28, 2023 •

edited

Loading

RalfJung Nov 28, 2023 •

edited

Loading