# 0.11.2 (2020-11-07)
- Fixed a bug that all but the first `#[skip(..)]` attribute for a bitfield were ignored despite proper error handling.
E.g. when flagging a field with `#[skip(getters)] #[skip(setters)]` the `#[skip(setters)]` was ignored.
# 0.11.1 (2020-11-07)
- Allow non-overlapping `#[skip(getters)]` and `#[skip(setters)]` attributes. This might be useful for conditional compilation.
- Fixed a bug with `#[skip]` skipped fields not properly bumping the bit offset
- Fixed a minor bug where duplicate `#[skip]` attributes would yield a confusing error.
# 0.11.0 (2020-11-06)
- Add `bits: int` parameter to the `#[bitfield]` macro which allows to precisely control the resulting bit width
of the generated bitfield struct. Use it like: `#[bitfield(bits = 5)]`.
- Replace `#[bitfield(specifier = true)]` syntax with `#[bitfield] #[derive(BitfieldSpecifier)]`.
Semantics of the new syntax is the same as the old.
- It is now possible to flag fields of `#[bitfield]` structs with `#[skip(..)]` in order to skip code generation for them.
There are possibilities to skip code generation of only setters using `#[skip(setters)]`, only getters `#[skip(getters)]`
or both. Having no arguments (e.g. just `#[skip]`) defaults to skipping both setters and getters.
A neat trick is to specify double wildcards as identifiers for skipped fields to avoid having the need to come up with
an identifier for them: For example: `#[skip]: __: B10`
- Attributes applied to `#[bitfield]` fields are now properly propagated to their generated getters and setters.
Note thought that it might be confusing that an attribute applied to a struct field is actually applied to a function
through macro expansion.
- Fixed several bugs and significantly improved error reporting for `#[bits = N]` field attributes for `#[bitfield]` fields.
- Minor fixes and improvements to code generation:
- The automatically implemented `#[derive(Debug)]` now produces code that the Rust 2015 edition will accept.
- Some minor macro hygiene improvements.
# 0.10.0 (2020-10-29)
- (Thanks @jam1garner): The `#[bitfield]` macro now looks for `#[derive(Debug)]` annotations and if found will implement
one that formats the struct with its fields as a user would expect them. Previously having a `#[derive(Debug)]`
annotation on a `#[bitfield]` struct would simply print the contents of the generated internal byte array.
- Implement `#[bitfield(bytes = N)]` parameter to ensure at compile time that the bitfield struct
requires `N` bytes of memory.
- Implement `#[bitfield(filled: bool)]` parameter to control whether the bitfield struct ensures that either
all bits are well defined (`filled = true`) or if there are going to be some bits intentionally undefined (`filled = false`).
The default is `filled = true`.
- Implement `#[repr(uN)]` for `#[bitfield]` structs where `uN` is one of `u8`, `u16`, `u32`, `u64` or `u128` with which it is
possible to control whether a bitfield allow conversions between `uN` and the bitfield. Also it ensures at compile time that
the bitfield requires the exact same amount of bits. This is in conflict with `filled = false`.
- Bitfield structs are no longer implicitly `#[repr(transparent)]`. If a user wants their bitfield struct to remain transparent
they have to add `#[repr(transparent)]` manually to their struct definition.
- The default behaviour for `#[bitfield(specifier = bool)]` got changed so that it no longer by default allows for
unfilled (`filled = false`) or undefined bits. Instead users now have to additionally add `filled = false` if they
explicitly want this behaviour.
- Renamed the generated `as_bytes` method for `#[bitfield]` structs to `into_bytes`. It now takes `self` instead of `&self`
and returns the byte array by value instead of reference. This change was necessary for working properly with the new
`#[repr(uN)]` feature.
- Fixed a bug with `#[bitfield(specifier = true)]` bitfields that were not aligned to have a power-of-two bytes.
# 0.9.0 (2020-10-26)
- Add `#[bitfield(specifier = bool)]` parameter with which it now is possible to have bitfield structs automatically also
implement the `modular_bitfield::Specifier` trait which makes it possible to have bitfields as fields of bitfields.
- No longer generates an `unsafe fn from_bytes_unchecked`. Now generates a safe `fn from_bytes` that is basically identical.
The difference is that we no longer consider bitfields containing invalid bit patterns as invalid since generated getters
will protect their access anyways.
- Update crate documentation and README.
# 0.8.0 (2020-10-25)
- The `#[derive(BitfieldSpecifier)]` now allows an amount of variants that is not a power of two via
the new attribute `#[bits = N]` where `N` is the bit width of the deriving enum. (Thanks @lkolbly)
- Add `Specifier` implementations for `u8`, `u16`, `u32`, `u64` and `u128`.
- The `#[bitfield]` macro now additionally generates getters for expected failures just as it already
does for the various setters. For a field `a` the new fail-safe getter is called `a_or_err` and returns
a `Result`.
- Silence repetitive `dead_code` warnings originating from generated `#[bitfield]` getters and setters.
- Improve error span information in a few use cases.
- Cleaned up backend code for `modular_bitfield` crate and its generated code.
# 0.7.0 (2020-10-18)
- Tons of macro generated code hygiene improvements for both `#[bitfield]` and `#[derive(BitfieldSpecifier)]`.
- `#[bitfield]` now produces `with_{}` and `with_{}_checked` methods that take `self` and return `Self`. (Thanks @lkolbly)
- This is useful for building up your bitfields without the need of a mutable reference.
- `#[bitfield]` generated getters now are the same identifiers as their fields. (Thanks @Qyriad)
- Previously for a field `a` it generated `fn get_a(..)` but now it generates `fn a(..)` instead.
- `#[bitfield]` now properly inherits visibility modifiers for all fields onto their generated getters and setters. (Thanks @WorldSEnder)
- Remove `TryFrom` implementation from `#[bitfield]` generated structs since it never was really safe.
- It didn't check for invalid bit patterns and thus could trigger undefined behaviour.
- The `#[bitfield]` generated `new` constructor is now a `const fn`.
- Rename the `#[bitfield]` generated `to_bytes` to `as_bytes`.
- Also it now returns a reference to an array, e.g. `&[u8; N]` instead of a slice.
- The `#[bitfield]` macro now generates an `unsafe fn from_bytes_unchecked` that allows constructing from raw bytes.
- This is meant as an `unsafe` replacement for the removed `TryFrom` implementation.
- We plan to create safer alternatives in future updates.
- Updated all benchmarks to use the `criterion` crate.
- Fixed a parsing bug that `enum` variant names sometimes could clash with Rust keywords. (Thanks @Qyriad)
- Fixed a bug that caused getters to sometimes read with extra invalid bits. (Thanks @crzysdrs)
- Fixed an issue that was caused by single bit manipulations. (Thanks @crzysdrs)