Create a new 'IntType' structure

Simple a pair of (IntType, signed)
Replaces the fields of the old TypeInfo::Integer
variant.

This is a breaking change!

Author: Techcable

src/core.rs

@@ -1,6 +1,6 @@
 //! Implementations of [StaticReflect] for core types (for `#![no_std]`)
-use crate::StaticReflect;
-use crate::types::{TypeInfo, SimpleNonZeroRepr};
+use crate::{StaticReflect, PrimInt, PrimFloat};
+use crate::types::{TypeInfo, IntSize, IntType, SimpleNonZeroRepr, FloatSize};
 use std::mem::{self, ManuallyDrop};
 use core::ptr::NonNull;
 use std::num::{NonZeroI32, NonZeroU32, NonZeroU8, NonZeroUsize};
@@ -15,13 +15,15 @@ macro_rules! impl_primitive {
 macro_rules! impl_ints {
     ($($target:ty),*) => {
         $(unsafe impl StaticReflect for $target {
+            const TYPE_INFO: TypeInfo<'static> = TypeInfo::Integer(Self::INT_TYPE);
+        }
+        unsafe impl PrimInt for $target {
+            const INT_SIZE: IntSize = IntSize::unwrap_from_bytes(std::mem::size_of::<Self>());
             #[allow(unused_comparisons)]
-            const TYPE_INFO: TypeInfo<'static> = {
-                let size = std::mem::size_of::<$target>();
-                let signed = <$target>::MIN < 0;
-                TypeInfo::integer(size, signed)
-            };
-        })*
+            const SIGNED: bool = <$target>::MIN < 0;
+            const INT_TYPE: IntType = IntType { size: Self::INT_SIZE, signed: Self::SIGNED };
+        }
+        impl crate::sealed::Sealed for $target {})*
     }
 }
 // NOTE: Pointer sized integers have machine-dependent implementation :(
@@ -33,6 +35,14 @@ impl_primitive!(() => TypeInfo::Unit);
 impl_primitive!(bool => TypeInfo::Bool);
 impl_primitive!(f32 => TypeInfo::F32);
 impl_primitive!(f64 => TypeInfo::F64);
+impl crate::sealed::Sealed for f32 {}
+unsafe impl PrimFloat for f32 {
+    const FLOAT_SIZE: FloatSize = FloatSize::Single;
+}
+impl crate::sealed::Sealed for f64 {}
+unsafe impl PrimFloat for f64 {
+    const FLOAT_SIZE: FloatSize = FloatSize::Double;
+}
 
 // Builtin support for the never type
 impl_primitive!(! => TypeInfo::Never);

src/lib.rs

@@ -32,6 +32,9 @@ mod core;
 
 pub use crate::types::TypeInfo;
 
+use crate::types::{IntType, IntSize, FloatSize};
+use std::ops::{Sub, Mul, Add};
+
 /// The trait for types whose information can be accessed via static reflection.
 ///
 /// In order to proper access any fields,
@@ -58,6 +61,24 @@ pub unsafe trait StaticReflect {
     const TYPE_INFO: TypeInfo<'static>;
 }
 
+/// A primitive integer type
+pub unsafe trait PrimInt: StaticReflect + Copy + Add<Self> + Sub<Self> + Mul<Self> + sealed::Sealed {
+    /// The [IntType] of this integer
+    const INT_TYPE: IntType;
+    /// Whether or not this integer is signed
+    const SIGNED: bool;
+    /// The size of this integer
+    ///
+    /// If this integer is pointer-sized (`isize`/`usize`),
+    /// then this will be its runtime size on the current platform.
+    const INT_SIZE: IntSize;
+}
+/// A primitive float type
+pub unsafe trait PrimFloat: StaticReflect + Copy + sealed::Sealed {
+    /// The size of this float
+    const FLOAT_SIZE: FloatSize;
+}
+
 /// A type that supports accessing its fields via reflection.
 /// 
 /// All fields are assumed to be defined in a way that is compatible
@@ -73,3 +94,7 @@ pub unsafe trait FieldReflect: StaticReflect {
     /// where each field's information is given by name
     const NAMED_FIELD_INFO: Self::NamedFieldInfo;
 }
+
+mod sealed {
+    pub trait Sealed {}
+}