Tracking Issue for unbounded_shifts

[chorman0773]

Feature gate: #![feature(unbounded_shifts)]

This is a tracking issue for ACP 428.

This adds shifts functions to the integer types that ignore type bounds when shifting, with out of range values for the rhs yielding the result of shifting the entire value out (0 for left shifts, and unsigned right shifts, and either 0 or -1 for signed right shifts).

Public API

impl uN{
     pub const fn unbounded_shl(self, rhs: u32) -> Self;
     pub const fn unbounded_shr(self, rhs: u32) -> Self;
}

impl iN{
    pub const fn unbounded_shl(self, rhs: u32) -> Self;
    pub const fn unbounded_shr(self, rhs: u32) -> Self;
}

Steps / History

• Implementation: Add implementations for unbounded_shl/unbounded_shr #129377
• Final comment period (FCP)¹
• Stabilization PR Stabilize unbounded_shifts #137393

Unresolved Questions

• None yet.

Footnotes

1. https://std-dev-guide.rust-lang.org/feature-lifecycle/stabilization.html ↩

[joshtriplett]

This seems ready to stabilize.

@rfcbot merge

[rfcbot]

Team member @joshtriplett has proposed to merge this. The next step is review by the rest of the tagged team members:

• @Amanieu
• @BurntSushi
• @dtolnay
• @joshtriplett
• @m-ou-se

No concerns currently listed.

Once a majority of reviewers approve (and at most 2 approvals are outstanding), this will enter its final comment period. If you spot a major issue that hasn't been raised at any point in this process, please speak up!

See this document for info about what commands tagged team members can give me.

[chorman0773]

I was going to do a stabilization report.

Just to be clear, my intention was to stabilize it both as a function and as a const fn in one shot, so team should keep that in mind during the pFCP.

[chorman0773]

Stabilization Report

(Retroactive to pFCP)

Implementation History

• Implementation was completed in Add implementations for unbounded_shl/unbounded_shr #129377

Api Summary

impl uN{
     pub const fn unbounded_shl(self, rhs: u32) -> Self;
     pub const fn unbounded_shr(self, rhs: u32) -> Self;
}

impl iN{
    pub const fn unbounded_shl(self, rhs: u32) -> Self;
    pub const fn unbounded_shr(self, rhs: u32) -> Self;
}

unbounded_shl and unbounded_shr shifts self left or right by rhs as though with unbounded range. If rhs exceeds the bounds of the type, the result is:

• For unbounded_shl, 0 always
• For unbounded_shr, 0 for unsigned integers and either 0 or -1 (depending on the sign bit)

Experience Report

The Clever-ISA Project Emulator uses the nightly version of these functions to implement same-named functions in a primitive type wrapper. The wrapper functions (particularily unbounded_shr) are then used throughout the emulator to compute a number of different bitmasks.

[scottmcm]

Big fan of stabilizing a canonical way to write "shift that actually works" 👍

(These are the only shifts where shifting by one N times is the same as shifting by N one time.)

[rfcbot]

🔔 This is now entering its final comment period, as per the review above. 🔔

[rfcbot]

The final comment period, with a disposition to merge, as per the review above, is now complete.

As the automated representative of the governance process, I would like to thank the author for their work and everyone else who contributed.

This will be merged soon.