typecheck more expressions

respect phase boundaries

resolve conflicts

Author: imalsogreg

baml_language/Cargo.lock

@@ -30,7 +30,7 @@ pub use baml_vm::{
     BinOp, Bytecode, Class, CmpOp, Enum, Function, FunctionKind, Instruction, Object, Program,
     UnaryOp, Value,
 };
-use baml_workspace::ProjectRoot;
+use baml_workspace::Project;
 pub use compiler::{Compiler, compile_function};
 
 /// Generate bytecode for all functions in a project.
@@ -39,7 +39,7 @@ pub use compiler::{Compiler, compile_function};
 /// It collects all functions from HIR, type-checks them via THIR,
 /// and compiles them to bytecode.
 #[salsa::tracked]
-pub fn generate_project_bytecode(db: &dyn baml_thir::Db, root: ProjectRoot) -> Program {
+pub fn generate_project_bytecode(db: &dyn baml_thir::Db, root: Project) -> Program {
     let files = baml_workspace::project_files(db, root);
     compile_files(db, &files)
 }
@@ -61,7 +61,7 @@ pub fn compile_files(db: &dyn baml_thir::Db, files: &[SourceFile]) -> Program {
         let items_struct = baml_hir::file_items(db, *file);
         for item in items_struct.items(db) {
             if let ItemId::Function(func_loc) = item {
-                let signature = function_signature(db, *file, *func_loc);
+                let signature = function_signature(db, *func_loc);
                 globals.insert(signature.name.to_string(), global_idx);
                 global_idx += 1;
             }
@@ -73,12 +73,17 @@ pub fn compile_files(db: &dyn baml_thir::Db, files: &[SourceFile]) -> Program {
         let items_struct = baml_hir::file_items(db, *file);
         for item in items_struct.items(db) {
             if let ItemId::Function(func_loc) = item {
-                let signature = function_signature(db, *file, *func_loc);
-                let body = function_body(db, *file, *func_loc);
+                let signature = function_signature(db, *func_loc);
+                let body = function_body(db, *func_loc);
 
                 // Run type inference
-                let inference =
-                    baml_thir::infer_function(db, &signature, &body, Some(typing_context.clone()));
+                let inference = baml_thir::infer_function(
+                    db,
+                    &signature,
+                    &body,
+                    Some(typing_context.clone()),
+                    None,
+                );
 
                 // Get parameter names
                 let params: Vec<Name> = signature.params.iter().map(|p| p.name.clone()).collect();
@@ -127,7 +132,7 @@ fn build_typing_context<'db>(
         let items_struct = baml_hir::file_items(db, *file);
         for item in items_struct.items(db) {
             if let ItemId::Function(func_loc) = item {
-                let signature = function_signature(db, *file, *func_loc);
+                let signature = function_signature(db, *func_loc);
 
                 // Build the arrow type: (param_types) -> return_type
                 let param_types: Vec<baml_thir::Ty<'db>> = signature

baml_language/crates/baml_codegen/src/lib.rs

@@ -4,10 +4,9 @@
 
 use std::collections::HashMap;
 
-use baml_db::{
-    RootDatabase, baml_hir, baml_thir, build_typing_context_from_files, function_body,
-    function_signature,
-};
+use baml_db::{RootDatabase, baml_hir, baml_thir};
+use baml_hir::{function_body, function_signature};
+use baml_thir::build_typing_context_from_files;
 use baml_vm::test::{Instruction, Value};
 
 /// Helper struct for testing bytecode compilation.
@@ -167,7 +166,7 @@ fn compile_source(source: &str) -> CompileResult {
     let mut global_idx = 0;
     for item in items {
         if let baml_hir::ItemId::Function(func_loc) = item {
-            let sig = function_signature(&db, file, *func_loc);
+            let sig = function_signature(&db, *func_loc);
             globals.insert(sig.name.to_string(), global_idx);
             global_idx += 1;
         }
@@ -180,12 +179,17 @@ fn compile_source(source: &str) -> CompileResult {
     let mut functions = Vec::new();
     for item in items {
         if let baml_hir::ItemId::Function(func_loc) = item {
-            let signature = function_signature(&db, file, *func_loc);
-            let body = function_body(&db, file, *func_loc);
+            let signature = function_signature(&db, *func_loc);
+            let body = function_body(&db, *func_loc);
 
             // Run type inference
-            let inference =
-                baml_thir::infer_function(&db, &signature, &body, Some(typing_context.clone()));
+            let inference = baml_thir::infer_function(
+                &db,
+                &signature,
+                &body,
+                Some(typing_context.clone()),
+                None,
+            );
 
             // Get parameter names
             let params: Vec<baml_base::Name> =

baml_language/crates/baml_codegen/src/tests/common.rs

@@ -1,7 +1,6 @@
 //! Root database that assembles all compiler phases.
 //!
 //! This crate purely combines all the compiler traits into a single database.
-//! All testing happens in the separate `baml_tests` crate.
 
 use std::{
     path::PathBuf,
@@ -75,9 +74,12 @@ impl RootDatabase {
         SourceFile::new(self, text.into(), path.into(), file_id)
     }
 
-    /// Create a project root
-    pub fn set_project_root(&mut self, path: impl Into<PathBuf>) -> baml_workspace::ProjectRoot {
-        baml_workspace::ProjectRoot::new(self, path.into())
+    /// Create a project root with an empty file list.
+    ///
+    /// After creating the project root, use `add_file()` to add source files,
+    /// then update the project root's file list with `root.set_files()`.
+    pub fn set_project_root(&mut self, path: impl Into<PathBuf>) -> baml_workspace::Project {
+        baml_workspace::Project::new(self, path.into(), vec![])
     }
 }
 
@@ -86,60 +88,3 @@ impl Default for RootDatabase {
         Self::new()
     }
 }
-
-//
-// ────────────────────────────────────────────────── FUNCTION QUERIES ─────
-//
-
-// Re-export function queries from baml_hir
-pub use baml_hir::{function_body, function_signature};
-
-//
-// ────────────────────────────────────────────────── TYPING CONTEXT ─────
-//
-
-/// Build typing context from a list of source files.
-///
-/// This maps function names to their arrow types, e.g.:
-/// `Foo` -> `(int) -> int` for `function Foo(x: int) -> int`
-///
-/// This is used as the starting scope when type-checking function bodies,
-/// allowing function calls to be properly typed.
-///
-/// Note: This is not a Salsa query because it returns `Ty<'db>` which contains
-/// lifetime-parameterized data. Callers should cache the result if needed.
-pub fn build_typing_context_from_files<'db>(
-    db: &'db dyn baml_thir::Db,
-    files: &[SourceFile],
-) -> std::collections::HashMap<baml_base::Name, baml_thir::Ty<'db>> {
-    let mut context = std::collections::HashMap::new();
-
-    for file in files {
-        let items_struct = baml_hir::file_items(db, *file);
-        let items = items_struct.items(db);
-
-        for item in items {
-            if let baml_hir::ItemId::Function(func_loc) = item {
-                let signature = function_signature(db, *file, *func_loc);
-
-                // Build the arrow type: (param_types) -> return_type
-                let param_types: Vec<baml_thir::Ty<'db>> = signature
-                    .params
-                    .iter()
-                    .map(|p| baml_thir::lower_type_ref(db, &p.type_ref))
-                    .collect();
-
-                let return_type = baml_thir::lower_type_ref(db, &signature.return_type);
-
-                let func_type = baml_thir::Ty::Function {
-                    params: param_types,
-                    ret: Box::new(return_type),
-                };
-
-                context.insert(signature.name.clone(), func_type);
-            }
-        }
-    }
-
-    context
-}

baml_language/crates/baml_db/src/lib.rs

@@ -760,22 +760,21 @@ impl LoweringContext {
     }
 
     fn lower_field_access_expr(&mut self, node: &baml_syntax::SyntaxNode) -> ExprId {
-        use baml_syntax::SyntaxKind;
+        use baml_syntax::ast::FieldAccessExpr;
+        use rowan::ast::AstNode;
 
         // FIELD_ACCESS_EXPR structure: base expression, DOT token, field name (WORD)
-        // The parser wraps the left side as a child expression node
-        let base = node
-            .children()
-            .next()
+        let Some(field_access) = FieldAccessExpr::cast(node.clone()) else {
+            return self.exprs.alloc(Expr::Missing);
+        };
+
+        let base = field_access
+            .base()
             .map(|n| self.lower_expr(&n))
             .unwrap_or_else(|| self.exprs.alloc(Expr::Missing));
 
-        // Find the field name (WORD token after DOT)
-        let field = node
-            .children_with_tokens()
-            .filter_map(baml_syntax::NodeOrToken::into_token)
-            .filter(|token| token.kind() == SyntaxKind::WORD)
-            .last() // Get the last WORD (the field name, not part of the base expression)
+        let field = field_access
+            .field()
             .map(|token| Name::new(token.text()))
             .unwrap_or_else(|| Name::new(""));
 
@@ -858,21 +857,44 @@ impl LoweringContext {
     }
 
     fn lower_path_expr(&mut self, node: &baml_syntax::SyntaxNode) -> ExprId {
-        use baml_syntax::SyntaxKind;
+        use baml_syntax::ast::PathExpr;
+        use rowan::ast::AstNode;
 
-        // PATH_EXPR can be a simple identifier or a qualified path
-        // Collect all WORD tokens and join them
-        let path_parts: Vec<String> = node
-            .children_with_tokens()
-            .filter_map(baml_syntax::NodeOrToken::into_token)
-            .filter(|token| token.kind() == SyntaxKind::WORD)
+        // PATH_EXPR can be:
+        // 1. A simple identifier: `foo`
+        // 2. A qualified path with `.`: `mod.foo`
+        // 3. A field access chain with `.`: `obj.field.nested`
+
+        let Some(path_expr) = PathExpr::cast(node.clone()) else {
+            return self.exprs.alloc(Expr::Missing);
+        };
+
+        let segments: Vec<String> = path_expr
+            .segments()
             .map(|token| token.text().to_string())
             .collect();
 
-        if path_parts.is_empty() {
-            self.exprs.alloc(Expr::Missing)
+        if segments.is_empty() {
+            return self.exprs.alloc(Expr::Missing);
+        }
+
+        if path_expr.has_dots() {
+            // Field access chain: build nested FieldAccess expressions
+            // Start with the first segment as a Path
+            let mut current = self.exprs.alloc(Expr::Path(Name::new(&segments[0])));
+
+            // Chain the rest as FieldAccess
+            for segment in &segments[1..] {
+                current = self.exprs.alloc(Expr::FieldAccess {
+                    base: current,
+                    field: Name::new(segment),
+                });
+            }
+
+            current
         } else {
-            let path_text = path_parts.join("::");
+            // Module path with :: or simple identifier
+            let path_text = segments.join(".");
             self.exprs.alloc(Expr::Path(Name::new(&path_text)))
         }
     }

baml_language/crates/baml_hir/src/body.rs

@@ -111,6 +111,11 @@ impl ItemTree {
         self.tests.insert(id, test);
         id
     }
+
+    /// Iterate over all classes in the item tree.
+    pub fn iter_classes(&self) -> impl Iterator<Item = (&LocalItemId<ClassMarker>, &Class)> {
+        self.classes.iter()
+    }
 }
 
 /// A function definition in the `ItemTree`.