allow deriving CheckedBitPattern for enums with fields (#171)

* simplify `ToTokens` impl for `Representation`

Instead of collecting the representation and modifier into `Option`s
and determining whether a comma is needed manually, we can use the
`Puncutuated` struct which handles commas automatically.

This will also make emitting the `align` modifier in the future easier.

* emit alignment modifier

This is required for correctly implementing `CheckedBitPattern` because
we need the layout of the type and its `Bits` type to have the same
layout.

* add unit test for `#[repr]` parsing

* allow multiple alignment modifiers

According to RFC #1358, if multiple alignment modifiers are specified,
the resulting alignment is the maximum of all alignment modifiers.

* actually return the error we just created

* factor out the integer Repr's into their own type

This is a preparation step for adding support for `#[repr(C, int)]`.

* allow parsing `#[repr(C, int)]`

This can be used on enums with fields.

* derive `CheckedBitPattern` for enums with fields

The implementation mostly mirrors the desugaring described at
https://doc.rust-lang.org/reference/type-layout.html

* add comments and rename some idents

* update error message

* update docs for `CheckedBitPattern` derive

* add new nested test case, change generated type naming scheme

* fix wrong comment

* small nit

---------

Co-authored-by: Gray Olson <[email protected]>

derive/src/lib.rs

@@ -218,7 +218,7 @@ pub fn derive_zeroable(
 /// - The struct must contain no generic parameters
 ///
 /// If applied to an enum:
-/// - The enum must be explicit `#[repr(Int)]`
+/// - The enum must be explicit `#[repr(Int)]`, `#[repr(C)]`, or both
 /// - All variants must be fieldless
 /// - The enum must contain no generic parameters
 #[proc_macro_derive(NoUninit)]
@@ -237,16 +237,17 @@ pub fn derive_no_uninit(
 /// for the `CheckedBitPattern` trait and derives the required `Bits` type
 /// definition and `is_valid_bit_pattern` method for the type automatically.
 ///
-/// The following constraints need to be satisfied for the macro to succeed
-/// (the rest of the constraints are guaranteed by the `CheckedBitPattern`
-/// subtrait bounds, i.e. are guaranteed by the requirements of the `NoUninit`
-/// trait which `CheckedBitPattern` is a subtrait of):
+/// The following constraints need to be satisfied for the macro to succeed:
 ///
 /// If applied to a struct:
 /// - All fields must implement `CheckedBitPattern`
+/// - The struct must be `#[repr(C)]` or `#[repr(transparent)]`
+/// - The struct must contain no generic parameters
 ///
 /// If applied to an enum:
-/// - All requirements already checked by `NoUninit`, just impls the trait
+/// - The enum must be explicit `#[repr(Int)]`
+/// - All fields in variants must implement `CheckedBitPattern`
+/// - The enum must contain no generic parameters
 #[proc_macro_derive(CheckedBitPattern)]
 pub fn derive_maybe_pod(
   input: proc_macro::TokenStream,