isit 0.1.2

Library for compile time assertions and conditional checks.
Documentation
  • Coverage
  • 100%
    94 out of 94 items documented48 out of 94 items with examples
  • Size
  • Source code size: 64.25 kB This is the summed size of all the files inside the crates.io package for this release.
  • Documentation size: 912.05 kB This is the summed size of all files generated by rustdoc for all configured targets
  • Ø build duration
  • this release: 7s Average build duration of successful builds.
  • all releases: 16s Average build duration of successful builds in releases after 2024-10-23.
  • Links
  • ErisianArchitect/isit
    8 0 0
  • crates.io
  • Dependencies
    • —
  • Versions
  • Owners
  • ErisianArchitect

isit is a compile time checking library. It has a multitude of functions for performing compile time checks to ensure that your program will work as expected before you ever run it.

Examples

const_assert

#[repr(C)]
struct Fred {
    foo: u32,
    bar: u64,
    baz: bool,
}
const _: () = isit::const_assert(std::mem::offset_of!(Fred, bar) == 8);

const_assert_all

#[repr(C)]
struct Fred {
    foo: u32,
    bar: u64,
    baz: bool,
}
const _: () = isit::const_assert_all([
    std::mem::size_of::<Fred>() == 24,
    std::mem::offset_of!(Fred, foo) == 0,
    std::mem::offset_of!(Fred, bar) == 8,
    std::mem::offset_of!(Fred, baz) == 16,
]);

const_assert_any

#[repr(C)]
struct Fred {
    foo: u32,
    bar: usize,
    baz: bool,
}
const _: () = isit::const_assert_any([
    // 64-bit systems
    std::mem::size_of::<Fred>() == 24,
    // 32-bit systems
    std::mem::size_of::<Fred>() == 12,
    // 16-bit systems
    std::mem::size_of::<Fred>() == 8,
]);

const_assert_none

#[repr(C)]
struct Fred {
    foo: u32,
    bar: u64,
    baz: bool,
}
const _: () = isit::const_assert_none([
    // align is 8, so none of these will be true.
    std::mem::align_of::<Fred>() == 1,
    std::mem::align_of::<Fred>() == 2,
    std::mem::align_of::<Fred>() == 4,
]);

assert_size

#[repr(C)]
struct Fred {
    foo: u32,
    bar: u64,
    baz: bool,
}
const _: () = isit::assert_size::<Fred, 24>();

assert_not_size

#[repr(C)]
struct Fred {
    foo: u32,
    bar: u64,
    baz: bool,
}
// If the type were not `C` layout, and were instead `Rust`
// layout, the size would end up being 16 instead of 24, and
// this check would fail.
const _: () = isit::assert_not_size::<Fred, 16>();

assert_same_size

#[repr(C)]
struct Fred {
    foo: u32,
    bar: u64,
    baz: bool,
}
const _: () = isit::assert_same_size::<Fred, [u64; 3]>();

assert_different_size

#[repr(C)]
struct Fred {
    foo: u32,
    bar: u64,
    baz: bool,
}
/// 

#[repr(C)]
struct NotFred {
    bar: u64,
    foo: u32,
    baz: bool,
}
const _: () = isit::assert_different_size::<Fred, NotFred>();

assert_compatible_size

#[repr(C)]
struct Fred {
    foo: u32,
    bar: u64,
    baz: bool,
}
const _: () = isit::assert_compatible_size::<[u64; 1], Fred>();
const _: () = isit::assert_compatible_size::<[u64; 2], Fred>();
const _: () = isit::assert_compatible_size::<[u64; 3], Fred>();

assert_incompatible_size

#[repr(C)]
struct Fred {
    foo: u32,
    bar: u64,
    baz: bool,
}
const _: () = isit::assert_incompatible_size::<Fred, [u64; 2]>();

assert_align

#[repr(C)]
struct Fred {
    foo: u32,
    bar: u64,
    baz: bool,
}
const _: () = isit::assert_align::<Fred, 8>();

assert_not_align

