Implement SameOperandsAndResultType test.

Signed-off-by: Tomas Fabrizio Orsi <[email protected]>

Signed-off-by: Tomas Fabrizio Orsi <[email protected]>

Author: lima-limon-inc

hir/src/derive.rs

@@ -211,4 +211,28 @@ mod tests {
         let op = op_builder(lhs, invalid_rhs, Overflow::Wrapping);
         let _op = op.unwrap();
     }
+
+    /// Fails if [`InvalidOpsWithReturn`] is created successfully. [`InvalidOpsWithReturn`] is a
+    /// struct that has differing types in its result and arguments, despite implementing the
+    /// [`SameOperandsAndResultType`] trait.
+    #[test]
+    #[should_panic = "expected 'i32', got 'u64'"]
+    fn same_operands_and_result_type_verifier_test() {
+        use crate::{SourceSpan, Type};
+
+        let context = Rc::new(Context::default());
+        let block = context.create_block_with_params([Type::I32, Type::I32]);
+        let (lhs, rhs) = {
+            let block = block.borrow();
+            let lhs = block.get_argument(0).upcast::<dyn crate::Value>();
+            let rhs = block.get_argument(1).upcast::<dyn crate::Value>();
+            (lhs, rhs)
+        };
+        let mut builder = context.builder();
+        builder.set_insertion_point_to_end(block);
+        // Try to create instance of AddOp with mismatched operand types
+        let op_builder = builder.create::<InvalidOpsWithReturn, _>(SourceSpan::default());
+        let op = op_builder(lhs, rhs);
+        let _op = op.unwrap();
+    }
 }

hir/src/dialects/test/ops/binary.rs

@@ -75,10 +75,11 @@ impl InferTypeOpInterface for Shl {
     }
 }
 
-/// Invalid operation that breaks the SameOperandsAndResultType trait
+/// Invalid operation that breaks the SameOperandsAndResultType trait (used for testing).
 #[operation(
     dialect = TestDialect,
     traits(BinaryOp, SameTypeOperands, SameOperandsAndResultType),
+    implements(InferTypeOpInterface)
 )]
 pub struct InvalidOpsWithReturn {
     #[operand]
@@ -87,6 +88,11 @@ pub struct InvalidOpsWithReturn {
     rhs: AnyInteger,
     #[result]
     result: AnyUnsignedInteger,
-    #[attr]
-    overflow: Overflow,
+}
+
+impl InferTypeOpInterface for InvalidOpsWithReturn {
+    fn infer_return_types(&mut self, context: &Context) -> Result<(), Report> {
+        self.result_mut().set_type(Type::U64);
+        Ok(())
+    }
 }

hir/src/ir/traits/types.rs

@@ -86,7 +86,7 @@ derive! {
                     (value.ty().clone(), value.span())
                 };
 
-                let mut results = op.results().iter();
+                let results = op.results().iter();
 
                 for operand in operands {
                     let operand = operand.borrow();