remove duplicate function

engine/baml-lib/jsonish/src/deserializer/coercer/ir_ref/coerce_class.rs

@@ -1,5 +1,5 @@
 use anyhow::Result;
-use baml_types::{BamlMap, Constraint};
+use baml_types::BamlMap;
 use internal_baml_core::ir::FieldType;
 use internal_baml_jinja::types::{Class, Name};
 
@@ -11,7 +11,7 @@ use crate::deserializer::{
 
 use super::ParsingContext;
 
-// Name, type, description, constraints.
+// Name, type, description.
 type FieldValue = (Name, FieldType, Option<String>);
 
 impl TypeCoercer for Class {

engine/baml-lib/jsonish/src/tests/mod.rs

@@ -106,37 +106,6 @@ fn find_enum_value(
     Ok(Some((name, desc)))
 }
 
-/// Eliminate the `FieldType::Constrained` variant by searching for it, and stripping
-/// it off of its base type, returning a tulpe of the base type and any constraints found
-/// (if called on an argument that is not Constrained, the returned constraints Vec is
-/// empty).
-///
-/// If the function encounters directly nested Constrained types,
-/// (i.e. `FieldType::Constrained { base: FieldType::Constrained { .. }, .. } `)
-/// then the constraints of the two levels will be combined into a single vector.
-/// So, we always return a base type that is not FieldType::Constrained.
-fn distribute_constraints(field_type: &FieldType) -> (&FieldType, Vec<Constraint>) {
-
-    match field_type {
-        // Check the first level to see if it's constrained.
-        FieldType::Constrained { base, constraints } => {
-            match base.as_ref() {
-                // If so, we must check the second level to see if we need to combine
-                // constraints across levels.
-                // The recursion here means that arbitrarily nested `FieldType::Constrained`s
-                // will be collapsed before the function returns.
-                FieldType::Constrained{..} => {
-                    let (sub_base, sub_constraints) = distribute_constraints(base);
-                    let combined_constraints = vec![constraints.clone(), sub_constraints].into_iter().flatten().collect();
-                    (sub_base, combined_constraints)
-                },
-                _ => (base, constraints.clone()),
-            }
-        },
-        _ => (field_type, Vec::new()),
-    }
-}
-
 // TODO: (Greg) Is the use of `String` as a hash key safe? Is there some way to
 // get a collision that results in some type not getting put onto the stack?
 fn relevant_data_models<'a>(
@@ -151,7 +120,7 @@ fn relevant_data_models<'a>(
 
     while !start.is_empty() {
         let output = start.pop().unwrap();
-        match distribute_constraints(&output) {
+        match output.distribute_constraints() {
             (FieldType::Enum(enm), constraints) => {
                 if checked_types.insert(output.to_string()) {
                     let walker = ir.find_enum(enm);