Same-type bitcast elimination via SameTypeBitcast relation

When OpBitcast's input and output types are identical, the operation is
redundant (identity). Detect this during parsing by comparing type IDs
and seed a SameTypeBitcast(Expr) relation via additional_facts. A rule
in type_conversion.egg then eliminates: Bitcast(x) where SameTypeBitcast
→ x.

This matches the C++ RedundantBitcast optimization. The existing
Bitcast(Bitcast(x)) → Bitcast(x) chain collapse rule is preserved.

Author: LegNeato

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

@@ -96,6 +96,23 @@ impl EgglogContext {
                         }
                     }
                 }
+
+                // Detect same-type bitcast for redundant bitcast elimination
+                if inst.class.opcode == Op::Bitcast {
+                    if let Some(result_type) = inst.result_type {
+                        let src_id = inst.operands.iter().find_map(|op| op.id_ref_any());
+                        if let Some(src_id) = src_id {
+                            if let Some(src_type) = self.id_to_type.get(&src_id) {
+                                if *src_type == result_type {
+                                    self.additional_facts.push(format!(
+                                        "(SameTypeBitcast id{})",
+                                        result_id
+                                    ));
+                                }
+                            }
+                        }
+                    }
+                }
             }
         }
     }

rust/spirv-tools-opt/src/rules/datatypes.egg

@@ -376,9 +376,12 @@
 (function VecSize (Expr) i64 :merge (min old new))
 
 ; ResultWidth — tracks the bit width of an integer expression's result type
-; Used for SConvert/UConvert constant folding
+; Used for SConvert/UConvert constant folding and bitcast constant folding
 (function ResultWidth (IntExpr) i64 :merge (min old new))
 
+; SameTypeBitcast — seeded by parser when OpBitcast input/output types are identical
+(relation SameTypeBitcast (Expr))
+
 ; Vector arithmetic (component-wise)
 (constructor VecAdd (Expr Expr) Expr)
 (constructor VecSub (Expr Expr) Expr)

rust/spirv-tools-opt/src/rules/type_conversion.egg

@@ -54,6 +54,10 @@
 ; Bitcast Rules
 ; =============================================================================
 
+; Same-type bitcast is identity (seeded from parser type checking) - ONE-DIRECTIONAL
+(rule ((= e (Bitcast x)) (SameTypeBitcast e))
+      ((union e x)))
+
 ; Bitcast of bitcast is bitcast (two reinterpretations)
 ; Note: In general bitcast(bitcast(x)) may equal x if types align, but
 ; without type info we can only say it's still a bitcast - ONE-DIRECTIONAL