Unify instanceof with TypeTag — JumpTable dispatch, fused IsType, InstanceOfRemoved diagnostic

baml_language/crates/baml_compiler2_ast/src/ast.rs

@@ -634,7 +634,6 @@ pub enum BinaryOp {
     BitXor,
     Shl,
     Shr,
-    Instanceof,
     /// Null coalescing: `a ?? b` — returns `a` if non-null, else `b`.
     NullCoalesce,
 }
@@ -660,7 +659,6 @@ impl std::fmt::Display for BinaryOp {
             BinaryOp::BitXor => "^",
             BinaryOp::Shl => "<<",
             BinaryOp::Shr => ">>",
-            BinaryOp::Instanceof => "instanceof",
             BinaryOp::NullCoalesce => "??",
         };
         write!(f, "{s}")

baml_language/crates/baml_compiler2_ast/src/lower_expr_body.rs

@@ -610,7 +610,11 @@ impl LoweringContext {
                         SyntaxKind::CARET => op = Some(BinaryOp::BitXor),
                         SyntaxKind::LESS_LESS => op = Some(BinaryOp::Shl),
                         SyntaxKind::GREATER_GREATER => op = Some(BinaryOp::Shr),
-                        SyntaxKind::KW_INSTANCEOF => op = Some(BinaryOp::Instanceof),
+                        SyntaxKind::KW_INSTANCEOF => {
+                            self.diags
+                                .push(LoweringDiagnostic::InstanceofRemoved { span });
+                            return self.alloc_expr(Expr::Missing, node.text_range());
+                        }
                         SyntaxKind::QUESTION_QUESTION => op = Some(BinaryOp::NullCoalesce),
                         SyntaxKind::QUESTION if op.is_none() => {
                             // Two consecutive QUESTION tokens = null coalescing (??)

baml_language/crates/baml_compiler2_ast/src/lowering_diagnostic.rs

@@ -80,6 +80,9 @@ pub enum LoweringDiagnostic {
 
     /// A byte string literal contains an invalid escape sequence.
     InvalidByteStringEscape { message: String, span: TextRange },
+
+    /// The `instanceof` operator was used; it has been removed. Use `match` instead.
+    InstanceofRemoved { span: TextRange },
 }
 
 impl LoweringDiagnostic {
@@ -183,6 +186,12 @@ impl LoweringDiagnostic {
                 *span,
                 "invalid escape",
             ),
+            LoweringDiagnostic::InstanceofRemoved { span } => (
+                DiagnosticId::InstanceofRemoved,
+                "`instanceof` is no longer supported. Use a `match` expression for type checking instead.".to_string(),
+                *span,
+                "use `match` instead",
+            ),
         };
 
         Diagnostic::error(id, message)

baml_language/crates/baml_compiler2_emit/src/emit.rs

@@ -1349,6 +1349,12 @@ impl<'ctx, 'obj> StackifyCodegen<'ctx, 'obj> {
         exhaustive: bool,
         name_map: &std::collections::HashMap<i64, &str>,
     ) {
+        // Single exhaustive arm: no comparison needed, skip the discriminant entirely.
+        if exhaustive && arms.len() == 1 {
+            self.emit_jump_unless_fallthrough(arms[0].1);
+            return;
+        }
+
         self.emit_operand_pull(discriminant);
 
         let num_arms = arms.len();
@@ -1840,15 +1846,11 @@ impl PullSink for StackifyCodegen<'_, '_> {
     }
 
     fn is_type(&mut self, ty: &Ty) -> Result<(), Self::Error> {
-        // Emit instanceof check for nominal class checks.
         if let Ty::Class(tn, _) | Ty::TypeAlias(tn, _) = ty {
             let class_name_str = tn.display_name.as_str();
             if let Some(&class_obj_idx) = self.class_object_indices.get(class_name_str) {
-                let class_const =
-                    self.add_constant(ConstValue::Object(ObjectIndex::from_raw(class_obj_idx)));
-                let inst = self.emit(Instruction::LoadConst(class_const));
-                self.set_operand(inst, OperandMeta::Const(class_name_str.to_string()));
-                self.emit(Instruction::CmpOp(CmpOp::InstanceOf));
+                let c = self.add_constant(ConstValue::Object(ObjectIndex::from_raw(class_obj_idx)));
+                self.emit(Instruction::IsType(c));
             } else {
                 self.emit(Instruction::Pop(1));
                 let idx = self.add_constant(ConstValue::Bool(false));
@@ -1858,7 +1860,6 @@ impl PullSink for StackifyCodegen<'_, '_> {
             return Ok(());
         }
 
-        // Primitive and builtin runtime kinds use type tags.
         let type_tag = match ty {
             Ty::Int { .. } => Some(baml_type::typetag::INT),
             Ty::String { .. } => Some(baml_type::typetag::STRING),
@@ -1880,11 +1881,8 @@ impl PullSink for StackifyCodegen<'_, '_> {
         };
 
         if let Some(tag) = type_tag {
-            self.emit(Instruction::TypeTag);
-            let idx = self.add_constant(ConstValue::Int(tag));
-            let inst = self.emit(Instruction::LoadConst(idx));
-            self.set_operand(inst, OperandMeta::Const(tag.to_string()));
-            self.emit(Instruction::CmpOp(CmpOp::Eq));
+            let c = self.add_constant(ConstValue::Int(tag));
+            self.emit(Instruction::IsType(c));
         } else {
             self.emit(Instruction::Pop(1));
             let idx = self.add_constant(ConstValue::Bool(false));

baml_language/crates/baml_compiler2_mir/src/ir.rs

@@ -525,7 +525,7 @@ pub enum Rvalue {
 
     /// Extract runtime type tag from any value: `type_tag(_1)`
     ///
-    /// Used for jump table dispatch on union types (instanceof patterns).
+    /// Used for jump table dispatch on union types (type patterns in match).
     /// Type tags are global constants:
     /// - Primitives: `int=0`, `string=1`, `bool=2`, `null=3`, `float=4`
     /// - Classes: assigned unique IDs starting at 100