#[repr(C)]
struct Fred {
    foo: u32,
    bar: u64,
    baz: bool,
}
const _: () = isit::assert_not_align::<Fred, 4>();
const _: () = isit::assert_not_align::<Fred, 16>();

assert_same_align

#[repr(C)]
struct Fred {
    foo: u32,
    bar: u64,
    baz: bool,
}
const _: () = isit::assert_same_align::<Fred, u64>();

assert_different_align

#[repr(C)]
struct Fred {
    foo: u32,
    bar: u64,
    baz: bool,
}
const _: () = isit::assert_different_align::<Fred, u32>();
const _: () = isit::assert_different_align::<Fred, bool>();

assert_compatible_align

#[repr(C)]
struct Fred {
    foo: u32,
    bar: u64,
    baz: bool,
}
const _: () = isit::assert_compatible_align::<Fred, u64>();

assert_incompatible_align

#[repr(C)]
struct Fred {
    foo: u32,
    bar: u64,
    baz: bool,
}
const _: () = isit::assert_incompatible_align::<Fred, u32>();
const _: () = isit::assert_incompatible_align::<Fred, bool>();

assert_size_align

#[repr(C)]
struct Fred {
    foo: u32,
    bar: u64,
    baz: bool,
}
const _: () = isit::assert_size_align::<Fred, 24, 8>();

assert_not_size_align

#[repr(C)]
struct Fred {
    foo: u32,
    bar: u64,
    baz: bool,
}
const _: () = isit::assert_not_size_align::<Fred, 16, 4>();

assert_same_size_align

#[repr(C)]
struct Fred {
    foo: u32,
    bar: u64,
    baz: bool,
}
const _: () = isit::assert_same_size_align::<Fred, [u64; 3]>();

assert_different_size_align

#[repr(C)]
struct Fred {
    foo: u32,
    bar: u64,
    baz: bool,
}
const _: () = isit::assert_different_size_align::<Fred, [u32; 4]>();

assert_compatible_size_align

#[repr(C)]
struct Fred {
    foo: u32,
    bar: u64,
    baz: bool,
}
const _: () = isit::assert_compatible_size_align::<[u32; 3], Fred>();

assert_incompatible_size_algin

#[repr(C)]
struct Fred {
    foo: u32,
    bar: u64,
    baz: bool,
}
const _: () = isit::assert_incompatible_size_align::<Fred, u32>();

assert_pointer_size

use std::ptr::NonNull;
#[repr(transparent)]
struct Foo {
    ptr: NonNull<u8>,
}
const _: () = isit::assert_pointer_size::<Foo>();

assert_not_pointer_size

#[repr(C)]
struct Foo {
    a: bool,
    b: u16,
    c: bool,
    d: u16,
    e: bool,
}
const _: () = isit::assert_not_pointer_size::<Foo>();

assert_pointer_align

#[cfg_attr(target_pointer_width = "64", repr(C, align(8)))]
#[cfg_attr(target_pointer_width = "32", repr(C, align(4)))]
#[cfg_attr(target_pointer_width = "16", repr(C, align(2)))]
struct Foo(usize);
const _: () = isit::assert_pointer_align::<Foo>();

assert_not_pointer_align

#[repr(transparent)]
struct Foo {
    inner: u8,
}
const _: () = isit::assert_not_pointer_align::<Foo>();

assert_pointer_size_align

use std::ptr::NonNull;
/// 

#[repr(transparent)]
struct Foo(NonNull<Foo>);
const _: () = isit::assert_pointer_size_align::<Foo>();

assert_not_pointer_size_align

#[repr(transparent)]
struct Foo(u8);
const _: () = isit::assert_not_pointer_size_align::<Foo>();

assert_pointer_compatible_size_align

#[repr(transparent)]
struct Foo(u8);
const _: () = isit::assert_pointer_compatible_size_align::<Foo>();

assert_pointer_incompatible_size_align

#[repr(C, align(16))]
struct Fred {
    foo: u32,
    bar: u64,
    baz: bool,
}
const _: () = isit::assert_pointer_incompatible_size_align::<Fred>();

assert_t_niche

