add invalid unicode syntax and rust-as-baml tests

Author: imalsogreg

baml_language/crates/baml_hir/src/pretty_print.rs

@@ -1,14 +1,15 @@
 //! Pretty printing for HIR items.
 
-use crate::{ClassId, EnumId, FunctionId, ItemId};
 use std::fmt;
 
+use crate::{ClassId, EnumId, FunctionId, ItemId};
+
 impl fmt::Display for ItemId {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            ItemId::Function(func) => write!(f, "{}", func),
-            ItemId::Class(class) => write!(f, "{}", class),
-            ItemId::Enum(enum_) => write!(f, "{}", enum_),
+            ItemId::Function(func) => write!(f, "{func}"),
+            ItemId::Class(class) => write!(f, "{class}"),
+            ItemId::Enum(enum_) => write!(f, "{enum_}"),
         }
     }
 }
@@ -36,7 +37,7 @@ pub fn format_items(items: &[ItemId]) -> String {
     let mut output = String::new();
 
     for item in items {
-        output.push_str(&format!("  {}\n", item));
+        output.push_str(&format!("  {item}\n"));
     }
 
     if output.is_empty() {
@@ -65,23 +66,23 @@ pub fn format_items_grouped(items: &[ItemId]) -> String {
     if !functions.is_empty() {
         output.push_str("Functions:\n");
         for func in functions {
-            output.push_str(&format!("  {}\n", func));
+            output.push_str(&format!("  {func}\n"));
         }
         output.push('\n');
     }
 
     if !classes.is_empty() {
         output.push_str("Classes:\n");
         for class in classes {
-            output.push_str(&format!("  {}\n", class));
+            output.push_str(&format!("  {class}\n"));
         }
         output.push('\n');
     }
 
     if !enums.is_empty() {
         output.push_str("Enums:\n");
         for enum_ in enums {
-            output.push_str(&format!("  {}\n", enum_));
+            output.push_str(&format!("  {enum_}\n"));
         }
         output.push('\n');
     }

baml_language/crates/baml_onionskin/examples/demo.baml

@@ -1,6 +1,58 @@
-function FooDemo() -> int {
-  let x = 100;
-  let z = 100;
-  20    
+class Receipt {
+  establishment_name string
+  date string @description("ISO8601 formatted date")
+  total int @description("The total amount of the receipt")
+  currency string
+  items Item[] @description("The items on the receipt")
+}
 
+class Item {
+  name string
+  price float
+  quantity int @description("If not specified, assume 1")
+}
+ 
+// This is our LLM function we can call in Python or Typescript
+// the receipt can be an image OR text here!
+function ExtractReceipt(receipt: image | string) -> Receipt {
+  // see clients.baml
+  client GPT4o
+  prompt #"
+    {# start a user message #}
+    {{ _.role("user") }}
+
+    Extract info from this receipt:
+    {{ receipt }}
+
+    {# special macro to print the output schema instructions. #}
+    {{ ctx.output_format }}
+  "#
+}
+
+// Test when the input is an image
+test ImageReceiptTest {
+  functions [ExtractReceipt]
+  args {
+    receipt { url "https://i.redd.it/adzt4bz4llfc1.jpeg"}
+  }
+}
+
+// Test when the input is a string
+test StarbucksTextReceiptTest {
+  functions [ExtractReceipt]
+  args {
+    // use #""# for multi-line strings
+    receipt #"
+      Starbucks
+      Date: 2022-01-01
+      Total: $5.00 USD
+      Items:
+      - Coffee
+        - $2.50
+        - 1
+      - Croissant
+        - $2.50
+        - 1
+    "#
+  }
 }

baml_language/crates/baml_onionskin/src/app.rs

@@ -1,15 +1,16 @@
-use crate::compiler::{CompilerPhase, CompilerRunner, VisualizationMode, read_files_from_disk};
-use crate::ui;
-use crate::watcher::FileWatcher;
+use std::{collections::HashMap, path::PathBuf, time::Duration};
+
 use anyhow::Result;
 use crossterm::event::{self, Event, KeyCode, KeyEvent, KeyModifiers, MouseEventKind};
-use ratatui::Terminal;
-use ratatui::backend::CrosstermBackend;
-use std::collections::HashMap;
-use std::path::PathBuf;
-use std::time::Duration;
+use ratatui::{Terminal, backend::CrosstermBackend};
+
+use crate::{
+    compiler::{CompilerPhase, CompilerRunner, VisualizationMode, read_files_from_disk},
+    ui,
+    watcher::FileWatcher,
+};
 
-pub struct App {
+pub(crate) struct App {
     file_path: PathBuf,
     /// Which tab is shown in the TUI.
     current_phase: CompilerPhase,
@@ -28,7 +29,7 @@ pub struct App {
 }
 
 impl App {
-    pub fn new(path: PathBuf) -> Result<Self> {
+    pub(crate) fn new(path: PathBuf) -> Result<Self> {
         let watcher = FileWatcher::new(&path)?;
         let mut compiler = CompilerRunner::new(&path);
 
@@ -52,7 +53,7 @@ impl App {
         })
     }
 
-    pub fn run(
+    pub(crate) fn run(
         &mut self,
         terminal: &mut Terminal<CrosstermBackend<std::io::Stdout>>,
     ) -> Result<()> {
@@ -193,42 +194,42 @@ impl App {
         Ok(())
     }
 
-    pub fn current_phase(&self) -> CompilerPhase {
+    pub(crate) fn current_phase(&self) -> CompilerPhase {
         self.current_phase
     }
 
-    pub fn current_output(&self) -> &str {
+    pub(crate) fn current_output(&self) -> &str {
         self.compiler
             .get_phase_output(self.current_phase)
             .unwrap_or("No output available")
     }
 
-    pub fn snapshot_output(&self) -> Option<&str> {
+    pub(crate) fn snapshot_output(&self) -> Option<&str> {
         self.snapshot_compiler
             .as_ref()
             .and_then(|c| c.get_phase_output(self.current_phase))
     }
 
-    pub fn file_path(&self) -> &PathBuf {
+    pub(crate) fn file_path(&self) -> &PathBuf {
         &self.file_path
     }
 
-    pub fn has_snapshot(&self) -> bool {
+    pub(crate) fn has_snapshot(&self) -> bool {
         self.snapshot_compiler.is_some()
     }
 
-    pub fn scroll_offset(&self) -> u16 {
+    pub(crate) fn scroll_offset(&self) -> u16 {
         self.scroll_offset
     }
 
-    pub fn get_recomputation_status(
+    pub(crate) fn get_recomputation_status(
         &self,
         phase: CompilerPhase,
     ) -> crate::compiler::RecomputationStatus {
         self.compiler.get_recomputation_status(phase)
     }
 
-    pub fn get_snapshot_recomputation_status(
+    pub(crate) fn get_snapshot_recomputation_status(
         &self,
         phase: CompilerPhase,
     ) -> Option<crate::compiler::RecomputationStatus> {
@@ -237,15 +238,15 @@ impl App {
             .map(|c| c.get_recomputation_status(phase))
     }
 
-    pub fn get_output_annotated(
+    pub(crate) fn get_output_annotated(
         &self,
         phase: CompilerPhase,
     ) -> Vec<(String, crate::compiler::LineStatus)> {
         self.compiler
             .get_annotated_output_with_mode(phase, self.visualization_mode)
     }
 
-    pub fn get_snapshot_output_annotated(
+    pub(crate) fn get_snapshot_output_annotated(
         &self,
         phase: CompilerPhase,
     ) -> Option<Vec<(String, crate::compiler::LineStatus)>> {
@@ -255,11 +256,11 @@ impl App {
         })
     }
 
-    pub fn visualization_mode(&self) -> VisualizationMode {
+    pub(crate) fn visualization_mode(&self) -> VisualizationMode {
         self.visualization_mode
     }
 
-    pub fn visualization_mode_name(&self) -> &'static str {
+    pub(crate) fn visualization_mode_name(&self) -> &'static str {
         match self.visualization_mode {
             VisualizationMode::Diff => "Diff",
             VisualizationMode::Salsa => "Salsa",