wip: remove span

Author: alanpq

crates/ltk_ritobin/src/typecheck/visitor.rs

@@ -18,41 +18,6 @@ use crate::{
     typecheck::RitobinName,
 };
 
-pub trait SpannedExt {
-    fn with_span(self, span: Span) -> Spanned<Self>
-    where
-        Self: Sized,
-    {
-        Spanned::new(self, span)
-    }
-}
-impl<T: Sized> SpannedExt for T {}
-
-#[derive(Debug, Clone, Copy)]
-pub struct Spanned<T> {
-    pub span: Span,
-    pub inner: T,
-}
-
-impl<T> Spanned<T> {
-    pub fn new(item: T, span: Span) -> Self {
-        Self { inner: item, span }
-    }
-}
-
-impl<T> Deref for Spanned<T> {
-    type Target = T;
-
-    fn deref(&self) -> &Self::Target {
-        &self.inner
-    }
-}
-impl<T> DerefMut for Spanned<T> {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.inner
-    }
-}
-
 #[derive(Debug, Clone)]
 pub enum ClassKind {
     Str(String),
@@ -61,12 +26,12 @@ pub enum ClassKind {
 
 #[derive(Debug, Clone)]
 pub struct IrEntry {
-    pub key: Spanned<PropertyValueEnum>,
-    pub value: Spanned<PropertyValueEnum>,
+    pub key: PropertyValueEnum<Span>,
+    pub value: PropertyValueEnum<Span>,
 }
 
 #[derive(Debug, Clone)]
-pub struct IrListItem(pub Spanned<PropertyValueEnum>);
+pub struct IrListItem(pub PropertyValueEnum<Span>);
 
 #[derive(Debug, Clone)]
 pub enum IrItem {
@@ -94,19 +59,19 @@ impl IrItem {
             _ => None,
         }
     }
-    pub fn value(&self) -> &Spanned<PropertyValueEnum> {
+    pub fn value(&self) -> &PropertyValueEnum<Span> {
         match self {
             IrItem::Entry(i) => &i.value,
             IrItem::ListItem(i) => &i.0,
         }
     }
-    pub fn value_mut(&mut self) -> &mut Spanned<PropertyValueEnum> {
+    pub fn value_mut(&mut self) -> &mut PropertyValueEnum<Span> {
         match self {
             IrItem::Entry(i) => &mut i.value,
             IrItem::ListItem(i) => &mut i.0,
         }
     }
-    pub fn into_value(self) -> Spanned<PropertyValueEnum> {
+    pub fn into_value(self) -> PropertyValueEnum<Span> {
         match self {
             IrItem::Entry(i) => i.value,
             IrItem::ListItem(i) => i.0,
@@ -116,7 +81,7 @@ impl IrItem {
 
 pub struct TypeChecker<'a> {
     ctx: Ctx<'a>,
-    pub root: IndexMap<String, Spanned<PropertyValueEnum>>,
+    pub root: IndexMap<String, PropertyValueEnum<Span>>,
     // current: Option<(PropertyValueEnum, PropertyValueEnum)>,
     stack: Vec<(u32, IrItem)>,
     list_queue: Vec<IrListItem>,
@@ -139,7 +104,7 @@ impl<'a> TypeChecker<'a> {
     pub fn into_parts(
         self,
     ) -> (
-        IndexMap<String, Spanned<PropertyValueEnum>>,
+        IndexMap<String, PropertyValueEnum<Span>>,
         Vec<DiagnosticWithSpan>,
     ) {
         (self.root, self.ctx.diagnostics)
@@ -476,7 +441,7 @@ pub fn resolve_value(
     ctx: &mut Ctx,
     tree: &Cst,
     kind_hint: Option<PropertyKind>,
-) -> Result<Option<Spanned<PropertyValueEnum>>, Diagnostic> {
+) -> Result<Option<PropertyValueEnum<Span>>, Diagnostic> {
     use PropertyKind as K;
     use PropertyValueEnum as P;
 
@@ -783,19 +748,19 @@ fn populate_vec_or_color(
     target: &mut IrItem,
     items: &mut Vec<IrListItem>,
 ) -> Result<(), MaybeSpanDiag> {
-    let resolve_f32 = |n: Spanned<PropertyValueEnum>| -> Result<f32, MaybeSpanDiag> {
-        match n.inner {
-            PropertyValueEnum::F32(values::F32 { value: n, .. }) => Ok(n),
+    let resolve_f32 = |n: PropertyValueEnum<Span>| -> Result<f32, MaybeSpanDiag> {
+        match n {
+            PropertyValueEnum::F32(values::F32 { value: n, meta: span }) => Ok(n),
             _ => Err(TypeMismatch {
-                span: n.span,
+                span: n.meta(),
                 expected: RitoType::simple(PropertyKind::F32),
                 expected_span: None, // TODO: would be nice
-                got: RitoTypeOrVirtual::RitoType(RitoType::simple(n.inner.kind())),
+                got: RitoTypeOrVirtual::RitoType(RitoType::simple(n.kind())),
             }
             .into()),
         }
     };
-    let resolve_u8 = |n: Spanned<PropertyValueEnum>| -> Result<u8, MaybeSpanDiag> {
+    let resolve_u8 = |n: PropertyValueEnum<Span>| -> Result<u8, MaybeSpanDiag> {
         match n.inner {
             PropertyValueEnum::U8(values::U8 { value: n, .. }) => Ok(n),
             _ => Err(TypeMismatch {