use std::ptr::NonNull;
/// 

#[repr(transparent)]
struct Foo {
    ptr: NonNull<Foo>,
}
const _: () = isit::assert_t_niche::<Foo, NonNull<Foo>>();

assert_no_t_niche

#[repr(transparent)]
struct Foo {
    foo: u32,
}
const _: () = isit::assert_no_t_niche::<Foo, u32>();

assert_t_niche_compatible

use std::num::NonZero;
#[repr(transparent)]
struct Foo(NonZero<u8>);
const _: () = isit::assert_t_niche_compatible::<Foo, NonZero<u8>>();
const _: () = isit::assert_t_niche_compatible::<Foo, NonZero<u16>>();

assert_niche

use std::ptr::NonNull;
/// 

#[repr(transparent)]
struct Foo(NonNull<Foo>);
const _: () = isit::assert_niche::<Foo>();

assert_no_niche

#[repr(transparent)]
struct Foo(u64);
const _: () = isit::assert_no_niche::<Foo>();

assert_single_niche

use std::ptr::NonNull;
/// 

#[repr(transparent)]
struct Foo(NonNull<Foo>);
const _: () = isit::assert_single_niche::<Foo>();

assert_pointer_niche

use std::ptr::NonNull;
/// 

#[repr(transparent)]
struct Foo(NonNull<Foo>);
const _: () = isit::assert_pointer_niche::<Foo>();

assert_no_pointer_niche

#[repr(transparent)]
struct Foo(usize);
const _: () = isit::assert_no_pointer_niche::<Foo>();

assert_pointer_niche_compatible

use std::num::NonZero;
#[repr(transparent)]
struct Foo(NonZero<u128>);
const _: () = isit::assert_pointer_niche_compatible::<Foo>();

assert_u8_niche

#[repr(u8)]
enum Fred {
    Foo,
    Bar,
    Baz,
}
const _: () = isit::assert_u8_niche::<Fred>();

assert_u8_size_align

#[repr(transparent)]
struct Foo(u8);
const _: () = isit::assert_u8_size_align::<Foo>();

assert_u8_compatible

struct Zst;
#[repr(transparent)]
struct U8(u8);
const _: () = isit::assert_u8_compatible::<Zst>();
const _: () = isit::assert_u8_compatible::<U8>();

assert_u8_incompatible

#[repr(transparent)]
struct Foo(u16);
const _: () = isit::assert_u8_incompatible::<Foo>();

assert_zst

struct Zst;
const _: () = isit::assert_zst::<Zst>();
const _: () = isit::assert_zst::<()>();
const _: () = isit::assert_zst::<[[u64; u16::MAX as usize]; 0]>();

assert_not_zst

struct NonZst([u64; u16::MAX as usize]);
const _: () = isit::assert_not_zst::<NonZst>();

assert_uninhabited_zst

enum Uninhabited {}
struct Holder<T>(T);
const _: () = isit::assert_uninhabited_zst::<Uninhabited>();
const _: () = isit::assert_uninhabited_zst::<(Uninhabited, Uninhabited)>();
const _: () = isit::assert_uninhabited_zst::<[Uninhabited; usize::MAX]>();
const _: () = isit::assert_uninhabited_zst::<Holder<Uninhabited>>();
const _: () = isit::assert_uninhabited_zst::<Holder<[Uninhabited; usize::MAX]>>();
const _: () = isit::assert_uninhabited_zst::<Holder<[[Uninhabited; usize::MAX]; usize::MAX]>>();
const _: () = isit::assert_uninhabited_zst::<Holder<[[[Uninhabited; usize::MAX]; usize::MAX]; usize::MAX]>>();
const _: () = isit::assert_uninhabited_zst::<Holder<(
    Holder<[[[Uninhabited; usize::MAX]; usize::MAX]; usize::MAX]>,
    Holder<[[[Uninhabited; usize::MAX]; usize::MAX]; usize::MAX]>,
)>>();

assert_not_uninhabited_zst

struct Foo(u8);
const _: () = isit::assert_not_uninhabited_zst::<Foo>();