-
Notifications
You must be signed in to change notification settings - Fork 12.8k
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
Add
impl_tag! macro to implement Tag for tagged pointer easily
- Loading branch information
1 parent
13fc33e
commit 77c83c0
Showing
4 changed files
with
244 additions
and
29 deletions.
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
170 changes: 170 additions & 0 deletions
170
compiler/rustc_data_structures/src/tagged_ptr/impl_tag.rs
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,170 @@ | ||
| /// Implements [`Tag`] for a given type. | ||
| /// | ||
| /// You can use `impl_tag` on structs and enums. | ||
| /// You need to specify the type and all its possible values, | ||
| /// which can only be paths with optional fields. | ||
| /// | ||
| /// [`Tag`]: crate::tagged_ptr::Tag | ||
| /// | ||
| /// # Examples | ||
| /// | ||
| /// Basic usage: | ||
| /// | ||
| /// ``` | ||
| /// use rustc_data_structures::{impl_tag, tagged_ptr::Tag}; | ||
| /// | ||
| /// #[derive(Copy, Clone, PartialEq, Debug)] | ||
| /// enum SomeTag { | ||
| /// A, | ||
| /// B, | ||
| /// X { v: bool }, | ||
| /// Y(bool, bool), | ||
| /// } | ||
| /// | ||
| /// impl_tag! { | ||
| /// // The type for which the `Tag` will be implemented | ||
| /// for SomeTag; | ||
| /// // You need to specify the `{value_of_the_type} <=> {tag}` relationship | ||
| /// SomeTag::A <=> 0, | ||
| /// SomeTag::B <=> 1, | ||
| /// // For variants with fields, you need to specify the fields: | ||
| /// SomeTag::X { v: true } <=> 2, | ||
| /// SomeTag::X { v: false } <=> 3, | ||
| /// // For tuple variants use named syntax: | ||
| /// SomeTag::Y { 0: true, 1: true } <=> 4, | ||
| /// SomeTag::Y { 0: false, 1: true } <=> 5, | ||
| /// SomeTag::Y { 0: true, 1: false } <=> 6, | ||
| /// SomeTag::Y { 0: false, 1: false } <=> 7, | ||
| /// } | ||
| /// | ||
| /// assert_eq!(SomeTag::A.into_usize(), 0); | ||
| /// assert_eq!(SomeTag::X { v: false }.into_usize(), 3); | ||
| /// assert_eq!(SomeTag::Y(false, true).into_usize(), 5); | ||
| /// | ||
| /// assert_eq!(unsafe { SomeTag::from_usize(1) }, SomeTag::B); | ||
| /// assert_eq!(unsafe { SomeTag::from_usize(2) }, SomeTag::X { v: true }); | ||
| /// assert_eq!(unsafe { SomeTag::from_usize(7) }, SomeTag::Y(false, false)); | ||
| /// ``` | ||
| /// | ||
| /// Structs are supported: | ||
| /// | ||
| /// ``` | ||
| /// # use rustc_data_structures::impl_tag; | ||
| /// #[derive(Copy, Clone)] | ||
| /// struct Flags { a: bool, b: bool } | ||
| /// | ||
| /// impl_tag! { | ||
| /// for Flags; | ||
| /// Flags { a: true, b: true } <=> 3, | ||
| /// Flags { a: false, b: true } <=> 2, | ||
| /// Flags { a: true, b: false } <=> 1, | ||
| /// Flags { a: false, b: false } <=> 0, | ||
| /// } | ||
| /// ``` | ||
| /// | ||
| // This is supposed to produce a compile error, but does not, | ||
| // see <https://github.com/rust-lang/rust/issues/110613> for more information. | ||
| // | ||
| // Using the same pattern twice results in a compile error: | ||
| // | ||
| // ```compile_fail | ||
| // # use rustc_data_structures::impl_tag; | ||
| // #[derive(Copy, Clone)] | ||
| // struct Unit; | ||
| // | ||
| // impl_tag! { | ||
| // for Unit; | ||
| // Unit <=> 0, | ||
| // Unit <=> 1, | ||
| // } | ||
| // ``` | ||
| // | ||
| // Using the same tag twice results in a compile error: | ||
| // | ||
| // ```compile_fail | ||
| // # use rustc_data_structures::impl_tag; | ||
| // #[derive(Copy, Clone)] | ||
| // enum E { A, B }; | ||
| // | ||
| // impl_tag! { | ||
| // for E; | ||
| // E::A <=> 0, | ||
| // E::B <=> 0, | ||
| // } | ||
| // ``` | ||
| // | ||
| /// Not specifying all values results in a compile error: | ||
| /// | ||
| /// ```compile_fail,E0004 | ||
| /// # use rustc_data_structures::impl_tag; | ||
| /// #[derive(Copy, Clone)] | ||
| /// enum E { | ||
| /// A, | ||
| /// B, | ||
| /// } | ||
| /// | ||
| /// impl_tag! { | ||
| /// for E; | ||
| /// E::A <=> 0, | ||
| /// } | ||
| /// ``` | ||
| #[macro_export] | ||
| macro_rules! impl_tag { | ||
| ( | ||
| for $Self:ty; | ||
| $( | ||
| $($path:ident)::* $( { $( $fields:tt )* })? <=> $tag:literal, | ||
| )* | ||
| ) => { | ||
| // Safety: | ||
| // `into_usize` only returns one of `$tag`s, | ||
| // `bits_for_tags` is called on all `$tag`s, | ||
| // thus `BITS` constant is correct. | ||
| unsafe impl $crate::tagged_ptr::Tag for $Self { | ||
| const BITS: u32 = $crate::tagged_ptr::bits_for_tags(&[ | ||
| $( $tag, )* | ||
| ]); | ||
|
|
||
| fn into_usize(self) -> usize { | ||
| // This forbids use of repeating patterns (`Enum::V`&`Enum::V`, etc) | ||
| // (or at least it should, see <https://github.com/rust-lang/rust/issues/110613>) | ||
| #[forbid(unreachable_patterns)] | ||
| match self { | ||
| // `match` is doing heavy lifting here, by requiring exhaustiveness | ||
| $( | ||
| $($path)::* $( { $( $fields )* } )? => $tag, | ||
| )* | ||
| } | ||
| } | ||
|
|
||
| unsafe fn from_usize(tag: usize) -> Self { | ||
| // Similarly to the above, this forbids repeating tags | ||
| // (or at least it should, see <https://github.com/rust-lang/rust/issues/110613>) | ||
| #[forbid(unreachable_patterns)] | ||
| match tag { | ||
| $( | ||
| $tag => $($path)::* $( { $( $fields )* } )?, | ||
| )* | ||
|
|
||
| // Safety: | ||
| // `into_usize` only returns one of `$tag`s, | ||
| // all `$tag`s are filtered up above, | ||
| // thus if this is reached, the safety contract of this | ||
| // function was already breached. | ||
| _ => unsafe { | ||
| debug_assert!( | ||
| false, | ||
| "invalid tag: {tag}\ | ||
| (this is a bug in the caller of `from_usize`)" | ||
| ); | ||
| std::hint::unreachable_unchecked() | ||
| }, | ||
| } | ||
| } | ||
|
|
||
| } | ||
| }; | ||
| } | ||
|
|
||
| #[cfg(test)] | ||
| mod tests; |
33 changes: 33 additions & 0 deletions
33
compiler/rustc_data_structures/src/tagged_ptr/impl_tag/tests.rs
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,33 @@ | ||
| #[test] | ||
| fn bits_constant() { | ||
| use crate::tagged_ptr::Tag; | ||
|
|
||
| #[derive(Copy, Clone)] | ||
| struct Unit; | ||
| impl_tag! { for Unit; Unit <=> 0, } | ||
| assert_eq!(Unit::BITS, 0); | ||
|
|
||
| #[derive(Copy, Clone)] | ||
| struct Unit1; | ||
| impl_tag! { for Unit1; Unit1 <=> 1, } | ||
| assert_eq!(Unit1::BITS, 1); | ||
|
|
||
| #[derive(Copy, Clone)] | ||
| struct Unit2; | ||
| impl_tag! { for Unit2; Unit2 <=> 0b10, } | ||
| assert_eq!(Unit2::BITS, 2); | ||
|
|
||
| #[derive(Copy, Clone)] | ||
| struct Unit3; | ||
| impl_tag! { for Unit3; Unit3 <=> 0b100, } | ||
| assert_eq!(Unit3::BITS, 3); | ||
|
|
||
| #[derive(Copy, Clone)] | ||
| enum Enum { | ||
| A, | ||
| B, | ||
| C, | ||
| } | ||
| impl_tag! { for Enum; Enum::A <=> 0b1, Enum::B <=> 0b1000, Enum::C <=> 0b10, } | ||
| assert_eq!(Enum::BITS, 4); | ||
| } |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters