baml-language: implement new PPIR

baml-language: ppir fixes

Author: sxlijin

baml_language/crates/baml_compiler2_ppir/src/expand.rs

@@ -256,7 +256,9 @@ pub fn infer_scope_types<'db>(
                                     &mut diags,
                                 )
                             })
-                            .unwrap_or(Ty::Unknown { attr: TyAttr::default() });
+                            .unwrap_or(Ty::Unknown {
+                                attr: TyAttr::default(),
+                            });
 
                         // Report unresolved type diagnostics for return type
                         if !diags.is_empty() {
@@ -300,12 +302,15 @@ pub fn infer_scope_types<'db>(
                                         let mut ns_path = pkg_info.namespace_path.clone();
                                         ns_path.push(cn.clone());
                                         pkg_items.lookup_type(&ns_path).map(|def| {
-                                            Ty::Class(crate::lower_type_expr::qualify_def(
-                                                db, def, cn,
-                                            ), TyAttr::default())
+                                            Ty::Class(
+                                                crate::lower_type_expr::qualify_def(db, def, cn),
+                                                TyAttr::default(),
+                                            )
                                         })
                                     })
-                                    .unwrap_or(Ty::Unknown { attr: TyAttr::default() })
+                                    .unwrap_or(Ty::Unknown {
+                                        attr: TyAttr::default(),
+                                    })
                             } else {
                                 let mut param_diags = Vec::new();
                                 let ty = crate::lower_type_expr::lower_type_expr_in_ns(
@@ -461,7 +466,14 @@ fn collect_class_fields<'db>(
                 let resolved = resolve_class_fields(db, *loc);
                 let qualified =
                     crate::lower_type_expr::qualify_def(db, Definition::Class(*loc), name);
-                classes.insert(qualified, resolved.fields.clone());
+                classes.insert(
+                    qualified,
+                    resolved
+                        .fields
+                        .iter()
+                        .map(|(n, t, _)| (n.clone(), t.clone()))
+                        .collect(),
+                );
             }
         }
     }
@@ -473,7 +485,8 @@ fn collect_class_fields<'db>(
 /// Resolved class fields — `TypeExpr` resolved to `Ty` for each field.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct ResolvedClassFields {
-    pub fields: Vec<(Name, Ty)>,
+    /// (field name, resolved type, SAP attribute names)
+    pub fields: Vec<(Name, Ty, Vec<Name>)>,
     /// Type lowering diagnostics: (error, span of the type annotation).
     pub diagnostics: Vec<(crate::infer_context::TirTypeError, text_size::TextRange)>,
 }
@@ -562,8 +575,15 @@ pub fn resolve_class_fields<'db>(
                     }
                     ty
                 })
-                .unwrap_or(Ty::Unknown { attr: TyAttr::default() });
-            (f.name.clone(), ty)
+                .unwrap_or(Ty::Unknown {
+                    attr: TyAttr::default(),
+                });
+            let sap_attrs: Vec<Name> = f
+                .type_expr
+                .as_ref()
+                .map(|te| te.expr.attrs().iter().map(|a| a.name.clone()).collect())
+                .unwrap_or_default();
+            (f.name.clone(), ty, sap_attrs)
         })
         .collect();
 
@@ -607,7 +627,9 @@ pub fn resolve_type_alias<'db>(
             }
             ty
         })
-        .unwrap_or(Ty::Unknown { attr: TyAttr::default() });
+        .unwrap_or(Ty::Unknown {
+            attr: TyAttr::default(),
+        });
 
     Arc::new(ResolvedTypeAlias {
         ty,

baml_language/crates/baml_compiler2_ppir/src/lib.rs

@@ -475,7 +475,7 @@ fn completions_for_ty_members(db: &dyn Db, ty: &Ty) -> Vec<Completion> {
 
             // Fields from resolved class fields.
             let resolved = baml_compiler2_tir::inference::resolve_class_fields(db, class_loc);
-            for (field_name, field_ty) in &resolved.fields {
+            for (field_name, field_ty, _sap_attrs) in &resolved.fields {
                 items.push(
                     Completion::new(field_name.as_str(), CompletionKind::Field)
                         .with_detail(utils::display_ty(field_ty))

baml_language/crates/baml_compiler2_ppir/src/ty.rs

@@ -221,7 +221,7 @@ fn type_info_for_definition(db: &dyn Db, def: Definition<'_>) -> TypeInfo {
             let fields = resolved
                 .fields
                 .iter()
-                .map(|(field_name, ty)| (field_name.as_str().to_string(), utils::display_ty(ty)))
+                .map(|(field_name, ty, _)| (field_name.as_str().to_string(), utils::display_ty(ty)))
                 .collect();
 
             TypeInfo::Class {

baml_language/crates/baml_compiler2_tir/src/inference.rs

@@ -0,0 +1,15 @@
+class Config {
+  id int @stream.must_exist
+  name string @stream.done
+  data AttrFoo @stream.must_exist @stream.done
+}
+
+class AttrFoo {
+  x int
+}
+
+class WithBlockAttrs {
+  a int
+  b string
+  @@stream.done
+}

baml_language/crates/baml_lsp2_actions/src/completions.rs

@@ -0,0 +1,14 @@
+class Foo {
+  a int
+  b string
+  c float
+  d bool
+}
+
+class Bar {
+  ref Foo
+  items int[]
+  nested Foo[]
+  mapping map<string, int>
+  opt int?
+}

baml_language/crates/baml_lsp2_actions/src/type_info.rs

@@ -0,0 +1,24 @@
+enum Color {
+  Red
+  Green
+  Blue
+}
+
+class Inner {
+  value int
+}
+
+type StringAlias = string
+
+class Complex {
+  color Color
+  literal 5
+  str_literal "hello"
+  union_field int | string[]
+  alias_field StringAlias
+  nested_list Inner[][]
+  optional_class Inner?
+  union_with_null int | null | string
+}
+
+type AliasToClass = Inner

baml_language/crates/baml_tests/projects/stream_types/attrs.baml

@@ -0,0 +1,45 @@
+class SelfRef {
+  name string
+  children SelfRef[]
+}
+
+class AllMustExist {
+  a int @stream.must_exist
+  b string @stream.must_exist
+  c float @stream.must_exist
+}
+
+class AllDone {
+  a int @stream.done
+  b string @stream.done
+  c EdgeFoo @stream.done
+}
+
+class EdgeFoo {
+  x int
+}
+
+class NeverFields {
+  lit_int 42
+  lit_str "fixed"
+  lit_bool true
+}
+
+// GAP 5: @@stream.must_exist on a class makes pending_default return Never.
+// In a union where all variants are pending=Never, the union itself gets
+// @sap.pending_never instead of prepending null.
+//
+// Without the fix: pending_default(MustExistClass) = Null, so the union
+// gets PrependNull → `null | MustExistClass$stream | 5 @sap.parse_without_null`.
+// With the fix: pending_default(MustExistClass) = Never (due to @@stream.must_exist),
+// literal 5 is also Never, so union gets InherentlyNever → `@sap.pending_never`.
+class MustExistClass {
+  v int
+  @@stream.must_exist
+}
+
+class UnionWithMustExist {
+  // Both variants are pending=Never: MustExistClass via @@stream.must_exist,
+  // literal 5 inherently. Union should get @sap.pending_never, not null prepended.
+  mixed MustExistClass | 5
+}