fix: match latest ltk_meta

Author: alanpq

crates/ltk_ritobin/src/typecheck/name_ext.rs

@@ -1,11 +1,11 @@
-use ltk_meta::BinPropertyKind;
+use ltk_meta::PropertyKind;
 
 pub trait RitobinName: Sized {
     fn from_ritobin_name(name: &str) -> Option<Self>;
     fn to_ritobin_name(self) -> &'static str;
 }
 
-impl RitobinName for BinPropertyKind {
+impl RitobinName for PropertyKind {
     fn from_ritobin_name(name: &str) -> Option<Self> {
         match name {
             "none" => Some(Self::None),

crates/ltk_ritobin/src/typecheck/visitor.rs

@@ -6,11 +6,8 @@ use std::{
 use indexmap::IndexMap;
 use ltk_hash::fnv1a;
 use ltk_meta::{
-    value::{
-        ContainerValue, EmbeddedValue, HashValue, MapValue, OptionalValue, StringValue,
-        UnorderedContainerValue, Vector2Value, Vector3Value,
-    },
-    BinPropertyKind, PropertyValueEnum,
+    property::{values, NoMeta},
+    PropertyKind, PropertyValueEnum,
 };
 
 use crate::{
@@ -494,8 +491,7 @@ pub fn resolve_value(
     tree: &Cst,
     kind_hint: Option<BinPropertyKind>,
 ) -> Result<Option<Spanned<PropertyValueEnum>>, Diagnostic> {
-    use ltk_meta::value::*;
-    use BinPropertyKind as K;
+    use PropertyKind as K;
     use PropertyValueEnum as P;
 
     // dbg!(tree, kind_hint);
@@ -540,12 +536,14 @@ pub fn resolve_value(
                 }
             };
             match kind_hint {
-                K::Struct => P::Struct(StructValue {
+                K::Struct => P::Struct(values::Struct {
                     class_hash,
+                    meta: NoMeta,
                     properties: Default::default(),
                 }),
-                K::Embedded => P::Embedded(EmbeddedValue(StructValue {
+                K::Embedded => P::Embedded(values::Embedded(values::Struct {
                     class_hash,
+                    meta: NoMeta,
                     properties: Default::default(),
                 })),
                 other => {
@@ -698,7 +696,8 @@ pub fn resolve_entry(
     };
 
     Ok(IrEntry {
-        key: PropertyValueEnum::String(StringValue(ctx.text[key.span].into())).with_span(key.span),
+        key: PropertyValueEnum::String(values::String(ctx.text[key.span].into()))
+            .with_span(key.span),
         value,
     })
 }
@@ -711,26 +710,28 @@ impl TypeChecker<'_> {
     fn merge_ir(&mut self, mut parent: IrItem, child: IrItem) -> IrItem {
         match &mut parent.value_mut().inner {
             PropertyValueEnum::Container(list)
-            | PropertyValueEnum::UnorderedContainer(UnorderedContainerValue(list)) => {
+            | PropertyValueEnum::UnorderedContainer(values::UnorderedContainer(list)) => {
                 match child {
                     IrItem::ListItem(IrListItem(value)) => {
-                        let value = match list.item_kind == value.kind() {
-                            true => value.inner, // FIXME: span info inside all containers??
-                            false => {
+                        let span = value.span; // FIXME: span info inside all containers
+
+                        match list.push(value.inner) {
+                            Ok(_) => {}
+                            Err(ltk_meta::Error::MismatchedContainerTypes { expected, got }) => {
                                 self.ctx.diagnostics.push(
                                     TypeMismatch {
-                                        span: value.span,
-                                        expected: RitoType::simple(list.item_kind),
+                                        span,
+                                        expected: RitoType::simple(list.item_kind()),
                                         expected_span: None, // TODO: would be nice here
                                         got: RitoType::simple(value.kind()).into(),
                                     }
                                     .unwrap(),
                                 );
-                                list.item_kind.default_value()
                             }
-                        };
-
-                        list.items.push(value);
+                            Err(e) => {
+                                todo!("handle unexpected error");
+                            }
+                        }
                     }
                     IrItem::Entry(IrEntry { key, value }) => {
                         eprintln!("list item must be list item");
@@ -739,15 +740,15 @@ impl TypeChecker<'_> {
                 }
             }
             PropertyValueEnum::Struct(struct_val)
-            | PropertyValueEnum::Embedded(EmbeddedValue(struct_val)) => {
+            | PropertyValueEnum::Embedded(values::Embedded(struct_val)) => {
                 let IrItem::Entry(IrEntry { key, value }) = child else {
                     eprintln!("struct item must be entry");
                     return parent;
                 };
 
                 let key = match key.inner {
-                    PropertyValueEnum::String(StringValue(str)) => fnv1a::hash_lower(&str),
-                    PropertyValueEnum::Hash(HashValue(hash)) => hash,
+                    PropertyValueEnum::String(values::String(str)) => fnv1a::hash_lower(&str),
+                    PropertyValueEnum::Hash(values::Hash(hash)) => hash,
                     other => {
                         eprintln!("{other:?} not valid hash");
                         return parent;
@@ -768,19 +769,19 @@ impl TypeChecker<'_> {
                     eprintln!("map item must be entry");
                     return parent;
                 };
-                let value = match map_value.value_kind == value.kind() {
+                let value = match map_value.value_kind() == value.kind() {
                     true => value.inner, // FIXME: span info inside all containers??
                     false => {
                         self.ctx.diagnostics.push(
                             TypeMismatch {
                                 span: value.span,
-                                expected: RitoType::simple(map_value.value_kind),
+                                expected: RitoType::simple(map_value.value_kind()),
                                 expected_span: None, // TODO: would be nice here
                                 got: RitoType::simple(value.kind()).into(),
                             }
                             .unwrap(),
                         );
-                        map_value.value_kind.default_value()
+                        map_value.value_kind().default_value()
                     }
                 };
                 map_value