creating a signature for every type in the IR

Author: hellovai

engine/Cargo.lock

@@ -10,6 +10,7 @@ members = [
   "language_client_python",
   "language_client_ruby/ext/ruby_ffi",
   "language_client_typescript",
+  "boundary-collector",
   "sandbox",
 ]
 default-members = [
@@ -26,6 +27,7 @@ default-members = [
   "language_client_python",
   "language_client_ruby/ext/ruby_ffi",
   "language_client_typescript",
+  "boundary-collector",
 ]
 
 [workspace.dependencies]
@@ -55,6 +57,8 @@ internal-baml-core = { path = "baml-lib/baml-core" }
 internal-baml-jinja = { path = "baml-lib/jinja-runtime" }
 internal-baml-schema-ast = { path = "baml-lib/schema-ast" }
 internal-llm-client = { path = "baml-lib/llm-client" }
+baml-runtime = { path = "baml-runtime" }
+
 log = "0.4.20"
 # TODO: disable imports, etc
 minijinja = { version = "1.0.16", default-features = false, features = [

engine/Cargo.toml

@@ -3,6 +3,7 @@ pub mod jinja_helpers;
 mod json_schema;
 pub mod repr;
 mod walker;
+pub mod signature;
 
 pub use ir_helpers::{
     scope_diagnostics, ArgCoercer, ClassFieldWalker, ClassWalker, ClientWalker, EnumValueWalker,

engine/baml-lib/baml-core/src/ir/mod.rs

@@ -23,7 +23,7 @@ use internal_llm_client::{ClientProvider, ClientSpec, UnresolvedClientProperty};
 use serde::Serialize;
 
 use crate::Configuration;
-
+use crate::ir::signature::{BamlHash, ProvideBamlHash};
 /// This class represents the intermediate representation of the BAML AST.
 /// It is a representation of the BAML AST that is easier to work with than the
 /// raw BAML AST, and should include all information necessary to generate
@@ -327,6 +327,23 @@ impl IntermediateRepr {
             recursive_aliases,
         ))
     }
+
+    pub fn create_baml_hash(&self) -> String {
+        // hash everything we can based on the IR
+        let enum_names = self
+            .enums
+            .iter()
+            .map(|e| {
+                let hash = e.to_baml_hash();
+
+                (
+                    e.elem.name.as_str(),
+                    hash,
+                )
+            })
+            .collect::<IndexMap<_, _>>();
+        return "TODO".to_string();
+    }
 }
 
 // TODO:

engine/baml-lib/baml-core/src/ir/repr.rs

@@ -0,0 +1,107 @@
+use baml_types::{Resolvable, StringOr};
+
+mod r#enum;
+mod class;
+mod template_string;
+mod test_case;
+mod client;
+mod function;
+mod type_alias;
+#[cfg(test)]
+mod test;
+
+/// Used to identify unique signatures of types.
+
+pub(super) trait Signature {
+    fn type_name(&self) -> &'static str;
+    fn interface(&self) -> Option<String>;
+    fn impl_(&self) -> Option<String> {
+        None
+    }
+}
+
+pub struct BamlHash {
+    type_name: &'static str,
+    interface_hash: Option<u64>,
+    impl_hash: Option<u64>,
+}
+
+pub trait ProvideBamlHash {
+    fn to_baml_hash(&self) -> BamlHash;
+}
+
+fn hash_string(type_name: &str, s: &str) -> u64 {
+    let mut hasher = std::collections::hash_map::DefaultHasher::new();
+    std::hash::Hash::hash(&(type_name, s), &mut hasher);
+    std::hash::Hasher::finish(&hasher)
+}
+
+impl<T: Signature> ProvideBamlHash for T {
+    fn to_baml_hash(&self) -> BamlHash {
+        BamlHash {
+            type_name: self.type_name(),
+            interface_hash: self.interface().map(|s| hash_string(self.type_name(), &s)),
+            impl_hash: self.impl_().map(|s| hash_string(self.type_name(), &s)),
+        }
+    }
+}
+
+impl<Meta> Signature for Resolvable<StringOr, Meta> {
+    fn type_name(&self) -> &'static str {
+        match self {
+            Resolvable::String(s, _) => s.type_name(),
+            Resolvable::Numeric(n, _) => "numeric",
+            Resolvable::Bool(b, _) => "bool",
+            Resolvable::Array(_, _) => "array",
+            Resolvable::Map(_, _) => "map",
+            Resolvable::Null(_) => "null",
+        }
+    }
+
+    fn interface(&self) -> Option<String> {
+        match self {
+            Resolvable::String(value, _) => value.interface(),
+            Resolvable::Numeric(value, _) => Some(value.to_string()),
+            Resolvable::Bool(value, _) => Some(value.to_string()),
+            Resolvable::Array(resolvables, _) => Some(resolvables
+                .iter()
+                .filter_map(|r| r.interface())
+                .collect::<Vec<_>>()
+                .join("_BAML_ARRAY_")),
+            Resolvable::Map(index_map, _) => Some(index_map
+                .iter()
+                .filter_map(|(k, (_, v))| v.interface().map(|s| format!("{}: {}", k, s)))
+                .collect::<Vec<_>>()
+                .join("_BAML_MAP_")),
+            Resolvable::Null(_) => Some("null".to_string()),
+        }
+    }
+}
+
+impl Signature for StringOr {
+    fn type_name(&self) -> &'static str {
+        match self {
+            StringOr::EnvVar(_) => "env_var",
+            StringOr::Value(_) => "value",
+            StringOr::JinjaExpression(j) => j.type_name(),
+        }
+    }
+
+    fn interface(&self) -> Option<String> {
+        match self {
+            StringOr::EnvVar(name) => Some(name.clone()),
+            StringOr::Value(value) => Some(value.clone()),
+            StringOr::JinjaExpression(expression) => expression.interface(),
+        }
+    }
+}
+
+impl Signature for baml_types::JinjaExpression {
+    fn type_name(&self) -> &'static str {
+        "jinja_expression"
+    }
+
+    fn interface(&self) -> Option<String> {
+        Some(self.to_string())
+    }
+}