Fix stuff, change format to JSON

matt-cornell · matt-cornell · commit 179b9a1d75ca · 2024-01-06T15:13:10.000-05:00
diff --git a/cobalt-ast/Cargo.toml b/cobalt-ast/Cargo.toml
@@ -31,5 +31,6 @@ serde_derive_state = "0.4.10"
 const-identify = "0.1.1"
 erased-serde = "0.4.1"
 deranged = { version = "0.3.10", features = ["serde"] }
-serde-value = "0.7.0"
-serde_cbor = "0.11.2"
+serde_json = "1.0.111"
+hex = { version = "0.4.3", features = ["serde"] }
+serde_bytes = "0.11.14"
diff --git a/cobalt-ast/src/context.rs b/cobalt-ast/src/context.rs
@@ -8,6 +8,7 @@ use inkwell::{builder::Builder, context::Context, module::Module};
 use owned_chars::OwnedCharsExt;
 use serde::de::DeserializeSeed;
 use std::cell::{Cell, RefCell};
+use std::fmt::{self, Debug, Formatter};
 use std::io::{Read, Write};
 use std::mem::MaybeUninit;
 use std::pin::Pin;
@@ -286,11 +287,11 @@ impl<'src, 'ctx> CompCtx<'src, 'ctx> {
         }
         Some(v)
     }
-    pub fn save<W: Write>(&self, out: &mut W) -> serde_cbor::Result<()> {
-        serde_cbor::to_writer(out, self)
+    pub fn save<W: Write>(&self, buf: &mut W) -> serde_json::Result<()> {
+        serde_json::to_writer(buf, self)
     }
-    pub fn load<R: Read>(&self, buf: &mut R) -> serde_cbor::Result<Vec<String>> {
-        self.deserialize(&mut serde_cbor::Deserializer::from_reader(buf))
+    pub fn load<R: Read>(&self, buf: &mut R) -> serde_json::Result<Vec<String>> {
+        self.deserialize(&mut serde_json::Deserializer::from_reader(buf))
     }
 }
 impl Drop for CompCtx<'_, '_> {
@@ -319,7 +320,9 @@ impl<'de, T, F: FnOnce(&mut dyn erased_serde::Deserializer) -> Result<T, erased_
             .map_err(de::Error::custom)
     }
 }
-
+#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
+#[serde(transparent)]
+struct HexArray(#[serde(with = "hex::serde")] [u8; 8]);
 struct CtxTypeSerde<'a, 's, 'c>(&'a CompCtx<'s, 'c>);
 impl Serialize for CtxTypeSerde<'_, '_, '_> {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -330,7 +333,7 @@ impl Serialize for CtxTypeSerde<'_, '_, '_> {
         let tsr = TYPE_SERIAL_REGISTRY.pin();
         let mut map = serializer.serialize_map(Some(tsr.len()))?;
         for (id, info) in &tsr {
-            map.serialize_entry(id, &(info.erased_header)())?;
+            map.serialize_entry(&HexArray(id.to_le_bytes()), &(info.erased_header)())?;
         }
         map.end()
     }
