Merge #2642

2642: Tock reg UIntLike r=lschuermann a=ppannuto

### Pull Request Overview

tock-registers: Rename `IntLike` to `UIntLike`

This better captures the semantics of this interfaces.

Closes #2641.

Depends on #2618.


### Testing Strategy

This pull request was tested by compiling.


### TODO or Help Wanted

N/A.


### Documentation Updated

- [x] Updated the relevant files in `/docs`, or no updates are required.

### Formatting

- [x] Ran `make prepush`.


Co-authored-by: Pat Pannuto <pat.pannuto@gmail.com>

Author: bors[bot]

libraries/tock-register-interface/README.md

@@ -204,7 +204,7 @@ methods, through the implementations of the `Readable`, `Writeable`
 and `ReadWriteable` traits respectively:
 
 ```rust
-ReadOnly<T: IntLike, R: RegisterLongName = ()>: Readable
+ReadOnly<T: UIntLike, R: RegisterLongName = ()>: Readable
 .get() -> T                                    // Get the raw register value
 .read(field: Field<T, R>) -> T                 // Read the value of the given field
 .read_as_enum<E>(field: Field<T, R>) -> Option<E> // Read value of the given field as a enum member
@@ -213,11 +213,11 @@ ReadOnly<T: IntLike, R: RegisterLongName = ()>: Readable
 .matches_all(value: FieldValue<T, R>) -> bool  // Check if all specified parts of a field match
 .extract() -> LocalRegisterCopy<T, R>          // Make local copy of register
 
-WriteOnly<T: IntLike, R: RegisterLongName = ()>: Writeable
+WriteOnly<T: UIntLike, R: RegisterLongName = ()>: Writeable
 .set(value: T)                                 // Set the raw register value
 .write(value: FieldValue<T, R>)                // Write the value of one or more fields,
                                                //  overwriting other fields to zero
-ReadWrite<T: IntLike, R: RegisterLongName = ()>: Readable + Writeable + ReadWriteable
+ReadWrite<T: UIntLike, R: RegisterLongName = ()>: Readable + Writeable + ReadWriteable
 .get() -> T                                    // Get the raw register value
 .set(value: T)                                 // Set the raw register value
 .read(field: Field<T, R>) -> T                 // Read the value of the given field
@@ -234,7 +234,7 @@ ReadWrite<T: IntLike, R: RegisterLongName = ()>: Readable + Writeable + ReadWrit
 .matches_all(value: FieldValue<T, R>) -> bool  // Check if all specified parts of a field match
 .extract() -> LocalRegisterCopy<T, R>          // Make local copy of register
 
-Aliased<T: IntLike, R: RegisterLongName = (), W: RegisterLongName = ()>: Readable + Writeable
+Aliased<T: UIntLike, R: RegisterLongName = (), W: RegisterLongName = ()>: Readable + Writeable
 .get() -> T                                    // Get the raw register value
 .set(value: T)                                 // Set the raw register value
 .read(field: Field<T, R>) -> T                 // Read the value of the given field
@@ -250,7 +250,7 @@ Aliased<T: IntLike, R: RegisterLongName = (), W: RegisterLongName = ()>: Readabl
 The `Aliased` type represents cases where read-only and write-only registers,
 with different meanings, are aliased to the same memory location.
 
-The first type parameter (the `IntLike` type) is `u8`, `u16`, `u32`,
+The first type parameter (the `UIntLike` type) is `u8`, `u16`, `u32`,
 `u64`, `u128` or `usize`.
 
 ## Example: Using registers and bitfields

libraries/tock-register-interface/src/fields.rs

@@ -9,7 +9,7 @@
 //!
 //! A specific section (bitfield) in a register is described by the
 //! [`Field`] type, consisting of an unshifted bitmask over the base
-//! register [`IntLike`](crate::IntLike) type, and a shift
+//! register [`UIntLike`](crate::UIntLike) type, and a shift
 //! parameter. It is further associated with a specific
 //! [`RegisterLongName`], which can prevent its use with incompatible
 //! registers.
@@ -68,18 +68,18 @@
 use core::marker::PhantomData;
 use core::ops::{Add, AddAssign};
 
-use crate::{IntLike, RegisterLongName};
+use crate::{RegisterLongName, UIntLike};
 
 /// Specific section of a register.
 ///
 /// For the Field, the mask is unshifted, ie. the LSB should always be set.
-pub struct Field<T: IntLike, R: RegisterLongName> {
+pub struct Field<T: UIntLike, R: RegisterLongName> {
     pub mask: T,
     pub shift: usize,
     associated_register: PhantomData<R>,
 }
 
-impl<T: IntLike, R: RegisterLongName> Field<T, R> {
+impl<T: UIntLike, R: RegisterLongName> Field<T, R> {
     pub const fn new(mask: T, shift: usize) -> Field<T, R> {
         Field {
             mask: mask,
@@ -113,7 +113,7 @@ impl<T: IntLike, R: RegisterLongName> Field<T, R> {
 //
 //    #[automatically_derived]
 //    #[allow(unused_qualifications)]
-//    impl<T: ::core::marker::Copy + IntLike,
+//    impl<T: ::core::marker::Copy + UIntLike,
 //         R: ::core::marker::Copy + RegisterLongName>
 //            ::core::marker::Copy for Field<T, R> {}
 //
@@ -122,7 +122,7 @@ impl<T: IntLike, R: RegisterLongName> Field<T, R> {
 // Manually implementing Clone and Copy works around this issue.
 //
 // Relevant Rust issue: https://github.com/rust-lang/rust/issues/26925
-impl<T: IntLike, R: RegisterLongName> Clone for Field<T, R> {
+impl<T: UIntLike, R: RegisterLongName> Clone for Field<T, R> {
     fn clone(&self) -> Self {
         Field {
             mask: self.mask,
@@ -131,7 +131,7 @@ impl<T: IntLike, R: RegisterLongName> Clone for Field<T, R> {
         }
     }
 }
-impl<T: IntLike, R: RegisterLongName> Copy for Field<T, R> {}
+impl<T: UIntLike, R: RegisterLongName> Copy for Field<T, R> {}
 
 macro_rules! Field_impl_for {
     ($type:ty) => {
@@ -155,7 +155,7 @@ Field_impl_for!(usize);
 /// For the FieldValue, the masks and values are shifted into their actual
 /// location in the register.
 #[derive(Copy, Clone)]
-pub struct FieldValue<T: IntLike, R: RegisterLongName> {
+pub struct FieldValue<T: UIntLike, R: RegisterLongName> {
     mask: T,
     pub value: T,
     associated_register: PhantomData<R>,
@@ -193,7 +193,7 @@ FieldValue_impl_for!(u64);
 FieldValue_impl_for!(u128);
 FieldValue_impl_for!(usize);
 
-impl<T: IntLike, R: RegisterLongName> FieldValue<T, R> {
+impl<T: UIntLike, R: RegisterLongName> FieldValue<T, R> {
     /// Get the raw bitmask represented by this FieldValue.
     #[inline]
     pub fn mask(&self) -> T {
@@ -225,7 +225,7 @@ impl<T: IntLike, R: RegisterLongName> FieldValue<T, R> {
 }
 
 // Combine two fields with the addition operator
-impl<T: IntLike, R: RegisterLongName> Add for FieldValue<T, R> {
+impl<T: UIntLike, R: RegisterLongName> Add for FieldValue<T, R> {
     type Output = Self;
 
     #[inline]
@@ -239,7 +239,7 @@ impl<T: IntLike, R: RegisterLongName> Add for FieldValue<T, R> {
 }
 
 // Combine two fields with the += operator
-impl<T: IntLike, R: RegisterLongName> AddAssign for FieldValue<T, R> {
+impl<T: UIntLike, R: RegisterLongName> AddAssign for FieldValue<T, R> {
     #[inline]
     fn add_assign(&mut self, rhs: FieldValue<T, R>) {
         self.mask |= rhs.mask;

libraries/tock-register-interface/src/interfaces.rs

@@ -7,7 +7,7 @@
 //!
 //! Each trait has two associated type parameters, namely:
 //!
-//! - `T`: [`IntLike`](crate::IntLike), indicating the underlying
+//! - `T`: [`UIntLike`](crate::UIntLike), indicating the underlying
 //!   integer type used to represent the register's raw contents.
 //!
 //! - `R`: [`RegisterLongName`](crate::RegisterLongName), functioning
@@ -148,7 +148,7 @@
 //! ```
 
 use crate::fields::{Field, FieldValue, TryFromValue};
