Merge pull request #50 from bearcove/no-string-comp

Don't compare string, use const type_id

Author: fasterthanlime

Cargo.lock

@@ -13,3 +13,4 @@ keywords = ["reflection", "introspection", "serialization", "deserialization"]
 categories = ["development-tools", "encoding"]
 
 [dependencies]
+typeid = "1.0.3"

shapely-core/Cargo.toml

@@ -1,11 +1,11 @@
 use std::hash::Hash as _;
 
-use crate::{Bytes, Def, HasherProxy, Shape, Shapely, ValueVTable};
+use crate::{Bytes, Def, HasherProxy, ScalarDef, Shape, Shapely, ValueVTable};
 
 impl Shapely for Bytes {
     const SHAPE: &'static Shape = &Shape {
         layout: std::alloc::Layout::new::<Self>(),
-        def: Def::Scalar,
+        def: Def::Scalar(ScalarDef::of::<Self>()),
         vtable: &ValueVTable {
             type_name: |f, _opts| write!(f, "Bytes"),
             display: None,

shapely-core/src/impls/bytes_impl.rs

@@ -6,7 +6,7 @@ impl Shapely for () {
     const SHAPE: &'static Shape = &const {
         Shape {
             layout: Layout::new::<Self>(),
-            def: Def::Scalar,
+            def: Def::Scalar(ScalarDef::of::<Self>()),
             vtable: &ValueVTable {
                 type_name: |f, _opts| write!(f, "()"),
                 display: Some(|_value, mut f| write!(f, "()")),
@@ -32,7 +32,7 @@ impl Shapely for () {
 impl Shapely for String {
     const SHAPE: &'static Shape = &Shape {
         layout: Layout::new::<Self>(),
-        def: Def::Scalar,
+        def: Def::Scalar(ScalarDef::of::<Self>()),
         vtable: &ValueVTable {
             type_name: |f, _opts| write!(f, "String"),
             display: Some(|value, mut f| {
@@ -64,7 +64,7 @@ impl Shapely for String {
 impl Shapely for bool {
     const SHAPE: &'static Shape = &Shape {
         layout: Layout::new::<Self>(),
-        def: Def::Scalar,
+        def: Def::Scalar(ScalarDef::of::<Self>()),
         vtable: &ValueVTable {
             type_name: |f, _opts| write!(f, "bool"),
             display: Some(|value, mut f| {
@@ -100,7 +100,7 @@ macro_rules! impl_shapely_for_integer {
         impl Shapely for $type {
             const SHAPE: &'static Shape = &Shape {
                 layout: Layout::new::<Self>(),
-                def: Def::Scalar,
+                def: Def::Scalar(ScalarDef::of::<Self>()),
                 vtable: &ValueVTable {
                     type_name: |f, _opts| write!(f, stringify!($type)),
                     display: Some(|value, mut f| {
@@ -153,7 +153,7 @@ macro_rules! impl_shapely_for_float {
         impl Shapely for $type {
             const SHAPE: &'static Shape = &Shape {
                 layout: Layout::new::<Self>(),
-                def: Def::Scalar,
+                def: Def::Scalar(ScalarDef::of::<Self>()),
                 vtable: &ValueVTable {
                     type_name: |f, _opts| write!(f, stringify!($type)),
                     display: Some(|value, mut f| {

shapely-core/src/impls/scalar_impls.rs

@@ -34,9 +34,9 @@ pub trait Shapely: Sized {
     /// Returns the shape function of this type
     const SHAPE: &'static Shape;
 
-    /// Heap-allocate a value of this shape
-    fn allocate() -> OpaqueUninit<'static> {
-        OpaqueUninit::new(unsafe { std::alloc::alloc(Self::SHAPE.layout) })
+    /// Returns true if the type of `self` is equal to the type of `other`
+    fn type_eq<Other: Shapely>() -> bool {
+        Self::SHAPE == Other::SHAPE
     }
 }
 

shapely-core/src/lib.rs

@@ -44,7 +44,7 @@ impl<'mem> Peek<'mem> {
             super::Def::Tuple { .. } => todo!(),
             super::Def::Map { .. } => todo!(),
             super::Def::List { .. } => todo!(),
-            super::Def::Scalar => Peek::Scalar(PeekValue { data, shape }),
+            super::Def::Scalar { .. } => Peek::Scalar(PeekValue { data, shape }),
             super::Def::Enum { .. } => todo!(),
         }
     }

shapely-core/src/peek/mod.rs

@@ -1,4 +1,4 @@
-use crate::{EnumDef, FieldError, OpaqueUninit, Shape, Shapely, trace};
+use crate::{EnumDef, FieldError, OpaqueUninit, Shape, ShapeDebug, Shapely, trace};
 use std::ptr::NonNull;
 
 use super::{ISet, Poke};
@@ -232,7 +232,9 @@ impl<'mem> PokeEnum<'mem> {
                     if !self.iset.has(field_index) {
                         panic!(
                             "Field '{}' of variant '{}' was not initialized. Complete schema:\n{:?}",
-                            field.name, variant.name, self.shape
+                            field.name,
+                            variant.name,
+                            ShapeDebug(self.shape)
                         );
                     }
                 }
@@ -241,13 +243,11 @@ impl<'mem> PokeEnum<'mem> {
     }
 
     fn assert_matching_shape<T: Shapely>(&self) {
-        if self.shape != T::SHAPE {
-            let current_shape = self.shape;
-            let target_shape = T::SHAPE;
-
+        if !self.shape.is_type::<T>() {
             panic!(
                 "This is a partial \x1b[1;34m{}\x1b[0m, you can't build a \x1b[1;32m{}\x1b[0m out of it",
-                current_shape, target_shape,
+                self.shape,
+                T::SHAPE,
             );
         }
     }

shapely-core/src/poke/enum_.rs

@@ -54,7 +54,7 @@ impl Drop for Guard {
 impl<'mem> Poke<'mem> {
     /// Allocates a new poke of a type that implements shapely
     pub fn alloc<S: Shapely>() -> (Self, Guard) {
-        let data = S::allocate();
+        let data = S::SHAPE.allocate();
         let layout = Layout::new::<S>();
         let guard = Guard {
             ptr: data.as_mut_ptr(),
@@ -92,7 +92,7 @@ impl<'mem> Poke<'mem> {
                 let plu = unsafe { PokeListUninit::new(data, shape, list_def) };
                 Poke::List(plu)
             }
-            Def::Scalar => Poke::Scalar(unsafe { PokeValue::new(data, shape) }),
+            Def::Scalar { .. } => Poke::Scalar(unsafe { PokeValue::new(data, shape) }),
             Def::Enum(enum_def) => {
                 Poke::Enum(unsafe { PokeEnumNoVariant::new(data, shape, enum_def) })
             }

shapely-core/src/poke/mod.rs

@@ -1,4 +1,4 @@
-use crate::{FieldError, OpaqueUninit, Shape, StructDef};
+use crate::{FieldError, OpaqueUninit, Shape, ShapeDebug, StructDef};
 use std::ptr::NonNull;
 
 use super::{Guard, ISet};
@@ -33,7 +33,8 @@ impl<'mem> PokeStruct<'mem> {
             if !self.iset.has(i) {
                 panic!(
                     "Field '{}' was not initialized. Complete schema:\n{:?}",
-                    field.name, self.shape
+                    field.name,
+                    ShapeDebug(self.shape)
                 );
             }
         }
@@ -65,9 +66,9 @@ impl<'mem> PokeStruct<'mem> {
     /// - The generic type parameter T does not match the shape that this PokeStruct is building.
     pub fn build<T: crate::Shapely>(self, guard: Option<Guard>) -> T {
         self.assert_all_fields_initialized();
-        assert_eq!(self.shape, T::SHAPE, "Shape mismatch");
+        self.shape.assert_type::<T>();
         if let Some(guard) = &guard {
-            assert_eq!(guard.shape, self.shape, "Shape mismatch");
+            guard.shape.assert_type::<T>();
         }
 
         let result = unsafe {
@@ -88,7 +89,7 @@ impl<'mem> PokeStruct<'mem> {
     /// - The generic type parameter T does not match the shape that this PokeStruct is building.
     pub fn build_boxed<T: crate::Shapely>(self) -> Box<T> {
         self.assert_all_fields_initialized();
-        assert_eq!(self.shape, T::SHAPE, "Shape mismatch");
+        self.shape.assert_type::<T>();
 
         let boxed = unsafe { Box::from_raw(self.data.as_mut_ptr() as *mut T) };
         std::mem::forget(self);
@@ -106,7 +107,7 @@ impl<'mem> PokeStruct<'mem> {
     pub unsafe fn move_into(self, target: NonNull<u8>, guard: Option<Guard>) {
         self.assert_all_fields_initialized();
         if let Some(guard) = &guard {
-            assert_eq!(guard.shape, self.shape, "Shape mismatch");
+            guard.shape.assert_shape(self.shape);
         }
 
         unsafe {

shapely-core/src/poke/struct_.rs

@@ -1,4 +1,4 @@
-use crate::{Opaque, OpaqueConst, OpaqueUninit, Peek, Shape, ValueVTable};
+use crate::{Opaque, OpaqueConst, OpaqueUninit, Peek, Shape, ShapeDebug, ValueVTable};
 
 /// Lets you write to a value (implements write-only [`ValueVTable`] proxies)
 pub struct PokeValue<'mem> {
@@ -10,7 +10,7 @@ pub struct PokeValue<'mem> {
 impl std::fmt::Debug for PokeValue<'_> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("PokeValue")
-            .field("shape", &self.shape)
+            .field("shape", &ShapeDebug(self.shape))
             .finish_non_exhaustive()
     }
 }