Mixed integer ops

.github/workflows/ci.yaml

@@ -3,8 +3,10 @@ name: CI
 on:
   push:
     branches:
-      - main
+      - "*"
   pull_request:
+    branches:
+      - main
     types: [opened, synchronize, reopened]
   workflow_dispatch:
 

Makefile.toml

@@ -20,6 +20,7 @@ args = ["clippy", "--all-features"]
 [tasks.docs]
 args = ["doc", "--no-deps", "--all-features"]
 
+# Build package in no_std environment.
 [tasks.no-std]
 command = "cargo"
 args = ["build", "--target", "thumbv7m-none-eabi"]
@@ -55,6 +56,11 @@ run_task = "chkall"
 env = { "RUSTFLAGS" = "--cfg=cnst8bitonly" }
 run_task = "coverage-tarpaulin"
 
+# Linter check with 8bit types only.
+[tasks.clp8]
+env = { "RUSTFLAGS" = "--cfg=cnst8bitonly" }
+run_task = "clippy"
+
 # Run all 8bit related unit tests.
 [tasks.t8]
 env = { "RUSTFLAGS" = "--cfg=cnst8bitonly" }
@@ -129,3 +135,7 @@ args = [
     "i128",
     "isize",
 ]
+
+# Run all 8bit related doc examples only.
+[tasks.td8]
+run_task = { name = ["tdu8", "tdi8"] }

src/lib.rs

@@ -71,6 +71,10 @@
 #![allow(incomplete_features)]
 #![feature(generic_const_exprs)]
 //
+// Tracking issue for `mixed_integer_ops`:
+// https://github.com/rust-lang/rust/issues/87840.
+#![feature(mixed_integer_ops)]
+//
 // Tracking issue for `doc_auto_cfg` feature:
 // https://github.com/rust-lang/rust/issues/43781.
 #![feature(doc_auto_cfg)]
@@ -88,23 +92,20 @@ mod macros;
 // default values for doc examples.
 //
 // Format:
-//  { uint, uint_mod, TypeName, ErrorName, MinErrorName, MaxErrorName },+
+//  { uint, sint, uint_mod, sint_mod, TypeName, ErrorName, MinErrorName, MaxErrorName },+
 //
-// Builds `u8` only, which is significantly faster. Useful for most development
-// purposes.
-#[cfg(cnst8bitonly)]
+// Building 8bit related types exclusively is faster, useful for most development purposes.
+#[cfg(any(cnst8bitonly, not(cnst8bitonly)))]
 constrained_uint_def_impl! {
-    { u8, u8, ConstrainedU8, ConstrainedU8Error, MinU8Error, MaxU8Error }
+    { u8, i8, u8, i8, ConstrainedU8, ConstrainedU8Error, MinU8Error, MaxU8Error }
 }
-// Builds all unsigned types by default.
 #[cfg(not(cnst8bitonly))]
 constrained_uint_def_impl! {
-    { u8, u8, ConstrainedU8, ConstrainedU8Error, MinU8Error, MaxU8Error },
-    { u16, u16, ConstrainedU16, ConstrainedU16Error, MinU16Error, MaxU16Error },
-    { u32, u32, ConstrainedU32, ConstrainedU32Error, MinU32Error, MaxU32Error },
-    { u64, u64, ConstrainedU64, ConstrainedU64Error, MinU64Error, Max64Error },
-    { u128, u128, ConstrainedU128, ConstrainedU128Error, Min128Error, Max128Error },
-    { usize, usize, ConstrainedUsize, ConstrainedUsizeError, MinUsizeError, MaxUsizeError },
+    { u16, i16, u16, i16, ConstrainedU16, ConstrainedU16Error, MinU16Error, MaxU16Error },
+    { u32, i32, u32, i32, ConstrainedU32, ConstrainedU32Error, MinU32Error, MaxU32Error },
+    { u64, i64, u64, i64, ConstrainedU64, ConstrainedU64Error, MinU64Error, Max64Error },
+    { u128, i128, u128, i128, ConstrainedU128, ConstrainedU128Error, Min128Error, Max128Error },
+    { usize, isize, usize, isize, ConstrainedUsize, ConstrainedUsizeError, MinUsizeError, MaxUsizeError },
 }
 
 // Define mods, containers, errors, tests and impls for signed integers with
@@ -113,19 +114,19 @@ constrained_uint_def_impl! {
 // Format:
 //  { sint, uint, sint_mod, uint_mod, TypeName, ErrorName, MinErrorName, MaxErrorName },+
 //
-// Builds `i8` only, which is significantly faster. Useful for most development
-// purposes.
-#[cfg(cnst8bitonly)]
+// Building 8bit related types exclusively is faster, useful for most development purposes.
+#[cfg(any(cnst8bitonly, not(cnst8bitonly)))]
 constrained_int_def_impl! {
     { i8, u8, i8, u8, ConstrainedI8, ConstrainedI8Error, MinI8Error, MaxI8Error },
 }
-// Builds all signed types by default.
 #[cfg(not(cnst8bitonly))]
 constrained_int_def_impl! {
-    { i8, u8, i8, u8, ConstrainedI8, ConstrainedI8Error, MinI8Error, MaxI8Error },
     { i16, u16, i16, u16, ConstrainedI16, ConstrainedI16Error, MinI16Error, MaxI16Error },
     { i32, u32, i32, u32, ConstrainedI32, ConstrainedI32Error, MinI32Error, MaxI32Error },
     { i64, u64, i64, u64, ConstrainedI64, ConstrainedI64Error, MinI64Error, MaxI64Error },
     { i128, u128, i128, u128, ConstrainedI128, ConstrainedI128Error, MinI128Error, MaxI128Error },
     { isize, usize, isize, usize, ConstrainedIsize, ConstrainedIsizeError, MinIsizeError, MaxIsizeError },
 }
+
+#[cfg(test)]
+mod proptest;

src/macros/common.rs

@@ -1,8 +1,8 @@
 // Defines containers, errors, common impls and doc values for integers.
 macro_rules! constrained_def_impl {
-    ($Int:ty, $md:ident, $Ty:ident, $Err:ident, $MinErr:ident, $MaxErr:ident,
-        $min:literal..=$max:literal, ($l:literal, $h:literal)) =>
-    {
+    (   $Int:ty, $md:ident, $Ty:ident, $Err:ident, $MinErr:ident, $MaxErr:ident,
+        $min:literal..=$max:literal, ($l:literal, $h:literal)
+    ) => {
         // This const function is used to enforce constraints for the range definition.
         // Relevant const generics are: `MIN`, `MAX`.
         // The constraints are:
@@ -418,6 +418,15 @@ macro_rules! constrained_def_impl {
             pub const fn get(&self) -> $Int {
                 self.0
             }
+
+            /// **Not** part of the public API, implementation detail.
+            // Unfortunate workaround.
+            // Issue: https://github.com/Mari-W/const_guards/issues/2.
+            #[doc(hidden)]
+            #[cfg(test)]
+            pub const fn __new(value: $Int) -> Result<Self, $Err<MIN, MAX>> {
+                Self::new_unguarded(value)
+            }
         }
 
         // Implements some ::core::fmt traits for `Constrained` types.