Refactor operand macros (#427)

- **Rename**
- **Fix**

Author: raviqqe

macro/src/dialect/generation/attribute_accessor.rs

@@ -1,6 +1,6 @@
 use crate::dialect::{
     error::Error,
-    operation::{Attribute, OperationFieldLike},
+    operation::{Attribute, OperationField},
     utility::sanitize_snake_case_identifier,
 };
 use proc_macro2::TokenStream;

macro/src/dialect/generation/element_accessor.rs

@@ -1,10 +1,10 @@
-use crate::dialect::operation::{OperationElement, OperationFieldLike, VariadicKind};
+use crate::dialect::operation::{OperationElement, OperationField, VariadicKind};
 use proc_macro2::{Span, TokenStream};
 use quote::quote;
 use syn::Ident;
 
 pub fn generate_element_getter(
-    field: &(impl OperationFieldLike + OperationElement),
+    field: &(impl OperationField + OperationElement),
     singular_kind: &str,
     plural_kind: &str,
     error_variant: &Ident,

macro/src/dialect/generation/operand_accessor.rs

@@ -1,15 +1,18 @@
 use super::element_accessor::generate_element_getter;
-use crate::dialect::{error::Error, operation::OperationField};
+use crate::dialect::{
+    error::Error,
+    operation::{Operand, OperationField},
+};
 use proc_macro2::{Ident, Span, TokenStream};
 use quote::quote;
 
 pub fn generate_operand_accessor(
-    field: &OperationField,
+    field: &Operand,
     index: usize,
     length: usize,
 ) -> Result<TokenStream, Error> {
-    let ident = &field.sanitized_name;
-    let return_type = &field.kind.return_type();
+    let ident = field.singular_identifier();
+    let return_type = field.return_type();
     let body = generate_element_getter(
         field,
         "operand",

macro/src/dialect/generation/region_accessor.rs

@@ -1,4 +1,4 @@
-use crate::dialect::operation::{OperationFieldLike, Region};
+use crate::dialect::operation::{OperationField, Region};
 use proc_macro2::TokenStream;
 use quote::quote;
 

macro/src/dialect/generation/result_accessor.rs

@@ -1,7 +1,7 @@
 use super::element_accessor::generate_element_getter;
 use crate::dialect::{
     error::Error,
-    operation::{OperationFieldLike, OperationResult},
+    operation::{OperationField, OperationResult},
 };
 use proc_macro2::{Ident, Span, TokenStream};
 use quote::quote;

macro/src/dialect/generation/successor_accessor.rs

@@ -1,4 +1,4 @@
-use crate::dialect::operation::{OperationFieldLike, Successor};
+use crate::dialect::operation::{OperationField, Successor};
 use proc_macro2::TokenStream;
 use quote::quote;
 

macro/src/dialect/operation.rs

@@ -1,26 +1,25 @@
 mod attribute;
 mod builder;
-mod field_kind;
+mod operand;
 mod operation_element;
 mod operation_field;
-mod operation_result;
 mod region;
-mod sequence_info;
+mod result;
 mod successor;
 mod variadic_kind;
 
 pub use self::{
-    attribute::Attribute, builder::OperationBuilder, operation_element::OperationElement,
-    operation_field::OperationField, operation_result::OperationResult, region::Region,
-    sequence_info::SequenceInfo, successor::Successor, variadic_kind::VariadicKind,
+    attribute::Attribute, builder::OperationBuilder, operand::Operand,
+    operation_element::OperationElement, region::Region, result::OperationResult,
+    successor::Successor, variadic_kind::VariadicKind,
 };
 use super::utility::sanitize_documentation;
 use crate::dialect::{
     error::{Error, OdsError},
     r#trait::Trait,
     types::{RegionConstraint, SuccessorConstraint, TypeConstraint},
 };
-pub use operation_field::OperationFieldLike;
+pub use operation_field::OperationField;
 use tblgen::{error::WithLocation, record::Record, TypedInit};
 
 #[derive(Debug)]
@@ -30,7 +29,7 @@ pub struct Operation<'a> {
     regions: Vec<Region<'a>>,
     successors: Vec<Successor<'a>>,
     results: Vec<OperationResult<'a>>,
-    operands: Vec<OperationField<'a>>,
+    operands: Vec<Operand<'a>>,
     attributes: Vec<Attribute<'a>>,
     derived_attributes: Vec<Attribute<'a>>,
 }
@@ -130,10 +129,11 @@ impl<'a> Operation<'a> {
         sanitize_documentation(self.definition.str_value("description")?)
     }
 
-    pub fn fields(&self) -> impl Iterator<Item = &dyn OperationFieldLike> {
-        fn convert(field: &impl OperationFieldLike) -> &dyn OperationFieldLike {
+    pub fn fields(&self) -> impl Iterator<Item = &dyn OperationField> {
+        fn convert(field: &impl OperationField) -> &dyn OperationField {
             field
         }
+
         self.results
             .iter()
             .map(convert)
@@ -143,7 +143,7 @@ impl<'a> Operation<'a> {
             .chain(self.attributes().map(convert))
     }
 
-    pub fn operands(&self) -> impl Iterator<Item = &OperationField<'a>> + Clone {
+    pub fn operands(&self) -> impl Iterator<Item = &Operand<'a>> + Clone {
         self.operands.iter()
     }
 
@@ -171,7 +171,7 @@ impl<'a> Operation<'a> {
         self.attributes.iter().chain(&self.derived_attributes)
     }
 
-    pub fn required_fields(&self) -> impl Iterator<Item = &dyn OperationFieldLike> {
+    pub fn required_fields(&self) -> impl Iterator<Item = &dyn OperationField> {
         self.fields()
             .filter(|field| (!field.is_result() || !self.can_infer_type) && !field.is_optional())
     }
@@ -264,9 +264,7 @@ impl<'a> Operation<'a> {
                 .into_iter()
                 .map(|(name, constraint)| (name, TypeConstraint::new(constraint)))
                 .collect::<Vec<_>>(),
-            |name, constraint, _sequence_info, variadic_kind| {
-                OperationResult::new(name, constraint, variadic_kind)
-            },
+            OperationResult::new,
             same_size,
             attribute_sized,
         )
@@ -276,16 +274,14 @@ impl<'a> Operation<'a> {
         arguments: &[(&'a str, Record<'a>)],
         same_size: bool,
         attribute_sized: bool,
-    ) -> Result<Vec<OperationField<'a>>, Error> {
+    ) -> Result<Vec<Operand<'a>>, Error> {
         Ok(Self::collect_elements(
             &arguments
                 .iter()
                 .filter(|(_, definition)| definition.subclass_of("TypeConstraint"))
                 .map(|(name, definition)| (*name, TypeConstraint::new(*definition)))
                 .collect::<Vec<_>>(),
-            |name, constraint, sequence_info, variadic_kind| {
-                OperationField::new(name, constraint, sequence_info, variadic_kind)
-            },
+            Operand::new,
             same_size,
             attribute_sized,
         )?
@@ -294,7 +290,7 @@ impl<'a> Operation<'a> {
 
     fn collect_elements<T>(
         elements: &[(&'a str, TypeConstraint<'a>)],
-        create: impl Fn(&'a str, TypeConstraint<'a>, SequenceInfo, VariadicKind) -> Result<T, Error>,
+        create: impl Fn(&'a str, TypeConstraint<'a>, VariadicKind) -> Result<T, Error>,
         same_size: bool,
         attribute_sized: bool,
     ) -> Result<(Vec<T>, usize), Error> {
@@ -305,16 +301,8 @@ impl<'a> Operation<'a> {
         let mut variadic_kind = VariadicKind::new(unfixed_count, same_size, attribute_sized);
         let mut fields = vec![];
 
-        for (index, (name, constraint)) in elements.iter().enumerate() {
-            fields.push(create(
-                name,
-                *constraint,
-                SequenceInfo {
-                    index,
-                    len: elements.len(),
-                },
-                variadic_kind.clone(),
-            )?);
+        for (name, constraint) in elements {
+            fields.push(create(name, *constraint, variadic_kind.clone())?);
 
             match &mut variadic_kind {
                 VariadicKind::Simple { unfixed_seen } => {

macro/src/dialect/operation/attribute.rs

@@ -1,6 +1,6 @@
 use crate::dialect::{
     error::Error,
-    operation::operation_field::OperationFieldLike,
+    operation::operation_field::OperationField,
     utility::{generate_result_type, sanitize_snake_case_identifier},
 };
 use once_cell::sync::Lazy;
@@ -109,7 +109,7 @@ impl<'a> Attribute<'a> {
     }
 }
 
-impl OperationFieldLike for Attribute<'_> {
+impl OperationField for Attribute<'_> {
     fn name(&self) -> &str {
         self.name
     }

macro/src/dialect/operation/field_kind.rs

@@ -0,0 +1,94 @@
+use super::{OperationElement, OperationField, VariadicKind};
+use crate::dialect::{
+    error::Error,
+    types::TypeConstraint,
+    utility::{generate_iterator_type, generate_result_type, sanitize_snake_case_identifier},
+};
+use proc_macro2::{Ident, TokenStream};
+use quote::{format_ident, quote};
+use syn::{parse_quote, Type};
+
+#[derive(Debug)]
+pub struct Operand<'a> {
+    name: &'a str,
+    singular_identifier: Ident,
+    constraint: TypeConstraint<'a>,
+    variadic_kind: VariadicKind,
+}
+
+impl<'a> Operand<'a> {
+    pub fn new(
+        name: &'a str,
+        constraint: TypeConstraint<'a>,
+        variadic_kind: VariadicKind,
+    ) -> Result<Self, Error> {
+        Ok(Self {
+            name,
+            singular_identifier: sanitize_snake_case_identifier(name)?,
+            constraint,
+            variadic_kind,
+        })
+    }
+}
+
+impl OperationField for Operand<'_> {
+    fn name(&self) -> &str {
+        self.name
+    }
+
+    fn singular_identifier(&self) -> &Ident {
+        &self.singular_identifier
+    }
+
+    fn plural_kind_identifier(&self) -> Ident {
+        format_ident!("operands")
+    }
+
+    fn parameter_type(&self) -> Type {
+        let r#type: Type = parse_quote!(::melior::ir::Value<'c, '_>);
+
+        if self.constraint.is_variadic() {
+            parse_quote! { &[#r#type] }
+        } else {
+            r#type
+        }
+    }
+
+    fn return_type(&self) -> Type {
+        let r#type: Type = parse_quote!(::melior::ir::Value<'c, '_>);
+
+        if !self.constraint.is_variadic() {
+            generate_result_type(r#type)
+        } else if self.variadic_kind == VariadicKind::AttributeSized {
+            generate_result_type(generate_iterator_type(r#type))
+        } else {
+            generate_iterator_type(r#type)
+        }
+    }
+
+    fn is_optional(&self) -> bool {
+        self.constraint.is_optional()
+    }
+
+    fn is_result(&self) -> bool {
+        false
+    }
+
+    fn add_arguments(&self, name: &Ident) -> TokenStream {
+        if self.constraint.is_variadic() {
+            quote! { #name }
+        } else {
+            quote! { &[#name] }
+        }
+    }
+}
+
+impl OperationElement for Operand<'_> {
+    fn is_variadic(&self) -> bool {
+        self.constraint.is_variadic()
+    }
+
+    fn variadic_kind(&self) -> &VariadicKind {
+        &self.variadic_kind
+    }
+}

macro/src/dialect/operation/operand.rs

@@ -1,6 +1,6 @@
-use super::{OperationFieldLike, VariadicKind};
+use super::{OperationField, VariadicKind};
 
-pub trait OperationElement: OperationFieldLike {
+pub trait OperationElement: OperationField {
     fn is_variadic(&self) -> bool;
     fn variadic_kind(&self) -> &VariadicKind;