rename

engine/baml-fmt/src/lint.rs

@@ -110,7 +110,8 @@ pub(crate) fn run(input: &str) -> String {
         })).collect::<Vec<_>>(),
         "functions": schema
         .db
-        .walk_functions()
+        .walk_old_functions()
+        .chain(schema.db.walk_new_functions())
         .map(|func| {
             json!({
                 "name": StringSpan::new(func.name(), func.identifier().span()),

engine/baml-lib/baml-core/src/generate/generate_python_client_old.rs

@@ -39,7 +39,8 @@ pub(crate) fn generate_py(
     db.walk_enums().for_each(|e| generate_py_file(&e, &mut fc));
     db.walk_classes()
         .for_each(|c| generate_py_file(&c, &mut fc));
-    db.walk_functions()
+    db.walk_old_functions()
+        .chain(db.walk_new_functions())
         .for_each(|f| generate_py_file(&f, &mut fc));
     let mut variants = db.walk_variants().collect::<Vec<_>>();
     variants.sort_by(|a, b| {
@@ -142,20 +143,23 @@ impl WithWritePythonString for ParserDatabase {
         fc.complete_file();
 
         fc.start_export_file("./baml_types", "__init__");
-        self.walk_functions().for_each(|f| {
-            fc.last_file().add_import(
-                &format!("..__do_not_import.functions.{}", f.file_name()),
-                &format!("I{}", f.name()),
-            );
-            fc.last_file().add_import(
-                &format!("..__do_not_import.functions.{}", f.file_name()),
-                &format!("I{}Stream", f.name()),
-            );
-            fc.last_file().add_import(
-                &format!("..__do_not_import.functions.{}", f.file_name()),
-                &format!("I{}Output", f.name()),
-            )
-        });
+
+        self.walk_old_functions()
+            .chain(self.walk_new_functions())
+            .for_each(|f| {
+                fc.last_file().add_import(
+                    &format!("..__do_not_import.functions.{}", f.file_name()),
+                    &format!("I{}", f.name()),
+                );
+                fc.last_file().add_import(
+                    &format!("..__do_not_import.functions.{}", f.file_name()),
+                    &format!("I{}Stream", f.name()),
+                );
+                fc.last_file().add_import(
+                    &format!("..__do_not_import.functions.{}", f.file_name()),
+                    &format!("I{}Output", f.name()),
+                )
+            });
         self.walk_enums().for_each(|e| {
             fc.last_file().add_import(
                 &format!("..__do_not_import.types.enums.{}", e.file_name()),
@@ -191,7 +195,8 @@ impl WithWritePythonString for ParserDatabase {
 
         fc.start_py_file(".", "generated_baml_client");
         let mut fxs = self
-            .walk_functions()
+            .walk_old_functions()
+            .chain(self.walk_new_functions())
             .map(|f| {
                 fc.last_file().add_import(
                     &format!(".functions.{}", f.file_name()),

engine/baml-lib/baml-core/src/generate/generate_python_client_old/function.rs

@@ -1,4 +1,4 @@
-use internal_baml_parser_database::walkers::{ArgWalker, EnumWalker, Walker};
+use internal_baml_parser_database::walkers::{ArgWalker, EnumWalker, FunctionWalker, Walker};
 use internal_baml_schema_ast::ast::{
     FieldType, FunctionArg, FunctionId, Identifier, WithDocumentation, WithName,
 };
@@ -92,15 +92,22 @@ impl JsonHelper for ArgWalker<'_> {
     }
 }
 
-impl JsonHelper for Walker<'_, FunctionId> {
+impl JsonHelper for FunctionWalker<'_> {
     fn json(&self, f: &mut File) -> serde_json::Value {
-        let mut impls = self
-            .walk_variants()
-            .map(|v| v.name().to_string())
-            .collect::<Vec<_>>();
-        impls.sort();
+        let impls = if self.is_old_function() {
+            let mut impls = self
+                .walk_variants()
+                .map(|v| v.name().to_string())
+                .collect::<Vec<_>>();
+            impls.sort();
+            impls
+        } else {
+            // New function logic
+            vec!["default".into()]
+        };
+
         let mut inputs = self.walk_input_args().collect::<Vec<_>>();
-        inputs.sort_by(|a, b| a.is_optional().cmp(&b.is_optional()));
+        inputs.sort_by(|a, b| a.name().cmp(&b.name()));
 
         json!({
             "name": self.ast_function().name(),
@@ -130,7 +137,7 @@ fn is_enum<'a>(
     return false;
 }
 
-impl WithWritePythonString for Walker<'_, FunctionId> {
+impl WithWritePythonString for FunctionWalker<'_> {
     fn file_name(&self) -> String {
         format!("fx_{}", clean_file_name(self.name()))
     }
@@ -152,5 +159,20 @@ impl WithWritePythonString for Walker<'_, FunctionId> {
             json,
         );
         fc.complete_file();
+
+        if !self.is_old_function() {
+            let impl_name = format!("fx_{}_impl_default", clean_file_name(self.name()));
+
+            fc.start_py_file("impls", "__init__.py");
+            fc.last_file()
+                .add_line(format!("from .{0} import default as unused_{0}", impl_name,));
+            fc.complete_file();
+
+            // May need to do some fancy stuff
+            fc.start_py_file("impls", impl_name);
+            // let json = self.json(fc.last_file());
+            // render_template(super::template::HSTemplate::Variant, fc.last_file(), json);
+            fc.complete_file();
+        }
     }
 }

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

@@ -79,7 +79,8 @@ impl IntermediateRepr {
                 .map(|e| e.node(db))
                 .collect::<Result<Vec<_>>>()?,
             functions: db
-                .walk_functions()
+                .walk_old_functions()
+                .chain(db.walk_new_functions())
                 .map(|e| e.node(db))
                 .collect::<Result<Vec<_>>>()?,
             clients: db
@@ -354,7 +355,7 @@ impl WithRepr<EnumValue> for EnumValueWalker<'_> {
 
         attributes.meta = to_ir_attributes(db, self.get_default_attributes());
 
-        for r#fn in db.walk_functions() {
+        for r#fn in db.walk_old_functions() {
             for r#impl in r#fn.walk_variants() {
                 let node_attributes = to_ir_attributes(db, self.get_override(&r#impl));
 
@@ -381,7 +382,7 @@ impl WithRepr<Enum> for EnumWalker<'_> {
 
         attributes.meta = to_ir_attributes(db, self.get_default_attributes());
 
-        for r#fn in db.walk_functions() {
+        for r#fn in db.walk_old_functions() {
             for r#impl in r#fn.walk_variants() {
                 let node_attributes =
                     to_ir_attributes(db, r#impl.find_serializer_attributes(self.name()));
@@ -420,7 +421,7 @@ impl WithRepr<Field> for FieldWalker<'_> {
 
         attributes.meta = to_ir_attributes(db, self.get_default_attributes());
 
-        for r#fn in db.walk_functions() {
+        for r#fn in db.walk_old_functions() {
             for r#impl in r#fn.walk_variants() {
                 let node_attributes = to_ir_attributes(db, self.get_override(&r#impl));
                 if !node_attributes.is_empty() {
@@ -458,7 +459,7 @@ impl WithRepr<Class> for ClassWalker<'_> {
 
         attributes.meta = to_ir_attributes(db, self.get_default_attributes());
 
-        for r#fn in db.walk_functions() {
+        for r#fn in db.walk_old_functions() {
             for r#impl in r#fn.walk_variants() {
                 let node_attributes =
                     to_ir_attributes(db, r#impl.find_serializer_attributes(self.name()));
@@ -724,12 +725,17 @@ impl WithRepr<Function> for FunctionWalker<'_> {
             }?,
             default_impl: self.metadata().default_impl.as_ref().map(|f| f.0.clone()),
             impls: {
-                let mut impls = self
-                    .walk_variants()
-                    .map(|e| e.node(db))
-                    .collect::<Result<Vec<_>>>()?;
-                impls.sort_by(|a, b| a.elem.name.cmp(&&b.elem.name));
-                impls
+                if self.is_old_function() {
+                    let mut impls = self
+                        .walk_variants()
+                        .map(|e| e.node(db))
+                        .collect::<Result<Vec<_>>>()?;
+                    impls.sort_by(|a, b| a.elem.name.cmp(&&b.elem.name));
+                    impls
+                } else {
+                    // TODO: @hellovai
+                    vec![]
+                }
             },
             tests: self
                 .walk_tests()

engine/baml-lib/baml-core/src/validate/validation_pipeline/validations/functions.rs

@@ -6,7 +6,7 @@ use crate::validate::validation_pipeline::context::Context;
 use super::common::validate_type_exists;
 
 pub(super) fn validate(ctx: &mut Context<'_>) {
-    for func in ctx.db.walk_functions() {
+    for func in ctx.db.walk_old_functions() {
         for args in func.walk_input_args().chain(func.walk_output_args()) {
             let arg = args.ast_arg();
             validate_type_exists(ctx, &arg.1.field_type)
@@ -45,4 +45,33 @@ pub(super) fn validate(ctx: &mut Context<'_>) {
             }
         }
     }
+
+    let clients = ctx
+        .db
+        .walk_clients()
+        .map(|c| c.name().to_string())
+        .collect::<Vec<_>>();
+    for func in ctx.db.walk_new_functions() {
+        for args in func.walk_input_args().chain(func.walk_output_args()) {
+            let arg = args.ast_arg();
+            validate_type_exists(ctx, &arg.1.field_type)
+        }
+
+        // Ensure the client is correct.
+        match func.client() {
+            Some(_) => {}
+            None => {
+                let client = func.metadata().client.as_ref().unwrap();
+                ctx.push_error(DatamodelError::not_found_error(
+                    "Client",
+                    &client.0,
+                    client.1.clone(),
+                    clients.clone(),
+                ))
+            }
+        }
+
+        // TODO: @sxlijin do any validation on the prompt.
+        let _prompt = func.jinja_prompt();
+    }
 }

engine/baml-lib/baml/tests/validation_files/functions_v2/invalid.baml

@@ -0,0 +1,31 @@
+function Foo() -> {
+  client Bar
+  prompt #"fa"#
+}
+
+function FooBar(arg) -> bar {
+
+}
+
+
+// error: Error validating function "Foo": No return type specified. Valid function syntax is
+// ```
+// function Foo(param1: String, param2: String) -> ReturnType {
+//     client SomeClient
+//     prompt #"..."#
+// }
+// ```
+//   -->  functions_v2/invalid.baml:1
+//    | 
+//    | 
+//  1 | function Foo() -> {
+//  2 |   client Bar
+//  3 |   prompt #"fa"#
+//  4 | }
+//    | 
+// error: Error validating: No type specified for argument: arg. Expected: `arg: type`
+//   -->  functions_v2/invalid.baml:6
+//    | 
+//  5 | 
+//  6 | function FooBar(arg) -> bar {
+//    | 

engine/baml-lib/baml/tests/validation_files/functions_v2/invalid2.baml

@@ -0,0 +1,92 @@
+function Foo1(arg: int) -> float {
+  client Foo
+}
+
+function Foo2(arg: int) -> float {
+  prompt #"..."#
+}
+
+function Foo3(arg: int) -> float {
+  client bar
+  prompt "..."
+}
+
+
+function Foo4(arg: int) -> float {
+  client bar
+  prompt
+}
+
+
+function Foo5(arg: int) -> float {
+  client
+  prompt #"..."#
+}
+
+
+function Foo6(arg: int) -> float {
+  client
+  prompt
+}
+
+// error: Error validating: Missing `prompt` field in function. Add to the block:
+// ```
+// prompt #"..."#
+// ```
+//   -->  functions_v2/invalid2.baml:1
+//    | 
+//    | 
+//  1 | function Foo1(arg: int) -> float {
+//    | 
+// error: Error validating: Missing `client` field in function. Add to the block:
+// ```
+// client GPT4
+// ```
+//   -->  functions_v2/invalid2.baml:5
+//    | 
+//  4 | 
+//  5 | function Foo2(arg: int) -> float {
+//    | 
+// error: Expected a template_string value, but received string value `"..."`.
+//   -->  functions_v2/invalid2.baml:11
+//    | 
+// 10 |   client bar
+// 11 |   prompt "..."
+//    | 
+// error: Error validating: Missing `prompt` field in function. Add to the block:
+// ```
+// prompt #"..."#
+// ```
+//   -->  functions_v2/invalid2.baml:9
+//    | 
+//  8 | 
+//  9 | function Foo3(arg: int) -> float {
+//    | 
+// error: Error validating: Missing `prompt` field in function. Add to the block:
+// ```
+// prompt #"..."#
+// ```
+//   -->  functions_v2/invalid2.baml:15
+//    | 
+// 14 | 
+// 15 | function Foo4(arg: int) -> float {
+//    | 
+// error: Error validating: Missing `client` field in function. Add to the block:
+// ```
+// client GPT4
+// ```
+//   -->  functions_v2/invalid2.baml:21
+//    | 
+// 20 | 
+// 21 | function Foo5(arg: int) -> float {
+//    | 
+// error: Error validating: Missing `prompt` and `client` fields in function. Add to the block:
+// ```
+// client GPT4
+// prompt #"..."#
+// ```
+//   -->  functions_v2/invalid2.baml:27
+//    | 
+// 26 | 
+// 27 | function Foo6(arg: int) -> float {
+//    | 

engine/baml-lib/baml/tests/validation_files/functions_v2/valid.baml

@@ -0,0 +1,9 @@
+function Foo() -> int {
+  client Bar
+  prompt #"fa"#
+}
+
+function Bar(a: string, b: int | bool) -> int {
+  client Bar
+  prompt #"fa"#
+}