Add InputValue ser/de support for metadata container

Signed-off-by: akhilles <[email protected]>

Author: akhilles

crates/pcb-zen-core/src/lang/input.rs

@@ -21,6 +21,7 @@ use starlark::values::record::{FrozenRecord, FrozenRecordType, Record, RecordTyp
 use starlark::values::{Trace, Value, ValueLike};
 
 use crate::lang::interface::{get_promotion_map, FrozenInterfaceValue, InterfaceValue};
+use crate::lang::metadata::MetadataContainer;
 use crate::lang::net::NetValue;
 use crate::lang::physical::PhysicalValue;
 use crate::{FrozenNetValue, NetId};
@@ -66,6 +67,9 @@ pub enum InputValue {
         promotion_by_type: SmallMap<String, String>,
     },
 
+    /// Represents a metadata container (stores ref_id for later lookup)
+    MetadataContainer(MetadataContainer),
+
     /// Fallback for unsupported / complex values.
     #[allocative(skip)]
     Unsupported(String),
@@ -112,6 +116,7 @@ impl fmt::Display for InputValue {
                     )
                 }
             }
+            InputValue::MetadataContainer(mc) => write!(f, "{}", mc),
             InputValue::Unsupported(s) => write!(f, "Unsupported({s})"),
         }
     }
@@ -278,6 +283,7 @@ impl InputValue {
                 eval.eval_function(typ_val, &[], &named)
                     .map_err(|e| anyhow!(e.to_string()))
             }
+            InputValue::MetadataContainer(mc) => Ok(heap.alloc(*mc)),
             InputValue::Unsupported(s) => Err(anyhow!("unsupported input value type: {s}")),
         }
     }
@@ -423,6 +429,10 @@ impl InputValue {
             };
         }
 
+        if let Some(metadata_container) = value.downcast_ref::<MetadataContainer>() {
+            return InputValue::MetadataContainer(*metadata_container);
+        }
+
         InputValue::Unsupported(value.get_type().to_owned())
     }
 }

crates/pcb-zen-core/src/lang/metadata.rs

@@ -3,6 +3,7 @@ use std::sync::atomic::{AtomicU64, Ordering};
 
 use allocative::Allocative;
 use anyhow::anyhow;
+use serde::{Deserialize, Serialize};
 use starlark::any::ProvidesStaticType;
 use starlark::environment::GlobalsBuilder;
 use starlark::eval::{Arguments, Evaluator};
@@ -16,7 +17,7 @@ use starlark::values::{Freeze, Heap, NoSerialize, StarlarkValue, Value, ValueLik
 
 use crate::lang::evaluator_ext::EvaluatorExt;
 use crate::lang::input::InputValue;
-use crate::lang::physical::PhysicalValue;
+use crate::lang::physical::{physical_unit_from_ty, PhysicalValue};
 
 /// Helper to access metadata store with error handling
 fn with_metadata_store<T>(
@@ -96,7 +97,9 @@ impl MetadataStore {
 }
 
 /// A metadata container that holds a reference ID
-#[derive(Debug, Copy, Clone, ProvidesStaticType, NoSerialize, Allocative, Freeze)]
+#[derive(
+    Debug, Copy, Clone, PartialEq, ProvidesStaticType, Serialize, Deserialize, Allocative, Freeze,
+)]
 pub struct MetadataContainer {
     pub ref_id: u64,
 }
@@ -201,8 +204,10 @@ impl<'v> StarlarkValue<'v> for MetadataContainerPush {
             );
         }
         // If physical value, do unit checking in addition to type checking
-        if let Some(physical_value) = value.downcast_ref::<PhysicalValue>() {
-            physical_value.check_unit_ty(type_compiled.as_ty())?;
+        if let Some(expected) = physical_unit_from_ty(type_compiled.as_ty()) {
+            if let Some(physical_value) = value.downcast_ref::<PhysicalValue>() {
+                physical_value.check_unit(expected.into())?;
+            }
         }
 
         let input_value = InputValue::from_value(value);

crates/pcb-zen-core/src/lang/physical.rs

@@ -159,12 +159,6 @@ impl PhysicalValue {
         Ok(self)
     }
 
-    pub fn check_unit_ty(self, ty: &Ty) -> Result<Self, PhysicalValueError> {
-        let expected_unit =
-            physical_unit_from_ty(ty).ok_or(PhysicalValueError::InvalidPhysicalUnit)?;
-        self.check_unit(expected_unit.into())
-    }
-
     pub fn from_arguments<'v, T: PhysicalUnitType<'v>>(
         positional: &[Value<'v>],
         kwargs: &SmallMap<ValueTyped<'v, StarlarkStr>, Value<'v>>,
@@ -1432,7 +1426,7 @@ define_physical_unit!(MagneticFluxType, PhysicalUnit::Webers, "MagneticFlux");
 
 /// Helper function to extract PhysicalUnit from a Ty by matching the type name
 /// Returns Some(PhysicalUnit) if the type matches a known physical unit type
-fn physical_unit_from_ty(ty: &Ty) -> Option<PhysicalUnit> {
+pub fn physical_unit_from_ty(ty: &Ty) -> Option<PhysicalUnit> {
     // Try to convert the type to string and match against known names
     let type_str = ty.to_string();
     match type_str.as_str() {