-use crate::{IntLike, LocalRegisterCopy, RegisterLongName};
+use crate::{LocalRegisterCopy, RegisterLongName, UIntLike};
 
 /// Readable register
 ///
@@ -161,7 +161,7 @@ use crate::{IntLike, LocalRegisterCopy, RegisterLongName};
 /// [`Readable`] is the same as that of [`Writeable`] (i.e. not for
 /// [`Aliased`](crate::registers::Aliased) registers).
 pub trait Readable {
-    type T: IntLike;
+    type T: UIntLike;
     type R: RegisterLongName;
 
     /// Get the raw register value
@@ -218,7 +218,7 @@ pub trait Readable {
 /// [`Readable`] is the same as that of [`Writeable`] (i.e. not for
 /// [`Aliased`](crate::registers::Aliased) registers).
 pub trait Writeable {
-    type T: IntLike;
+    type T: UIntLike;
     type R: RegisterLongName;
 
     /// Set the raw register value
@@ -252,14 +252,14 @@ pub trait Writeable {
 /// and [`Writeable`], as long as [`Readable::R`] == [`Writeable::R`]
 /// (i.e. not for [`Aliased`](crate::registers::Aliased) registers).
 pub trait ReadWriteable {
-    type T: IntLike;
+    type T: UIntLike;
     type R: RegisterLongName;
 
     /// Write the value of one or more fields, leaving the other fields unchanged
     fn modify(&self, field: FieldValue<Self::T, Self::R>);
 }
 
-impl<T: IntLike, R: RegisterLongName, S> ReadWriteable for S
+impl<T: UIntLike, R: RegisterLongName, S> ReadWriteable for S
 where
     S: Readable<T = T, R = R> + Writeable<T = T, R = R>,
 {

libraries/tock-register-interface/src/lib.rs

@@ -73,14 +73,14 @@ use core::ops::{BitAnd, BitOr, BitOrAssign, Not, Shl, Shr};
 
 /// Trait representing the base type of registers.
 ///
-/// IntLike defines basic properties of types required to
+/// UIntLike defines basic properties of types required to
 /// read/write/modify a register through its methods and supertrait
 /// requirements.
 ///
-/// It features a range of default implementations for common integer
-/// types, such as [`u8`], [`u16`], [`u32`], [`u64`], [`u128`] and
-/// [`usize`].
-pub trait IntLike:
+/// It features a range of default implementations for common unsigned
+/// integer types, such as [`u8`], [`u16`], [`u32`], [`u64`], [`u128`],
+/// and [`usize`].
+pub trait UIntLike:
     BitAnd<Output = Self>
     + BitOr<Output = Self>
     + BitOrAssign
@@ -94,32 +94,32 @@ pub trait IntLike:
     /// Return the representation of the value `0` in the implementing
     /// type.
     ///
-    /// This can be used to acquire values of the [`IntLike`] type,
+    /// This can be used to acquire values of the [`UIntLike`] type,
     /// even in generic implementations. For instance, to get the
-    /// value `1`, one can use `<T as IntLike>::zero() + 1`. To get
+    /// value `1`, one can use `<T as UIntLike>::zero() + 1`. To get
     /// the largest representable value, use a bitwise negation: `~(<T
-    /// as IntLike>::zero())`.
+    /// as UIntLike>::zero())`.
     fn zero() -> Self;
 }
 
-// Helper macro for implementing the IntLike trait on differrent
+// Helper macro for implementing the UIntLike trait on differrent
 // types.
-macro_rules! IntLike_impl_for {
+macro_rules! UIntLike_impl_for {
     ($type:ty) => {
-        impl IntLike for $type {
+        impl UIntLike for $type {
             fn zero() -> Self {
                 0
             }
         }
     };
 }
 
-IntLike_impl_for!(u8);
-IntLike_impl_for!(u16);
-IntLike_impl_for!(u32);
-IntLike_impl_for!(u64);
-IntLike_impl_for!(u128);
-IntLike_impl_for!(usize);
+UIntLike_impl_for!(u8);
+UIntLike_impl_for!(u16);
+UIntLike_impl_for!(u32);
+UIntLike_impl_for!(u64);
+UIntLike_impl_for!(u128);
+UIntLike_impl_for!(usize);
 
 /// Descriptive name for each register.
 pub trait RegisterLongName {}

libraries/tock-register-interface/src/local_register.rs

@@ -5,7 +5,7 @@ use core::fmt;
 use core::marker::PhantomData;
 
 use crate::fields::{Field, FieldValue, TryFromValue};
-use crate::{IntLike, RegisterLongName};
+use crate::{RegisterLongName, UIntLike};
 
 /// A read-write copy of register contents.
 ///
@@ -28,12 +28,12 @@ use crate::{IntLike, RegisterLongName};
 /// [`Writeable`](crate::interfaces::Writeable) and
 /// [`ReadWriteable`](crate::interfaces::ReadWriteable).
 #[derive(Copy, Clone)]
-pub struct LocalRegisterCopy<T: IntLike, R: RegisterLongName = ()> {
+pub struct LocalRegisterCopy<T: UIntLike, R: RegisterLongName = ()> {
     value: T,
     associated_register: PhantomData<R>,
 }
 
-impl<T: IntLike, R: RegisterLongName> LocalRegisterCopy<T, R> {
+impl<T: UIntLike, R: RegisterLongName> LocalRegisterCopy<T, R> {
     pub const fn new(value: T) -> Self {
         LocalRegisterCopy {
             value: value,
@@ -103,14 +103,14 @@ impl<T: IntLike, R: RegisterLongName> LocalRegisterCopy<T, R> {
     }
 }
 
-impl<T: IntLike + fmt::Debug, R: RegisterLongName> fmt::Debug for LocalRegisterCopy<T, R> {
+impl<T: UIntLike + fmt::Debug, R: RegisterLongName> fmt::Debug for LocalRegisterCopy<T, R> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "{:?}", self.value)
     }
 }
 
-// Helper macro to implement From<LocalRegisterCopy<T: IntLike>, R>>
-// for <T: IntLike>
+// Helper macro to implement From<LocalRegisterCopy<T: UIntLike>, R>>
+// for <T: UIntLike>
 macro_rules! From_impl_for {
     ($type:ty) => {
         impl<R: RegisterLongName> From<LocalRegisterCopy<$type, R>> for $type {