Fix Op::Constant with boolean result type emitting wrong sort

Some SPIR-V compilers emit OpConstant (instead of OpConstantTrue/
OpConstantFalse) for boolean values. The parser only checked for
float vs integer, so bool constants fell through to the integer
branch and produced (Const N) instead of (BoolConst N). This caused
egglog sort mismatches when the value was later used in boolean
operations expecting BoolExpr.

Check TypeClass::Bool before the float/integer branches so boolean
OpConstant values emit (BoolConst 0/1) in the correct BoolExpr sort.

Author: LegNeato

rust/spirv-tools-opt/src/direct/context.rs

@@ -170,9 +170,17 @@ impl EgglogContext {
             Op::Constant => {
                 let result_type = inst.result_type?;
                 let width = self.type_widths.get(&result_type).copied().unwrap_or(32);
-                let is_float = self.type_class_of_type(result_type) == TypeClass::Float;
+                let type_class = self.type_class_of_type(result_type);
 
-                if is_float {
+                if type_class == TypeClass::Bool {
+                    // Boolean constant via OpConstant (some compilers use this
+                    // instead of OpConstantTrue/OpConstantFalse)
+                    let value = inst.operands.iter().find_map(|op| match op {
+                        Operand::LiteralBit32(v) => Some(*v),
+                        _ => None,
+                    })?;
+                    format!("(BoolConst {})", if value != 0 { 1 } else { 0 })
+                } else if type_class == TypeClass::Float {
                     // Float constant: reinterpret bits as IEEE float for FConst
                     let float_val: f64 = inst.operands.iter().find_map(|op| match op {
                         Operand::LiteralBit32(v) => Some(f32::from_bits(*v) as f64),