@@ -345,8 +348,8 @@ impl<'de> de::Visitor<'de> for CtxTypeSerde<'_, '_, '_> {
         A: de::MapAccess<'de>,
     {
         let tsr = TYPE_SERIAL_REGISTRY.pin();
-        while let Some(id) = map.next_key::<u64>()? {
-            let Some(loader) = tsr.get(&id) else {
+        while let Some(id) = map.next_key::<HexArray>()? {
+            let Some(loader) = tsr.get(&u64::from_le_bytes(id.0)) else {
                 return Err(de::Error::custom("unknown type ID {:0>16x}"));
             };
             map.next_value_seed(FnDeserializer(loader.load_header))?;
@@ -371,10 +374,12 @@ impl Serialize for CompCtx<'_, '_> {
         use ser::*;
         #[allow(clippy::unnecessary_cast)]
         SERIALIZATION_CONTEXT.with(|c| {
-            if let Some(ptr) = c.replace(Some(
+            if let Some(ptr) = c.replace(Some(ContextPointer::new(
                 self as *const CompCtx<'_, '_> as *const CompCtx<'static, 'static>, // this intermediate cast is necessary
-            )) {
-                panic!("serialization context is already in use with an address of {ptr:p}");
+            ))) {
+                if *ptr != (self as *const CompCtx<'_, '_> as *const CompCtx<'static, 'static>) {
+                    panic!("serialization context is already in use with an address of {ptr:#?}");
+                }
             }
         });
         let mut map = serializer.serialize_struct("Context", 3)?;
@@ -406,10 +411,12 @@ impl<'de> DeserializeSeed<'de> for &CompCtx<'_, '_> {
         use de::*;
         #[allow(clippy::unnecessary_cast)]
         SERIALIZATION_CONTEXT.with(|c| {
-            if let Some(ptr) = c.replace(Some(
+            if let Some(ptr) = c.replace(Some(ContextPointer::new(
                 self as *const CompCtx<'_, '_> as *const CompCtx<'static, 'static>, // this intermediate cast is necessary
-            )) {
-                panic!("serialization context is already in use with an address of {ptr:p}");
+            ))) {
+                if *ptr != (self as *const CompCtx<'_, '_> as *const CompCtx<'static, 'static>) {
+                    panic!("serialization context is already in use with an address of {ptr:#?}");
+                }
             }
         });
         let proxy = ContextDeProxy::deserialize(deserializer)?;
@@ -429,7 +436,57 @@ impl<'de> DeserializeSeed<'de> for &CompCtx<'_, '_> {
         Ok(self.with_vars(|v| varmap::merge(&mut v.symbols, vars.symbols)))
     }
 }
+
+/// Wrapper around a context pointer, maybe with a backtace
+pub struct ContextPointer {
+    ptr: *const CompCtx<'static, 'static>,
+    #[cfg(debug_assertions)]
+    trace: std::backtrace::Backtrace,
+}
+impl ContextPointer {
+    pub fn new(ptr: *const CompCtx<'static, 'static>) -> Self {
+        Self {
+            trace: std::backtrace::Backtrace::capture(),
+            ptr,
+        }
+    }
+}
+impl std::ops::Deref for ContextPointer {
+    type Target = *const CompCtx<'static, 'static>;
+    fn deref(&self) -> &Self::Target {
+        &self.ptr
+    }
+}
+impl Debug for ContextPointer {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        write!(f, "{:p}", self.ptr)?;
+        #[cfg(debug_assertions)]
+        {
+            if f.alternate() {
+                if self.trace.status() == std::backtrace::BacktraceStatus::Captured {
+                    write!(f, "at: \n{}", self.trace)?;
+                } else {
+                    f.write_str("without backtrace")?;
+                }
+            }
+        }
+        Ok(())
+    }
+}
+/// Get the context pointer from a cell
+/// Super unsafe lmao
+///
+/// # Safety
+/// `SERIALIZATION_CONTEXT`` must be valid
+pub unsafe fn get_ctx_ptr<'a, 's, 'c>(cell: &Cell<Option<ContextPointer>>) -> &'a CompCtx<'s, 'c> {
+    let opt = cell.replace(None);
+    let cp = opt.expect("expected pointer in serialization context");
+    let ptr = cp.ptr;
+    cell.set(Some(cp));
+    #[allow(clippy::unnecessary_cast)]
+    &*(ptr as *const CompCtx<'s, 'c>)
+}
 thread_local! {
-    /// CompCtx, should only have a value during deserialization
-    pub static SERIALIZATION_CONTEXT: Cell<Option<*const CompCtx<'static, 'static>>> = const {Cell::new(None)};
+    /// CompCtx, should only have a value during de/serialization
+    pub static SERIALIZATION_CONTEXT: Cell<Option<ContextPointer>> = const {Cell::new(None)};
 }
diff --git a/cobalt-ast/src/types.rs b/cobalt-ast/src/types.rs
@@ -703,7 +703,7 @@ impl Serialize for TypeRef {
     fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
         use ser::*;
         let mut map = serializer.serialize_struct("Type", 3)?;
-        map.serialize_field("kind", &self.kind())?;
+        map.serialize_field("kind", &hex::encode(self.kind().to_le_bytes()))?;
         map.serialize_field("type", &self.erased_proxy())?;
         map.end()
     }
@@ -714,15 +714,16 @@ impl<'de> Deserialize<'de> for TypeRef {
         #[derive(Deserialize)]
         #[serde(bound = "'a: 'de")]
         struct Proxy<'a> {
-            kind: u64,
+            #[serde(with = "hex::serde")]
+            kind: [u8; 8],
             #[serde(borrow, rename = "type")]
             ty: serde::__private::de::Content<'a>,
         }
         let p = Proxy::deserialize(deserializer)?;
         (TYPE_SERIAL_REGISTRY
             .pin()
-            .get(&p.kind)
-            .ok_or_else(|| D::Error::custom(format!("unknown type id {}", p.kind)))?
+            .get(&u64::from_le_bytes(p.kind))
+            .ok_or_else(|| D::Error::custom(format!("unknown type id {}", hex::encode(p.kind))))?
             .load)(&mut <dyn erased_serde::Deserializer>::erase(
             serde::__private::de::ContentDeserializer::<'de, D::Error>::new(p.ty),
         ))
diff --git a/cobalt-ast/src/types/custom.rs b/cobalt-ast/src/types/custom.rs
@@ -196,10 +196,7 @@ impl Serialize for CustomHeader {
         S: Serializer,
     {
         use ser::*;
-        let ctx = SERIALIZATION_CONTEXT.with(|c| unsafe {
-            &*c.get()
-                .expect("type deserialization must be called with a context")
-        });
+        let ctx = SERIALIZATION_CONTEXT.with(|c| unsafe { get_ctx_ptr(c) });
         let cd = CUSTOM_DATA.pin();
         let mut map = serializer.serialize_map(Some(cd.len()))?;
         cd.iter()
@@ -214,10 +211,7 @@ impl<'de> Deserialize<'de> for CustomHeader {
         D: Deserializer<'de>,
     {
         use de::*;
-        let ctx = SERIALIZATION_CONTEXT.with(|c| unsafe {
-            &*c.get()
-                .expect("type deserialization must be called with a context")
-        });
+        let ctx = SERIALIZATION_CONTEXT.with(|c| unsafe { get_ctx_ptr(c) });
         struct CHVisitor<'de, 'b, 'a, 's, 'c>(
             &'a CompCtx<'s, 'c>,
             flurry::Guard<'b>,
diff --git a/cobalt-ast/src/value.rs b/cobalt-ast/src/value.rs
@@ -399,9 +399,8 @@ impl<'src, 'ctx> Value<'src, 'ctx> {
 #[serde(serialize_state = "()")]
 #[serde(de_parameters = "'a", deserialize_state = "&'a CompCtx<'src, 'ctx>")]
 struct ValueShim<'b, 'src, 'ctx> {
-    pub loc: SourceSpan,
     #[serde(borrow)]
-    pub comp_val: Option<&'b bstr::BStr>,
+    pub comp_val: Option<Cow<'b, str>>,
     #[serde(deserialize_state)]
     pub inter_val: Option<Cow<'b, InterData<'src, 'ctx>>>,
     pub data_type: TypeRef,
@@ -410,20 +409,20 @@ struct ValueShim<'b, 'src, 'ctx> {
 impl<'src, 'ctx> Serialize for Value<'src, 'ctx> {
     fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
         let Value {
-            loc,
             comp_val,
             ref inter_val,
             data_type,
             frozen,
             ..
         } = *self;
         ValueShim {
-            loc,
             data_type,
             frozen,
             inter_val: inter_val.as_ref().map(Cow::Borrowed),
             comp_val: comp_val.map(|v| unsafe {
-                new_lifetime(v.into_pointer_value().get_name().to_bytes().into())
+                std::mem::transmute::<Cow<str>, Cow<str>>(String::from_utf8_lossy(
+                    v.into_pointer_value().get_name().to_bytes(),
+                ))
             }),
         }
         .serialize_state(serializer, &())
@@ -435,27 +434,25 @@ impl<'de, 'a, 'src, 'ctx> DeserializeState<'de, &'a CompCtx<'src, 'ctx>> for Val
         deserializer: D,
     ) -> Result<Self, D::Error> {
         let ctx = *seed;
-        ValueShim::deserialize_state(seed, deserializer).and_then(
+        ValueShim::deserialize_state(seed, deserializer).map(
             |ValueShim {
-                 loc,
                  comp_val,
                  inter_val,
                  data_type,
                  frozen,
              }| {
-                use de::Error;
                 use inkwell::module::Linkage::DLLImport;
                 let mut var = Value {
-                    loc,
                     data_type,
                     frozen,
                     name: None,
                     comp_val: None,
+                    loc: unreachable_span(),
                     address: Default::default(),
                     inter_val: inter_val.map(|iv| iv.into_owned()),
                 };
                 let Some(comp_val) = comp_val else {
-                    return Ok(var);
+                    return var;
                 };
                 if let Some(ty) = var
                     .data_type
@@ -482,16 +479,7 @@ impl<'de, 'a, 'src, 'ctx> DeserializeState<'de, &'a CompCtx<'src, 'ctx>> for Val
                     if good {
                         if let Some(llt) = ty.ret().llvm_type(ctx) {
                             let ft = llt.fn_type(&ps, false);
-                            let fv = ctx.module.add_function(
-                                std::str::from_utf8(comp_val).map_err(|_| {
-                                    D::Error::invalid_value(
-                                        de::Unexpected::Bytes(comp_val),
-                                        &"a string",
-                                    )
-                                })?,
-                                ft,
-                                None,
-                            );
+                            let fv = ctx.module.add_function(&comp_val, ft, None);
                             if let Some(InterData::Function(FnData { cconv, .. })) = var.inter_val {
                                 fv.set_call_conventions(cconv)
                             }
@@ -500,41 +488,26 @@ impl<'de, 'a, 'src, 'ctx> DeserializeState<'de, &'a CompCtx<'src, 'ctx>> for Val
                             var.comp_val = Some(gv.as_pointer_value().into());
                         } else if ty.ret().size() == SizeType::Static(0) {
                             let ft = ctx.context.void_type().fn_type(&ps, false);
-                            let fv = ctx.module.add_function(
-                                std::str::from_utf8(comp_val).map_err(|_| {
-                                    D::Error::invalid_value(
-                                        de::Unexpected::Bytes(comp_val),
-                                        &"a string",
-                                    )
-                                })?,
-                                ft,
-                                None,
-                            );
+                            let fv = ctx.module.add_function(&comp_val, ft, None);
                             if let Some(InterData::Function(FnData { cconv, .. })) = var.inter_val {
                                 fv.set_call_conventions(cconv)
                             }
                             let gv = fv.as_global_value();
                             gv.set_linkage(DLLImport);
                             var.comp_val = Some(gv.as_pointer_value().into());
                         }
-                        return Ok(var);
+                        return var;
                     }
                 } else if let Some(t) = var
                     .data_type
                     .downcast::<types::Reference>()
                     .and_then(|t| t.llvm_type(ctx))
                 {
-                    let gv = ctx.module.add_global(
-                        t,
-                        None,
-                        std::str::from_utf8(comp_val).map_err(|_| {
-                            D::Error::invalid_value(de::Unexpected::Bytes(comp_val), &"a string")
-                        })?,
-                    );
+                    let gv = ctx.module.add_global(t, None, &comp_val);
                     gv.set_linkage(DLLImport);
                     var.comp_val = Some(gv.as_pointer_value().into());
                 }
-                Ok(var)
+                var
             },
         )
     }
diff --git a/cobalt-ast/src/varmap.rs b/cobalt-ast/src/varmap.rs
@@ -148,6 +148,12 @@ impl Serialize for Symbol<'_, '_> {
 fn skip_serializing_parent(p: &Option<Box<VarMap>>) -> bool {
     p.as_ref().map_or(true, |p| p.parent.is_none())
 }
+fn serialize_var_symbols<S: Serializer>(
+    syms: &HashMap<Cow<str>, Symbol>,
+    serializer: S,
+) -> Result<S::Ok, S::Error> {
+    serializer.collect_map(syms.iter().filter(|v| v.1 .1.export))
+}
 
 #[derive(Debug, Clone, Default, SerializeState, DeserializeState)]
 #[serde(crate = "serde_state")]
@@ -156,7 +162,7 @@ fn skip_serializing_parent(p: &Option<Box<VarMap>>) -> bool {
 pub struct VarMap<'src, 'ctx> {
     #[serde(deserialize_state, skip_serializing_if = "skip_serializing_parent")]
     pub parent: Option<Box<Self>>,
-    #[serde(deserialize_state)]
+    #[serde(deserialize_state, serialize_with = "serialize_var_symbols")]
     pub symbols: HashMap<Cow<'src, str>, Symbol<'src, 'ctx>>,
     pub imports: Vec<(CompoundDottedName<'src>, bool)>,
 }
