Add BlockApi trait.

macro/tests/operand.rs

@@ -1,6 +1,6 @@
 mod utility;
 
-use melior::ir::{Block, Location, Type};
+use melior::ir::{block::BlockLike, Block, Location, Type};
 use utility::*;
 
 melior_macro::dialect! {

melior/src/dialect/arith.rs

@@ -174,6 +174,7 @@ mod tests {
         dialect::func,
         ir::{
             attribute::{StringAttribute, TypeAttribute},
+            block::BlockLike,
             r#type::FunctionType,
             Attribute, Block, Location, Module, Region, Type,
         },

melior/src/dialect/cf.rs

@@ -5,6 +5,7 @@ use crate::{
         attribute::{
             DenseElementsAttribute, DenseI32ArrayAttribute, IntegerAttribute, StringAttribute,
         },
+        block::BlockLike,
         operation::OperationBuilder,
         r#type::RankedTensorType,
         Block, Identifier, Location, Operation, Type, Value,

melior/src/dialect/func.rs

@@ -87,7 +87,7 @@ pub fn r#return<'c>(operands: &[Value<'c, '_>], location: Location<'c>) -> Opera
 mod tests {
     use super::*;
     use crate::{
-        ir::{Block, Module, Type},
+        ir::{block::BlockLike, Block, Module, Type},
         test::create_test_context,
     };
 

melior/src/dialect/index.rs

@@ -75,6 +75,7 @@ mod tests {
         dialect::func,
         ir::{
             attribute::{StringAttribute, TypeAttribute},
+            block::BlockLike,
             r#type::{FunctionType, IntegerType},
             Block, Location, Module, Region, Type,
         },

melior/src/dialect/llvm.rs

@@ -381,6 +381,7 @@ mod tests {
         },
         ir::{
             attribute::{IntegerAttribute, StringAttribute, TypeAttribute},
+            block::BlockLike,
             r#type::{FunctionType, IntegerType},
             Block, Module, Region,
         },

melior/src/dialect/memref.rs

@@ -324,6 +324,7 @@ mod tests {
         dialect::{func, index},
         ir::{
             attribute::{DenseElementsAttribute, StringAttribute, TypeAttribute},
+            block::BlockLike,
             r#type::{FunctionType, IntegerType, RankedTensorType},
             Block, Module, Region, Type,
         },

melior/src/dialect/ods.rs

@@ -140,6 +140,7 @@ mod tests {
         dialect,
         ir::{
             attribute::{IntegerAttribute, StringAttribute, TypeAttribute},
+            block::BlockLike,
             r#type::{FunctionType, IntegerType},
             Block, Location, Module, Region, Type,
         },

melior/src/dialect/scf.rs

@@ -114,6 +114,7 @@ mod tests {
         dialect::{arith, func},
         ir::{
             attribute::{FloatAttribute, IntegerAttribute, StringAttribute, TypeAttribute},
+            block::BlockLike,
             r#type::{FunctionType, IntegerType, Type},
             Attribute, Block, Module,
         },

melior/src/helpers/builtin.rs

@@ -1,5 +1,5 @@
 use crate::{
-    ir::{Block, Operation, Value},
+    ir::{block::BlockLike, Block, Operation, Value},
     Error,
 };
 

melior/src/helpers/llvm.rs

@@ -6,6 +6,7 @@ use crate::{
         attribute::{
             DenseI32ArrayAttribute, DenseI64ArrayAttribute, IntegerAttribute, TypeAttribute,
         },
+        block::BlockLike,
         r#type::IntegerType,
         Attribute, Block, Location, Type, Value, ValueLike,
     },

melior/src/ir.rs

@@ -14,7 +14,7 @@ mod value;
 pub use self::{
     affine_map::AffineMap,
     attribute::{Attribute, AttributeLike},
-    block::{Block, BlockRef},
+    block::{Block, BlockLike, BlockRef},
     identifier::Identifier,
     location::Location,
     module::Module,

melior/src/ir/block.rs

@@ -1,19 +1,14 @@
 //! Blocks.
 
 mod argument;
+mod block_like;
 
 pub use self::argument::BlockArgument;
-use super::{
-    operation::OperationRefMut, Location, Operation, OperationRef, RegionRef, Type, TypeLike, Value,
-};
-use crate::{context::Context, utility::print_callback, Error};
+pub use self::block_like::BlockLike;
+use super::{Location, Type, TypeLike, Value};
+use crate::{context::Context, utility::print_callback};
 use mlir_sys::{
-    mlirBlockAddArgument, mlirBlockAppendOwnedOperation, mlirBlockCreate, mlirBlockDestroy,
-    mlirBlockDetach, mlirBlockEqual, mlirBlockGetArgument, mlirBlockGetFirstOperation,
-    mlirBlockGetNextInRegion, mlirBlockGetNumArguments, mlirBlockGetParentOperation,
-    mlirBlockGetParentRegion, mlirBlockGetTerminator, mlirBlockInsertOwnedOperation,
-    mlirBlockInsertOwnedOperationAfter, mlirBlockInsertOwnedOperationBefore, mlirBlockPrint,
-    MlirBlock,
+    mlirBlockCreate, mlirBlockDestroy, mlirBlockDetach, mlirBlockEqual, mlirBlockPrint, MlirBlock,
 };
 use std::{
     ffi::c_void,
@@ -50,130 +45,6 @@ impl<'c> Block<'c> {
         }
     }
 
-    /// Returns an argument at a position.
-    pub fn argument(&self, index: usize) -> Result<BlockArgument<'c, '_>, Error> {
-        unsafe {
-            if index < self.argument_count() {
-                Ok(BlockArgument::from_raw(mlirBlockGetArgument(
-                    self.raw,
-                    index as isize,
-                )))
-            } else {
-                Err(Error::PositionOutOfBounds {
-                    name: "block argument",
-                    value: self.to_string(),
-                    index,
-                })
-            }
-        }
-    }
-
-    /// Returns a number of arguments.
-    pub fn argument_count(&self) -> usize {
-        unsafe { mlirBlockGetNumArguments(self.raw) as usize }
-    }
-
-    /// Returns a reference to the first operation.
-    pub fn first_operation(&self) -> Option<OperationRef<'c, '_>> {
-        unsafe { OperationRef::from_option_raw(mlirBlockGetFirstOperation(self.raw)) }
-    }
-
-    /// Returns a mutable reference to the first operation.
-    pub fn first_operation_mut(&mut self) -> Option<OperationRefMut<'c, '_>> {
-        unsafe { OperationRefMut::from_option_raw(mlirBlockGetFirstOperation(self.raw)) }
-    }
-
-    /// Returns a reference to a terminator operation.
-    pub fn terminator(&self) -> Option<OperationRef<'c, '_>> {
-        unsafe { OperationRef::from_option_raw(mlirBlockGetTerminator(self.raw)) }
-    }
-
-    /// Returns a mutable reference to a terminator operation.
-    pub fn terminator_mut(&mut self) -> Option<OperationRefMut<'c, '_>> {
-        unsafe { OperationRefMut::from_option_raw(mlirBlockGetTerminator(self.raw)) }
-    }
-
-    /// Returns a parent region.
-    // TODO Store lifetime of regions in blocks, or create another type like
-    // `InsertedBlockRef`?
-    pub fn parent_region(&self) -> Option<RegionRef<'c, '_>> {
-        unsafe { RegionRef::from_option_raw(mlirBlockGetParentRegion(self.raw)) }
-    }
-
-    /// Returns a parent operation.
-    pub fn parent_operation(&self) -> Option<OperationRef<'c, '_>> {
-        unsafe { OperationRef::from_option_raw(mlirBlockGetParentOperation(self.raw)) }
-    }
-
-    /// Adds an argument.
-    pub fn add_argument(&self, r#type: Type<'c>, location: Location<'c>) -> Value<'c, '_> {
-        unsafe {
-            Value::from_raw(mlirBlockAddArgument(
-                self.raw,
-                r#type.to_raw(),
-                location.to_raw(),
-            ))
-        }
-    }
-
-    /// Appends an operation.
-    pub fn append_operation(&self, operation: Operation<'c>) -> OperationRef<'c, '_> {
-        unsafe {
-            let operation = operation.into_raw();
-
-            mlirBlockAppendOwnedOperation(self.raw, operation);
-
-            OperationRef::from_raw(operation)
-        }
-    }
-
-    /// Inserts an operation.
-    // TODO How can we make those update functions take `&mut self`?
-    // TODO Use cells?
-    pub fn insert_operation(
-        &self,
-        position: usize,
-        operation: Operation<'c>,
-    ) -> OperationRef<'c, '_> {
-        unsafe {
-            let operation = operation.into_raw();
-
-            mlirBlockInsertOwnedOperation(self.raw, position as isize, operation);
-
-            OperationRef::from_raw(operation)
-        }
-    }
-
-    /// Inserts an operation after another.
-    pub fn insert_operation_after(
-        &self,
-        one: OperationRef<'c, '_>,
-        other: Operation<'c>,
-    ) -> OperationRef<'c, '_> {
-        unsafe {
-            let other = other.into_raw();
-
-            mlirBlockInsertOwnedOperationAfter(self.raw, one.to_raw(), other);
-
-            OperationRef::from_raw(other)
-        }
-    }
-
-    /// Inserts an operation before another.
-    pub fn insert_operation_before(
-        &self,
-        one: OperationRef<'c, '_>,
-        other: Operation<'c>,
-    ) -> OperationRef<'c, '_> {
-        unsafe {
-            let other = other.into_raw();
-
-            mlirBlockInsertOwnedOperationBefore(self.raw, one.to_raw(), other);
-
-            OperationRef::from_raw(other)
-        }
-    }
-
     /// Detaches a block from a region and assumes its ownership.
     ///
     /// # Safety
@@ -191,11 +62,6 @@ impl<'c> Block<'c> {
         }
     }
 
-    /// Returns a next block in a region.
-    pub fn next_in_region(&self) -> Option<BlockRef<'c, '_>> {
-        unsafe { BlockRef::from_option_raw(mlirBlockGetNextInRegion(self.raw)) }
-    }
-
     /// Creates a block from a raw object.
     ///
     /// # Safety
@@ -223,6 +89,12 @@ impl<'c> Block<'c> {
     }
 }
 
+impl<'c, 'a> BlockLike<'c, 'a> for &'a Block<'c> {
+    fn to_raw(self) -> MlirBlock {
+        self.raw
+    }
+}
+
 impl Drop for Block<'_> {
     fn drop(&mut self) {
         unsafe { mlirBlockDestroy(self.raw) };
@@ -295,8 +167,14 @@ impl BlockRef<'_, '_> {
     }
 }
 
-impl<'a> Deref for BlockRef<'_, 'a> {
-    type Target = Block<'a>;
+impl<'c, 'a> BlockLike<'c, 'a> for BlockRef<'c, 'a> {
+    fn to_raw(self) -> MlirBlock {
+        self.raw
+    }
+}
+
+impl<'c> Deref for BlockRef<'c, '_> {
+    type Target = Block<'c>;
 
     fn deref(&self) -> &Self::Target {
         unsafe { transmute(self) }
@@ -329,6 +207,7 @@ mod tests {
     use crate::{
         ir::{operation::OperationBuilder, r#type::IntegerType, Module, Region, ValueLike},
         test::create_test_context,
+        Error,
     };
     use pretty_assertions::assert_eq;
 

melior/src/ir/block/argument.rs

@@ -71,7 +71,7 @@ mod tests {
     use super::*;
     use crate::{
         context::Context,
-        ir::{Block, Location},
+        ir::{block::BlockLike, Block, Location},
     };
 
     #[test]