[flang][mlir][NFC] Remove deprecated parser/printer/verifier utilities

[shraiysh]

Summary

These have been replaced by hasCustomAssemblyFormat and hasVerifier
fields and aren't needed anymore.

Ops deriving from fir_IntegralSwitchTerminatorOp and region_Op are
not handled in this patch for ease of review.

[shraiysh]

Remove commented code.

[shraiysh]

Updated missed verifiers. This is ready for review now.

[rriddle]

Really nice, thanks!

flang/lib/Optimizer/Dialect/FIROps.cpp

245

Can you drop the () here? (and a few others)

[shraiysh]

Addressed comment. Thanks for the review @rriddle.

[clementval]

Thanks for the patch @shraiysh! With the upstreaming going on we felt a bit behind on this kind of stuff.

[shraiysh]

In D119776#3321823, @clementval wrote:

Thanks for the patch @shraiysh! With the upstreaming going on we felt a bit behind on this kind of stuff.

No worries! It is a collective effort and it is understandable that they will sometimes be out-of-sync. Happy to help! :)

flang/include/flang/Optimizer/Dialect/FIROps.td

let arguments = (ins
     OptionalAttr<StrAttr>:$bindc_name,
     UnitAttr:$pinned,
     Variadic<AnyIntegerType>:$typeparams,
     Variadic<AnyIntegerType>:$shape
   );
 
   let results = (outs fir_ReferenceType);
 
-  let parser =
-      "return parseAllocatableOp(wrapAllocaResultType, parser, result);";
-  let printer = "printAllocatableOp(p, (*this));";
+  let hasCustomAssemblyFormat = 1;
+  let hasVerifier = 1;
 
   let builders = [
     OpBuilder<(ins "mlir::Type":$inType, "llvm::StringRef":$uniqName,
       "llvm::StringRef":$bindcName, CArg<"mlir::ValueRange", "{}">:$typeparams,
       CArg<"mlir::ValueRange", "{}">:$shape,
       CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attributes)>,
     OpBuilder<(ins "mlir::Type":$inType, "llvm::StringRef":$uniqName,
       "llvm::StringRef":$bindcName, "bool":$pinned,
OpBuilder<(ins "mlir::Type":$inType, "bool":$pinned,
       CArg<"mlir::ValueRange", "{}">:$typeparams,
       CArg<"mlir::ValueRange", "{}">:$shape,
       CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attributes)>,
     OpBuilder<(ins "mlir::Type":$inType,
       CArg<"mlir::ValueRange", "{}">:$typeparams,
       CArg<"mlir::ValueRange", "{}">:$shape,
       CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attributes)>];
 
-  let verifier = "return ::verify(*this);";
-
   let extraClassDeclaration = [{
     mlir::Type getAllocatedType();
     bool hasLenParams() { return !typeparams().empty(); }
     bool hasShapeOperands() { return !shape().empty(); }
     unsigned numLenParams() { return typeparams().size(); }
     operand_range getLenParams() { return typeparams(); }
     unsigned numShapeOperands() { return shape().size(); }
     operand_range getShapeOperands() { return shape(); }
let arguments = (ins
     TypeAttr:$in_type,
     OptionalAttr<StrAttr>:$uniq_name,
     OptionalAttr<StrAttr>:$bindc_name,
     Variadic<AnyIntegerType>:$typeparams,
     Variadic<AnyIntegerType>:$shape
   );
   let results = (outs fir_HeapType);
 
-  let parser =
-      "return parseAllocatableOp(wrapAllocMemResultType, parser, result);";
-  let printer = "printAllocatableOp(p, (*this));";
+  let hasCustomAssemblyFormat = 1;
+  let hasVerifier = 1;
 
   let builders = [
     OpBuilder<(ins "mlir::Type":$in_type, "llvm::StringRef":$uniq_name,
       "llvm::StringRef":$bindc_name, CArg<"mlir::ValueRange", "{}">:$typeparams,
       CArg<"mlir::ValueRange", "{}">:$shape,
       CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attributes)>,
     OpBuilder<(ins "mlir::Type":$in_type, "llvm::StringRef":$uniq_name,
       CArg<"mlir::ValueRange", "{}">:$typeparams,
       CArg<"mlir::ValueRange", "{}">:$shape,
       CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attributes)>,
     OpBuilder<(ins "mlir::Type":$in_type,
       CArg<"mlir::ValueRange", "{}">:$typeparams,
       CArg<"mlir::ValueRange", "{}">:$shape,
       CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attributes)>];
 
-  let verifier = "return ::verify(*this);";
-
   let extraClassDeclaration = [{
     mlir::Type getAllocatedType();
     bool hasLenParams() { return !typeparams().empty(); }
     bool hasShapeOperands() { return !shape().empty(); }
     unsigned numLenParams() { return typeparams().size(); }
     operand_range getLenParams() { return typeparams(); }
     unsigned numShapeOperands() { return shape().size(); }
     operand_range getShapeOperands() { return shape(); }
let description = [{
     The ssa-value has an undefined value if the memory reference is undefined
     or null.
   }];
 
   let arguments = (ins Arg<AnyReferenceLike, "", [MemRead]>:$memref);
 
   let builders = [OpBuilder<(ins "mlir::Value":$refVal)>];
 
-  let parser = "return parseLoadOp(parser, result);";
-
-  let printer = "::print(p, *this);";
+  let hasCustomAssemblyFormat = 1;
 
   let extraClassDeclaration = [{
     static mlir::ParseResult getElementOf(mlir::Type &ele, mlir::Type ref);
   }];
 }
 
 def fir_CharConvertOp : fir_Op<"char_convert", []> {
   let summary = [{
let arguments = (ins
     AnyIntegerType:$count,
     Arg<AnyReferenceLike, "", [MemWrite]>:$to
   );
 
   let assemblyFormat = [{
     $from `for` $count `to` $to attr-dict `:` type(operands)
   }];
 
-  let verifier = "return ::verify(*this);";
+  let hasVerifier = 1;
 }
 
 def fir_StoreOp : fir_Op<"store", []> {
   let summary = "store an SSA-value to a memory location";
 
   let description = [{
     Store an ssa-value (virtual register) to a memory reference.  The stored
     value must be of the same type as the referent type of the memory
     reference.
 
     ```mlir
       %v = ... : f64
       %p = ... : !fir.ptr<f64>
       fir.store %v to %p : !fir.ptr<f64>
     ```
 
     The above store changes the value to which the pointer is pointing and not
     the pointer itself. The operation is undefined if the memory reference,
     `%p`, is undefined or null.
   }];
 
   let arguments = (ins AnyType:$value,
                    Arg<AnyReferenceLike, "", [MemWrite]>:$memref);
 
-  let parser = "return parseStoreOp(parser, result);";
-
-  let printer = "::print(p, *this);";
-
-  let verifier = "return ::verify(*this);";
+  let hasCustomAssemblyFormat = 1;
+  let hasVerifier = 1;
 
   let extraClassDeclaration = [{
     static mlir::Type elementType(mlir::Type refType);
   }];
 }
 
 def fir_SaveResultOp : fir_Op<"save_result", [AttrSizedOperandSegments]> {
   let summary = [{
let arguments = (ins ArrayOrBoxOrRecord:$value,
                    Optional<AnyShapeType>:$shape,
                    Variadic<AnyIntegerType>:$typeparams);
 
   let assemblyFormat = [{
     $value `to` $memref (`(` $shape^ `)`)? (`typeparams` $typeparams^)?
     attr-dict `:` type(operands)
   }];
 
-  let verifier = "return ::verify(*this);";
+  let hasVerifier = 1;
 }
 
 def fir_UndefOp : fir_OneResultOp<"undefined", [NoSideEffect]> {
   let summary = "explicit undefined value of some type";
   let description = [{
     Constructs an ssa-value of the specified type with an undefined value.
     This operation is typically created internally by the mem2reg conversion
     pass. An undefined value can be of any type except `!fir.ref<T>`.
OpBuilder<(ins "mlir::Value":$selector,
       CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attributes)>,
     OpBuilder<(ins "mlir::Value":$selector,
       "llvm::ArrayRef<mlir::Attribute>":$compareAttrs,
       "llvm::ArrayRef<mlir::Value>":$cmpOpList,
       "llvm::ArrayRef<mlir::Block *>":$destinations,
       CArg<"llvm::ArrayRef<mlir::ValueRange>", "{}">:$destOperands,
       CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attributes)>];
 
-  let parser = "return parseSelectCase(parser, result);";
-
-  let printer = "::print(p, *this);";
-
-  let verifier = "return ::verify(*this);";
+  let hasCustomAssemblyFormat = 1;
+  let hasVerifier = 1;
 
   let extraClassDeclaration = extraSwitchClassDeclaration#[{
     unsigned compareOffsetSize();
   }];
 }
 
 def fir_SelectTypeOp : fir_SwitchTerminatorOp<"select_type"> {
   let summary = "Fortran's SELECT TYPE statement";
def fir_SelectTypeOp : fir_SwitchTerminatorOp<"select_type"> {
 
   let skipDefaultBuilders = 1;
   let builders = [OpBuilder<(ins "mlir::Value":$selector,
     "llvm::ArrayRef<mlir::Attribute>":$typeOperands,
     "llvm::ArrayRef<mlir::Block *>":$destinations,
     CArg<"llvm::ArrayRef<mlir::ValueRange>", "{}">:$destOperands,
     CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attributes)>];
 
-  let parser = "return parseSelectType(parser, result);";
-
-  let printer = "::print(p, *this);";
-
-  let verifier = "return ::verify(*this);";
+  let hasCustomAssemblyFormat = 1;
+  let hasVerifier = 1;
 
   let extraClassDeclaration = extraSwitchClassDeclaration;
 }
 
 def fir_UnreachableOp : fir_Op<"unreachable", [Terminator]> {
   let summary = "the unreachable instruction";
 
   let description = [{
     Terminates a basic block with the assertion that the end of the block
     will never be reached at runtime.  This instruction can be used
     immediately after a call to the Fortran runtime to terminate the
     program, for example.  This instruction corresponds to the LLVM IR
     instruction `unreachable`.
 
     ```mlir
       fir.unreachable
     ```
   }];
 
-  let parser = "return mlir::success();";
+  let assemblyFormat = [{ attr-dict }];
 
-  let printer = "";
 }
 
 def fir_FirEndOp : fir_Op<"end", [Terminator]> {
   let summary = "the end instruction";
 
   let description = [{
     The end terminator is a special terminator used inside various FIR
     operations that have regions.  End is thus the custom invisible terminator
[{ return build($_builder, $_state, resultTypes, memref, shape, slice,
                     typeparams, mlir::AffineMapAttr{}); }]>
   ];
 
   let assemblyFormat = [{
     $memref (`(` $shape^ `)`)? (`[` $slice^ `]`)? (`typeparams` $typeparams^)?
       (`map` $accessMap^)? attr-dict `:` functional-type(operands, results)
   }];
 
-  let verifier = "return ::verify(*this);";
+  let hasVerifier = 1;
 
   let extraClassDeclaration = [{
     bool hasLenParams() { return !typeparams().empty(); }
     unsigned numLenParams() { return typeparams().size(); }
   }];
 }
 
 def fir_ReboxOp : fir_Op<"rebox", [NoSideEffect, AttrSizedOperandSegments]> {
def fir_ReboxOp : fir_Op<"rebox", [NoSideEffect, AttrSizedOperandSegments]> {
   );
 
   let results = (outs fir_BoxType);
 
   let assemblyFormat = [{
     $box (`(` $shape^ `)`)? (`[` $slice^ `]`)? attr-dict `:` functional-type(operands, results)
   }];
 
-  let verifier = "return ::verify(*this);";
+  let hasVerifier = 1;
 }
 
 def fir_EmboxCharOp : fir_Op<"emboxchar", [NoSideEffect]> {
   let summary = "boxes a given CHARACTER reference and its LEN parameter";
 
   let description = [{
     Create a boxed CHARACTER value. The CHARACTER type has the LEN type
     parameter, the value of which may only be known at runtime.  Therefore,
def fir_EmboxCharOp : fir_Op<"emboxchar", [NoSideEffect]> {
   let arguments = (ins AnyReferenceLike:$memref, AnyIntegerLike:$len);
 
   let results = (outs fir_BoxCharType);
 
   let assemblyFormat = [{
     $memref `,` $len attr-dict `:` functional-type(operands, results)
   }];
 
-  let verifier = "return ::verify(*this);";
+  let hasVerifier = 1;
 }
 
 def fir_EmboxProcOp : fir_Op<"emboxproc", [NoSideEffect]> {
   let summary = "boxes a given procedure and optional host context";
 
   let description = [{
     Creates an abstract encapsulation of a PROCEDURE POINTER along with an
     optional pointer to a host instance context. If the pointer is not to an
```mlir
       %5 = fir.emboxproc @g, %4 : ((i32) -> i32, !fir.ref<tuple<i32, i32>>) -> !fir.boxproc<(i32) -> i32>
     ```
   }];
 
   let arguments = (ins SymbolRefAttr:$funcname, AnyReferenceLike:$host);
 
   let results = (outs fir_BoxProcType);
 
-  let parser = "return parseEmboxProcOp(parser, result);";
-
-  let printer = "::print(p, *this);";
-
-  let verifier = "return ::verify(*this);";
+  let hasCustomAssemblyFormat = 1;
+  let hasVerifier = 1;
 }
 
 def fir_UnboxCharOp : fir_SimpleOp<"unboxchar", [NoSideEffect]> {
   let summary = "unbox a boxchar value into a pair value";
 
   let description = [{
     Unboxes a value of `boxchar` type into a pair consisting of a memory
     reference to the CHARACTER data and the LEN type parameter.
let description = [{
     pointer and a pointer to a host context.
 
     ```mlir
       %47   = ... : !fir.boxproc<() -> i32>
       %48:2 = fir.unboxproc %47 : (!fir.ref<() -> i32>, !fir.ref<tuple<f32, i32>>)
     ```
   }];
 
-  let verifier = "return ::verify(*this);";
+  let hasVerifier = 1;
 
   let arguments = (ins fir_BoxProcType:$boxproc);
 
   let results = (outs FunctionType, fir_ReferenceType:$refTuple);
 }
 
 def fir_BoxAddrOp : fir_SimpleOneResultOp<"box_addr", [NoSideEffect]> {
   let summary = "return a memory reference to the boxed value";
def fir_ArrayLoadOp : fir_Op<"array_load", [AttrSizedOperandSegments]> {
 
   let results = (outs fir_SequenceType);
 
   let assemblyFormat = [{
     $memref (`(`$shape^`)`)? (`[`$slice^`]`)? (`typeparams` $typeparams^)?
         attr-dict `:` functional-type(operands, results)
   }];
 
-  let verifier = "return ::verify(*this);";
+  let hasVerifier = 1;
 
   let extraClassDeclaration = [{
     std::vector<mlir::Value> getExtents();
   }];
 }
 
 def fir_ArrayFetchOp : fir_Op<"array_fetch", [AttrSizedOperandSegments,
     NoSideEffect]> {
def fir_ArrayFetchOp : fir_Op<"array_fetch", [AttrSizedOperandSegments,
 
   let results = (outs AnyType:$element);
 
   let assemblyFormat = [{
     $sequence `,` $indices (`typeparams` $typeparams^)? attr-dict `:`
       functional-type(operands, results)
   }];
 
-  let verifier = "return ::verify(*this);";
+  let hasVerifier = 1;
 }
 
 def fir_ArrayUpdateOp : fir_Op<"array_update", [AttrSizedOperandSegments,
     NoSideEffect]> {
 
   let summary = "Update the value of an element of an array value";
 
   let description = [{
def fir_ArrayUpdateOp : fir_Op<"array_update", [AttrSizedOperandSegments,
 
   let results = (outs fir_SequenceType);
 
   let assemblyFormat = [{
     $sequence `,` $merge `,` $indices (`typeparams` $typeparams^)? attr-dict
       `:` functional-type(operands, results)
   }];
 
-  let verifier = "return ::verify(*this);";
+  let hasVerifier = 1;
 }
 
 def fir_ArrayModifyOp : fir_Op<"array_modify", [AttrSizedOperandSegments,
     NoSideEffect]> {
   let summary = "Get an address for an array value to modify it.";
 
   let description = [{
     Modify the value of an element in an array value through actions done
def fir_ArrayModifyOp : fir_Op<"array_modify", [AttrSizedOperandSegments,
 
   let results = (outs fir_ReferenceType, fir_SequenceType);
 
   let assemblyFormat = [{
     $sequence `,` $indices (`typeparams` $typeparams^)? attr-dict
       `:` functional-type(operands, results)
   }];
 
-  let verifier = "return ::verify(*this);";
+  let hasVerifier = 1;
 }
 
 def fir_ArrayAccessOp : fir_Op<"array_access", [AttrSizedOperandSegments,
     NoSideEffect]> {
   let summary = "Fetch the reference of an element of an array value";
 
   let description = [{
     The `array_access` provides a reference to a single element from an array
def fir_ArrayAccessOp : fir_Op<"array_access", [AttrSizedOperandSegments,
 
   let results = (outs fir_ReferenceType:$element);
 
   let assemblyFormat = [{
     $sequence `,` $indices (`typeparams` $typeparams^)? attr-dict `:`
       functional-type(operands, results)
   }];
 
-  let verifier = "return ::verify(*this);";
+  let hasVerifier = 1;
 }
 
 def fir_ArrayAmendOp : fir_Op<"array_amend", [NoSideEffect]> {
   let summary = "Mark an array value as having been changed by reference.";
 
   let description = [{
     The `array_amend` operation marks an array value as having been changed via
     a reference obtained by an `array_access`. It acts as a logical transaction
let arguments = (ins
     Variadic<AnyIntegerType>:$typeparams
   );
 
   let assemblyFormat = [{
     $original `,` $sequence `to` $memref (`[` $slice^ `]`)? (`typeparams`
       $typeparams^)? attr-dict `:` type(operands)
   }];
 
-  let verifier = "return ::verify(*this);";
+  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // Record and array type operations
 //===----------------------------------------------------------------------===//
 
 def fir_ArrayCoorOp : fir_Op<"array_coor",
     [NoSideEffect, AttrSizedOperandSegments]> {
def fir_ArrayCoorOp : fir_Op<"array_coor",
 
   let results = (outs fir_ReferenceType);
 
   let assemblyFormat = [{
     $memref (`(`$shape^`)`)? (`[`$slice^`]`)? $indices (`typeparams`
       $typeparams^)? attr-dict `:` functional-type(operands, results)
   }];
 
-  let verifier = "return ::verify(*this);";
+  let hasVerifier = 1;
 }
 
 def fir_CoordinateOp : fir_Op<"coordinate_of", [NoSideEffect]> {
 
   let summary = "Finds the coordinate (location) of a value in memory";
 
   let description = [{
     Compute the internal coordinate address starting from a boxed value or
def fir_CoordinateOp : fir_Op<"coordinate_of", [NoSideEffect]> {
   let arguments = (ins
     AnyRefOrBox:$ref,
     Variadic<AnyCoordinateType>:$coor,
     TypeAttr:$baseType
   );
 
   let results = (outs RefOrLLVMPtr);
 
-  let parser =  "return parseCoordinateCustom(parser, result);";
-  let printer = "::print(p, *this);";
-  let verifier = "return ::verify(*this);";
+  let hasCustomAssemblyFormat = 1;
+  let hasVerifier = 1;
 
   let builders = [
     OpBuilder<(ins "mlir::Type":$resultType,
       "mlir::Value":$ref, "mlir::ValueRange":$coor),
     [{ return build($_builder, $_state, resultType, ref, coor,
            mlir::TypeAttr::get(ref.getType())); }]>,
   ];
 }
def fir_FieldIndexOp : fir_OneResultOp<"field_index", [NoSideEffect]> {
   }];
 
   let arguments = (ins
     StrAttr:$field_id,
     TypeAttr:$on_type,
     Variadic<AnyIntegerType>:$typeparams
   );
 
-  let parser = "return parseFieldIndexOp(parser, result);";
-
-  let printer = "::print(p, *this);";
+  let hasCustomAssemblyFormat = 1;
 
   let builders = [OpBuilder<(ins "llvm::StringRef":$fieldName,
       "mlir::Type":$recTy, CArg<"mlir::ValueRange","{}">:$operands)>];
 
   let extraClassDeclaration = [{
     static constexpr llvm::StringRef fieldAttrName() { return "field_id"; }
     static constexpr llvm::StringRef typeAttrName() { return "on_type"; }
     llvm::StringRef getFieldName() { return field_id(); }
def fir_ShapeOp : fir_Op<"shape", [NoSideEffect]> {
   let arguments = (ins Variadic<AnyIntegerType>:$extents);
 
   let results = (outs fir_ShapeType);
 
   let assemblyFormat = [{
     operands attr-dict `:` functional-type(operands, results)
   }];
 
-  let verifier = "return ::verify(*this);";
+  let hasVerifier = 1;
 }
 
 def fir_ShapeShiftOp : fir_Op<"shape_shift", [NoSideEffect]> {
 
   let summary = [{
     generate an abstract shape and shift vector of type `!fir.shapeshift`
   }];
 
def fir_ShapeShiftOp : fir_Op<"shape_shift", [NoSideEffect]> {
   let arguments = (ins Variadic<AnyIntegerType>:$pairs);
 
   let results = (outs fir_ShapeShiftType);
 
   let assemblyFormat = [{
     operands attr-dict `:` functional-type(operands, results)
   }];
 
-  let verifier = "return ::verify(*this);";
+  let hasVerifier = 1;
 
   let extraClassDeclaration = [{
     // Logically unzip the origins from the extent values.
     std::vector<mlir::Value> getOrigins() {
       std::vector<mlir::Value> result;
       for (auto i : llvm::enumerate(pairs()))
         if (!(i.index() & 1))
           result.push_back(i.value());
def fir_ShiftOp : fir_Op<"shift", [NoSideEffect]> {
   let arguments = (ins Variadic<AnyIntegerType>:$origins);
 
   let results = (outs fir_ShiftType);
 
   let assemblyFormat = [{
     operands attr-dict `:` functional-type(operands, results)
   }];
 
-  let verifier = "return ::verify(*this);";
+  let hasVerifier = 1;
 }
 
 def fir_SliceOp : fir_Op<"slice", [NoSideEffect, AttrSizedOperandSegments]> {
 
   let summary = "generate an abstract slice vector of type `!fir.slice`";
 
   let description = [{
     The array slicing arguments are an ordered list of integral type values
def fir_SliceOp : fir_Op<"slice", [NoSideEffect, AttrSizedOperandSegments]> {
   }];
 
   let builders = [
     OpBuilder<(ins "mlir::ValueRange":$triples,
       CArg<"mlir::ValueRange", "llvm::None">:$fields,
       CArg<"mlir::ValueRange", "llvm::None">:$substr)>
   ];
 
-  let verifier = "return ::verify(*this);";
+  let hasVerifier = 1;
 
   let extraClassDeclaration = [{
     unsigned getOutRank() { return getOutputRank(triples()); }
     static unsigned getOutputRank(mlir::ValueRange triples);
   }];
 }
 
 def fir_InsertValueOp : fir_OneResultOp<"insert_value", [NoSideEffect]> {
def fir_InsertOnRangeOp : fir_OneResultOp<"insert_on_range", [NoSideEffect]> {
 
   let arguments = (ins fir_SequenceType:$seq, AnyType:$val, IndexElementsAttr:$coor);
   let results = (outs fir_SequenceType);
 
   let assemblyFormat = [{
     $seq `,` $val custom<CustomRangeSubscript>($coor) attr-dict `:` functional-type(operands, results)
   }];
 
-  let verifier = "return ::verify(*this);";
+  let hasVerifier = 1;
 }
 
 def fir_LenParamIndexOp : fir_OneResultOp<"len_param_index", [NoSideEffect]> {
   let summary =
     "create a field index value from a LEN type parameter identifier";
 
   let description = [{
     Generate a LEN parameter (offset) value from an LEN parameter identifier.
     The type of a LEN parameter value is `!fir.len` and these values can be
     used with the `fir.coordinate_of` instructions to compute (abstract)
     addresses of LEN parameters.
 
     ```mlir
       %e = fir.len_param_index len1, !fir.type<X(len1:i32)>
       %p = ... : !fir.box<!fir.type<X>>
       %q = fir.coordinate_of %p, %e : (!fir.box<!fir.type<X>>, !fir.len) -> !fir.ref<i32>
     ```
   }];
 
   let arguments = (ins StrAttr:$field_id, TypeAttr:$on_type);
 
-  let parser = "return parseLenParamIndexOp(parser, result);";
-
-  let printer = "::print(p, *this);";
+  let hasCustomAssemblyFormat = 1;
 
   let builders = [OpBuilder<(ins "llvm::StringRef":$fieldName,
       "mlir::Type":$recTy),
     [{
       $_state.addAttribute(fieldAttrName(), $_builder.getStringAttr(fieldName));
       $_state.addAttribute(typeAttrName(), TypeAttr::get(recTy));
     }]
   >];
let description = [{
     depending upon its semantics.
   }];
 
   let arguments = (ins Variadic<AnyType>:$results);
   let builders = [OpBuilder<(ins), [{ /* do nothing */ }]>];
 
   let assemblyFormat = "($results^ `:` type($results))? attr-dict";
 
-  let verifier = "return ::verify(*this);";
+  let hasVerifier = 1;
 }
 
 def FirRegionTerminator : SingleBlockImplicitTerminator<"ResultOp">;
 
 class region_Op<string mnemonic, list<Trait> traits = []> :
     fir_Op<mnemonic,
     !listconcat(traits, [FirRegionTerminator, RecursiveSideEffects])> {
   let printer = "return ::print(p, *this);";
def fir_CallOp : fir_Op<"call", [CallOpInterface]> {
   }];
 
   let arguments = (ins
     OptionalAttr<SymbolRefAttr>:$callee,
     Variadic<AnyType>:$args
   );
   let results = (outs Variadic<AnyType>);
 
-  let parser = "return parseCallOp(parser, result);";
-  let printer = "printCallOp(p, *this);";
+  let hasCustomAssemblyFormat = 1;
 
   let builders = [
     OpBuilder<(ins "mlir::FuncOp":$callee,
         CArg<"mlir::ValueRange", "{}">:$operands)>,
     OpBuilder<(ins "mlir::SymbolRefAttr":$callee,
         "llvm::ArrayRef<mlir::Type>":$results,
         CArg<"mlir::ValueRange", "{}">:$operands)>,
     OpBuilder<(ins "llvm::StringRef":$callee,
def fir_DispatchOp : fir_Op<"dispatch", []> {
   let arguments = (ins
     StrAttr:$method,
     fir_BoxType:$object,
     Variadic<AnyType>:$args
   );
 
   let results = (outs Variadic<AnyType>);
 
-  let parser = "return parseDispatchOp(parser, result);";
-
-  let printer = "::print(p, *this);";
+  let hasCustomAssemblyFormat = 1;
 
   let extraClassDeclaration = [{
     mlir::FunctionType getFunctionType();
     operand_range getArgOperands() {
       return {arg_operand_begin(), arg_operand_end()};
     }
     // operand[0] is the object (of box type)
     operand_iterator arg_operand_begin() { return operand_begin() + 1; }
let description = [{
     ```mlir
       %1 = fir.string_lit "Hello, World!"(13) : !fir.char<1> // ASCII
       %2 = fir.string_lit [158, 2345](2) : !fir.char<2>      // Wide chars
     ```
   }];
 
   let results = (outs fir_CharacterType);
 
-  let parser = "return parseStringLitOp(parser, result);";
-
-  let printer = "::print(p, *this);";
+  let hasCustomAssemblyFormat = 1;
+  let hasVerifier = 1;
 
   let builders = [
     OpBuilder<(ins "fir::CharacterType":$inType,
       "llvm::StringRef":$value,
       CArg<"llvm::Optional<int64_t>", "{}">:$len)>,
     OpBuilder<(ins "fir::CharacterType":$inType,
       "llvm::ArrayRef<char>":$xlist,
       CArg<"llvm::Optional<int64_t>", "{}">:$len)>,
     OpBuilder<(ins "fir::CharacterType":$inType,
       "llvm::ArrayRef<char16_t>":$xlist,
       CArg<"llvm::Optional<int64_t>", "{}">:$len)>,
     OpBuilder<(ins "fir::CharacterType":$inType,
       "llvm::ArrayRef<char32_t>":$xlist,
       CArg<"llvm::Optional<int64_t>", "{}">:$len)>];
 
-  let verifier = "return ::verify(*this);";
-
   let extraClassDeclaration = [{
     static constexpr const char *size() { return "size"; }
     static constexpr const char *value() { return "value"; }
     static constexpr const char *xlist() { return "xlist"; }
 
     // Get the LEN attribute of this character constant
     mlir::Attribute getSize() { return (*this)->getAttr(size()); }
     // Get the string value of this character constant
def fir_ConstcOp : fir_Op<"constc", [NoSideEffect]> {
   let description = [{
     A complex constant. Similar to the standard dialect complex type, but this
     extension allows constants with APFloat values that are not supported in
     the standard dialect.
   }];
 
   let results = (outs fir_ComplexType);
 
-  let parser = "return parseConstcOp(parser, result);";
-
-  let printer = "::print(p, *this);";
-
-  let verifier = "return ::verify(*this);";
+  let hasCustomAssemblyFormat = 1;
+  let hasVerifier = 1;
 
   let extraClassDeclaration = [{
     static constexpr llvm::StringRef realAttrName() { return "real"; }
     static constexpr llvm::StringRef imagAttrName() { return "imaginary"; }
 
     mlir::Attribute getReal() { return (*this)->getAttr(realAttrName()); }
     mlir::Attribute getImaginary() { return (*this)->getAttr(imagAttrName()); }
   }];
def fir_CmpcOp : fir_Op<"cmpc",
   let description = [{
     A complex comparison to handle complex types found in FIR.
   }];
 
   let arguments = (ins fir_ComplexType:$lhs, fir_ComplexType:$rhs);
 
   let results = (outs AnyLogicalLike);
 
-  let parser = "return parseCmpcOp(parser, result);";
-
-  let printer = "printCmpcOp(p, *this);";
+  let hasCustomAssemblyFormat = 1;
 
   let builders = [OpBuilder<(ins "mlir::arith::CmpFPredicate":$predicate,
     "mlir::Value":$lhs, "mlir::Value":$rhs), [{
       buildCmpCOp($_builder, $_state, predicate, lhs, rhs);
   }]>];
 
   let extraClassDeclaration = [{
     static constexpr llvm::StringRef getPredicateAttrName() {
def fir_ConvertOp : fir_OneResultOp<"convert", [NoSideEffect]> {
   let arguments = (ins AnyType:$value);
 
   let assemblyFormat = [{
     $value attr-dict `:` functional-type($value, results)
   }];
 
   let hasFolder = 1;
 
-  let verifier = "return ::verify(*this);";
+  let hasVerifier = 1;
 
   let extraClassDeclaration = [{
     static bool isIntegerCompatible(mlir::Type ty);
     static bool isFloatCompatible(mlir::Type ty);
     static bool isPointerCompatible(mlir::Type ty);
   }];
   let hasCanonicalizer = 1;
 }
let description = [{
     ```mlir
       !T = type !fir.type<T{...}>
       %t = fir.gentypedesc !T  // returns value of !fir.tdesc<!T>
     ```
   }];
 
   let arguments = (ins FortranTypeAttr:$in_type);
 
-  let parser = "return parseGenTypeDescOp(parser, result);";
-
-  let printer = "::print(p, *this);";
+  let hasCustomAssemblyFormat = 1;
+  let hasVerifier = 1;
 
   let builders = [OpBuilder<(ins "mlir::TypeAttr":$inty)>];
-
-  let verifier = "return ::verify(*this);";
 }
 
 def fir_NoReassocOp : fir_OneResultOp<"no_reassoc",
     [NoSideEffect, SameOperandsAndResultType]> {
   let summary = "synthetic op to prevent reassociation";
   let description = [{
     Primitive operation meant to intrusively prevent operator reassociation.
     The operation is otherwise a nop and the value returned is the same as the
let arguments = (ins
     TypeAttr:$type,
     OptionalAttr<AnyAttr>:$initVal,
     OptionalAttr<UnitAttr>:$constant,
     OptionalAttr<StrAttr>:$linkName
   );
 
   let regions = (region AtMostRegion<1>:$region);
 
-  let parser = "return parseGlobalOp(parser, result);";
-
-  let printer = "::print(p, *this);";
+  let hasCustomAssemblyFormat = 1;
 
   let skipDefaultBuilders = 1;
   let builders = [
     OpBuilder<(ins "llvm::StringRef":$name, "mlir::Type":$type,
       CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attrs)>,
     OpBuilder<(ins "llvm::StringRef":$name, "bool":$isConstant,
       "mlir::Type":$type,
       CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attrs)>,
```mlir
         %1 = fir.undefined !fir.type<t(len1:i32)>
         fir.has_value %1 : !fir.type<t(len1:i32)>
       }
     ```
   }];
 
   let arguments = (ins StrAttr:$lenparam, APIntAttr:$intval);
 
-  let parser = "return parseGlobalLenOp(parser, result);";
-
-  let printer = "::print(p, *this);";
+  let hasCustomAssemblyFormat = 1;
 
   let extraClassDeclaration = [{
     static constexpr llvm::StringRef lenParamAttrName() { return "lenparam"; }
     static constexpr llvm::StringRef intAttrName() { return "intval"; }
   }];
 }
 
 def ImplicitFirTerminator : SingleBlockImplicitTerminator<"FirEndOp">;
let description = [{
     ```mlir
       fir.dispatch_table @_QDTMquuzTfoo {
         fir.dt_entry method1, @_QFNMquuzTfooPmethod1AfooR
         fir.dt_entry method2, @_QFNMquuzTfooPmethod2AfooII
       }
     ```
   }];
 
-  let parser = "return parseDispatchTableOp(parser, result);";
-
-  let printer = "::print(p, *this);";
-
-  let verifier = "return ::verify(*this);";
+  let hasCustomAssemblyFormat = 1;
+  let hasVerifier = 1;
 
   let regions = (region SizedRegion<1>:$region);
 
   let skipDefaultBuilders = 1;
   let builders = [
     OpBuilder<(ins "llvm::StringRef":$name, "mlir::Type":$type,
       CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attrs),
     [{
let description = [{
 
     ```mlir
       fir.dt_entry method_name, @uniquedProcedure
     ```
   }];
 
   let arguments = (ins StrAttr:$method, SymbolRefAttr:$proc);
 
-  let parser = "return parseDTEntryOp(parser, result);";
-
-  let printer = "::print(p, *this);";
+  let hasCustomAssemblyFormat = 1;
 
   let extraClassDeclaration = [{
     static constexpr llvm::StringRef getMethodAttrNameStr() { return "method"; }
     static constexpr llvm::StringRef getProcAttrNameStr() { return "proc"; }
   }];
 }
 
 def fir_AbsentOp : fir_OneResultOp<"absent", [NoSideEffect]> {

flang/lib/Optimizer/Dialect/FIROps.cpp

void fir::AllocaOp::build(mlir::OpBuilder &builder,
                           bool pinned, mlir::ValueRange typeparams,
                           mlir::ValueRange shape,
                           llvm::ArrayRef<mlir::NamedAttribute> attributes) {
   build(builder, result, wrapAllocaResultType(inType), inType, {}, {}, pinned,
         typeparams, shape);
   result.addAttributes(attributes);
 }
 
-static mlir::LogicalResult verify(fir::AllocaOp &op) {
+mlir::ParseResult fir::AllocaOp::parse(OpAsmParser &parser,
+                                       OperationState &result) {
+  return parseAllocatableOp(wrapAllocaResultType, parser, result);
+}
+
+void fir::AllocaOp::print(OpAsmPrinter &p) { printAllocatableOp(p, *this); }
+
+mlir::LogicalResult fir::AllocaOp::verify() {
   llvm::SmallVector<llvm::StringRef> visited;
-  if (verifyInType(op.getInType(), visited, op.numShapeOperands()))
-    return op.emitOpError("invalid type for allocation");
-  if (verifyTypeParamCount(op.getInType(), op.numLenParams()))
-    return op.emitOpError("LEN params do not correspond to type");
-  mlir::Type outType = op.getType();
+  if (verifyInType(getInType(), visited, numShapeOperands()))
+    return emitOpError("invalid type for allocation");
+  if (verifyTypeParamCount(getInType(), numLenParams()))
+    return emitOpError("LEN params do not correspond to type");
+  mlir::Type outType = getType();
   if (!outType.isa<fir::ReferenceType>())
-    return op.emitOpError("must be a !fir.ref type");
+    return emitOpError("must be a !fir.ref type");
   if (fir::isa_unknown_size_box(fir::dyn_cast_ptrEleTy(outType)))
-    return op.emitOpError("cannot allocate !fir.box of unknown rank or type");
+    return emitOpError("cannot allocate !fir.box of unknown rank or type");
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // AllocMemOp
 //===----------------------------------------------------------------------===//
 
 /// Create a legal heap reference as return type
void fir::AllocMemOp::build(mlir::OpBuilder &builder,
                             mlir::OperationState &result, mlir::Type inType,
                             mlir::ValueRange typeparams, mlir::ValueRange shape,
                             llvm::ArrayRef<mlir::NamedAttribute> attributes) {
   build(builder, result, wrapAllocMemResultType(inType), inType, {}, {},
         typeparams, shape);
   result.addAttributes(attributes);
 }
 
-static mlir::LogicalResult verify(fir::AllocMemOp op) {
+mlir::ParseResult AllocMemOp::parse(OpAsmParser &parser,
+                                    OperationState &result) {
+  return parseAllocatableOp(wrapAllocMemResultType, parser, result);
+}
+
+void AllocMemOp::print(OpAsmPrinter &p) { printAllocatableOp(p, *this); }
+
+mlir::LogicalResult AllocMemOp::verify() {
   llvm::SmallVector<llvm::StringRef> visited;
-  if (verifyInType(op.getInType(), visited, op.numShapeOperands()))
-    return op.emitOpError("invalid type for allocation");
-  if (verifyTypeParamCount(op.getInType(), op.numLenParams()))
-    return op.emitOpError("LEN params do not correspond to type");
-  mlir::Type outType = op.getType();
+  if (verifyInType(getInType(), visited, numShapeOperands()))
+    return emitOpError("invalid type for allocation");
+  if (verifyTypeParamCount(getInType(), numLenParams()))
+    return emitOpError("LEN params do not correspond to type");
+  mlir::Type outType = getType();
   if (!outType.dyn_cast<fir::HeapType>())
-    return op.emitOpError("must be a !fir.heap type");
+    return emitOpError("must be a !fir.heap type");
   if (fir::isa_unknown_size_box(fir::dyn_cast_ptrEleTy(outType)))
-    return op.emitOpError("cannot allocate !fir.box of unknown rank or type");
+    return emitOpError("cannot allocate !fir.box of unknown rank or type");
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // ArrayCoorOp
 //===----------------------------------------------------------------------===//
 
-static mlir::LogicalResult verify(fir::ArrayCoorOp op) {
-  auto eleTy = fir::dyn_cast_ptrOrBoxEleTy(op.memref().getType());
+mlir::LogicalResult ArrayCoorOp::verify() {
+  auto eleTy = fir::dyn_cast_ptrOrBoxEleTy(memref().getType());
   auto arrTy = eleTy.dyn_cast<fir::SequenceType>();
   if (!arrTy)
-    return op.emitOpError("must be a reference to an array");
+    return emitOpError("must be a reference to an array");
   auto arrDim = arrTy.getDimension();
 
-  if (auto shapeOp = op.shape()) {
+  if (auto shapeOp = shape()) {
     auto shapeTy = shapeOp.getType();
     unsigned shapeTyRank = 0;
     if (auto s = shapeTy.dyn_cast<fir::ShapeType>()) {
       shapeTyRank = s.getRank();
     } else if (auto ss = shapeTy.dyn_cast<fir::ShapeShiftType>()) {
       shapeTyRank = ss.getRank();
     } else {
       auto s = shapeTy.cast<fir::ShiftType>();
       shapeTyRank = s.getRank();
-      if (!op.memref().getType().isa<fir::BoxType>())
-        return op.emitOpError("shift can only be provided with fir.box memref");
+      if (!memref().getType().isa<fir::BoxType>())
+        return emitOpError("shift can only be provided with fir.box memref");
     }
     if (arrDim && arrDim != shapeTyRank)
-      return op.emitOpError("rank of dimension mismatched");
-    if (shapeTyRank != op.indices().size())
-      return op.emitOpError("number of indices do not match dim rank");
+      return emitOpError("rank of dimension mismatched");
+    if (shapeTyRank != indices().size())
+      return emitOpError("number of indices do not match dim rank");
   }
 
-  if (auto sliceOp = op.slice()) {
+  if (auto sliceOp = slice()) {
     if (auto sl = mlir::dyn_cast_or_null<fir::SliceOp>(sliceOp.getDefiningOp()))
       if (!sl.substr().empty())
-        return op.emitOpError("array_coor cannot take a slice with substring");
+        return emitOpError("array_coor cannot take a slice with substring");
     if (auto sliceTy = sliceOp.getType().dyn_cast<fir::SliceType>())
       if (sliceTy.getRank() != arrDim)
-        return op.emitOpError("rank of dimension in slice mismatched");
+        return emitOpError("rank of dimension in slice mismatched");
   }
 
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // ArrayLoadOp
 //===----------------------------------------------------------------------===//
if (auto *op = sh.getDefiningOp()) {
         auto extents = shOp.getExtents();
         return {extents.begin(), extents.end()};
       }
       return cast<fir::ShapeShiftOp>(op).getExtents();
     }
   return {};
 }
 
-static mlir::LogicalResult verify(fir::ArrayLoadOp op) {
-  auto eleTy = fir::dyn_cast_ptrOrBoxEleTy(op.memref().getType());
+mlir::LogicalResult ArrayLoadOp::verify() {
+  auto eleTy = fir::dyn_cast_ptrOrBoxEleTy(memref().getType());
   auto arrTy = eleTy.dyn_cast<fir::SequenceType>();
   if (!arrTy)
-    return op.emitOpError("must be a reference to an array");
+    return emitOpError("must be a reference to an array");
   auto arrDim = arrTy.getDimension();
 
-  if (auto shapeOp = op.shape()) {
+  if (auto shapeOp = shape()) {
     auto shapeTy = shapeOp.getType();
     unsigned shapeTyRank = 0;
     if (auto s = shapeTy.dyn_cast<fir::ShapeType>()) {
       shapeTyRank = s.getRank();
     } else if (auto ss = shapeTy.dyn_cast<fir::ShapeShiftType>()) {
       shapeTyRank = ss.getRank();
     } else {
       auto s = shapeTy.cast<fir::ShiftType>();
       shapeTyRank = s.getRank();
-      if (!op.memref().getType().isa<fir::BoxType>())
-        return op.emitOpError("shift can only be provided with fir.box memref");
+      if (!memref().getType().isa<fir::BoxType>())
+        return emitOpError("shift can only be provided with fir.box memref");
     }
     if (arrDim && arrDim != shapeTyRank)
-      return op.emitOpError("rank of dimension mismatched");
+      return emitOpError("rank of dimension mismatched");
   }
 
-  if (auto sliceOp = op.slice()) {
+  if (auto sliceOp = slice()) {
     if (auto sl = mlir::dyn_cast_or_null<fir::SliceOp>(sliceOp.getDefiningOp()))
       if (!sl.substr().empty())
-        return op.emitOpError("array_load cannot take a slice with substring");
+        return emitOpError("array_load cannot take a slice with substring");
     if (auto sliceTy = sliceOp.getType().dyn_cast<fir::SliceType>())
       if (sliceTy.getRank() != arrDim)
-        return op.emitOpError("rank of dimension in slice mismatched");
+        return emitOpError("rank of dimension in slice mismatched");
   }
 
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // ArrayMergeStoreOp
 //===----------------------------------------------------------------------===//
 
-static mlir::LogicalResult verify(fir::ArrayMergeStoreOp op) {
-  if (!isa<ArrayLoadOp>(op.original().getDefiningOp()))
-    return op.emitOpError("operand #0 must be result of a fir.array_load op");
-  if (auto sl = op.slice()) {
+mlir::LogicalResult ArrayMergeStoreOp::verify() {
+  if (!isa<ArrayLoadOp>(original().getDefiningOp()))
+    return emitOpError("operand #0 must be result of a fir.array_load op");
+  if (auto sl = slice()) {
     if (auto sliceOp =
             mlir::dyn_cast_or_null<fir::SliceOp>(sl.getDefiningOp())) {
       if (!sliceOp.substr().empty())
-        return op.emitOpError(
+        return emitOpError(
             "array_merge_store cannot take a slice with substring");
       if (!sliceOp.fields().empty()) {
         // This is an intra-object merge, where the slice is projecting the
         // subfields that are to be overwritten by the merge operation.
-        auto eleTy = fir::dyn_cast_ptrOrBoxEleTy(op.memref().getType());
+        auto eleTy = fir::dyn_cast_ptrOrBoxEleTy(memref().getType());
         if (auto seqTy = eleTy.dyn_cast<fir::SequenceType>()) {
           auto projTy =
               fir::applyPathToType(seqTy.getEleTy(), sliceOp.fields());
-          if (fir::unwrapSequenceType(op.original().getType()) != projTy)
-            return op.emitOpError(
+          if (fir::unwrapSequenceType(original().getType()) != projTy)
+            return emitOpError(
                 "type of origin does not match sliced memref type");
-          if (fir::unwrapSequenceType(op.sequence().getType()) != projTy)
-            return op.emitOpError(
+          if (fir::unwrapSequenceType(sequence().getType()) != projTy)
+            return emitOpError(
                 "type of sequence does not match sliced memref type");
           return mlir::success();
         }
-        return op.emitOpError("referenced type is not an array");
+        return emitOpError("referenced type is not an array");
       }
     }
     return mlir::success();
   }
-  auto eleTy = fir::dyn_cast_ptrOrBoxEleTy(op.memref().getType());
-  if (op.original().getType() != eleTy)
-    return op.emitOpError("type of origin does not match memref element type");
-  if (op.sequence().getType() != eleTy)
-    return op.emitOpError(
-        "type of sequence does not match memref element type");
+  auto eleTy = fir::dyn_cast_ptrOrBoxEleTy(memref().getType());
+  if (original().getType() != eleTy)
+    return emitOpError("type of origin does not match memref element type");
+  if (sequence().getType() != eleTy)
+    return emitOpError("type of sequence does not match memref element type");
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // ArrayFetchOp
 //===----------------------------------------------------------------------===//
 
 // Template function used for both array_fetch and array_update verification.
 template <typename A>
 mlir::Type validArraySubobject(A op) {
   auto ty = op.sequence().getType();
   return fir::applyPathToType(ty, op.indices());
 }
 
-static mlir::LogicalResult verify(fir::ArrayFetchOp op) {
-  auto arrTy = op.sequence().getType().cast<fir::SequenceType>();
-  auto indSize = op.indices().size();
+mlir::LogicalResult ArrayFetchOp::verify() {
+  auto arrTy = sequence().getType().cast<fir::SequenceType>();
+  auto indSize = indices().size();
   if (indSize < arrTy.getDimension())
-    return op.emitOpError("number of indices != dimension of array");
+    return emitOpError("number of indices != dimension of array");
   if (indSize == arrTy.getDimension() &&
-      ::adjustedElementType(op.element().getType()) != arrTy.getEleTy())
-    return op.emitOpError("return type does not match array");
-  auto ty = validArraySubobject(op);
-  if (!ty || ty != ::adjustedElementType(op.getType()))
-    return op.emitOpError("return type and/or indices do not type check");
-  if (!isa<fir::ArrayLoadOp>(op.sequence().getDefiningOp()))
-    return op.emitOpError("argument #0 must be result of fir.array_load");
+      ::adjustedElementType(element().getType()) != arrTy.getEleTy())
+    return emitOpError("return type does not match array");
+  auto ty = validArraySubobject(*this);
+  if (!ty || ty != ::adjustedElementType(getType()))
+    return emitOpError("return type and/or indices do not type check");
+  if (!isa<fir::ArrayLoadOp>(sequence().getDefiningOp()))
+    return emitOpError("argument #0 must be result of fir.array_load");
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // ArrayAccessOp
 //===----------------------------------------------------------------------===//
 
-static mlir::LogicalResult verify(fir::ArrayAccessOp op) {
-  auto arrTy = op.sequence().getType().cast<fir::SequenceType>();
-  std::size_t indSize = op.indices().size();
+mlir::LogicalResult ArrayAccessOp::verify() {
+  auto arrTy = sequence().getType().cast<fir::SequenceType>();
+  std::size_t indSize = indices().size();
   if (indSize < arrTy.getDimension())
-    return op.emitOpError("number of indices != dimension of array");
+    return emitOpError("number of indices != dimension of array");
   if (indSize == arrTy.getDimension() &&
-      op.element().getType() != fir::ReferenceType::get(arrTy.getEleTy()))
-    return op.emitOpError("return type does not match array");
-  mlir::Type ty = validArraySubobject(op);
-  if (!ty || fir::ReferenceType::get(ty) != op.getType())
-    return op.emitOpError("return type and/or indices do not type check");
+      element().getType() != fir::ReferenceType::get(arrTy.getEleTy()))
+    return emitOpError("return type does not match array");
+  mlir::Type ty = validArraySubobject(*this);
+  if (!ty || fir::ReferenceType::get(ty) != getType())
+    return emitOpError("return type and/or indices do not type check");
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // ArrayUpdateOp
 //===----------------------------------------------------------------------===//
 
-static mlir::LogicalResult verify(fir::ArrayUpdateOp op) {
-  if (fir::isa_ref_type(op.merge().getType()))
-    return op.emitOpError("does not support reference type for merge");
-  auto arrTy = op.sequence().getType().cast<fir::SequenceType>();
-  auto indSize = op.indices().size();
+mlir::LogicalResult ArrayUpdateOp::verify() {
+  if (fir::isa_ref_type(merge().getType()))
+    return emitOpError("does not support reference type for merge");
+  auto arrTy = sequence().getType().cast<fir::SequenceType>();
+  auto indSize = indices().size();
   if (indSize < arrTy.getDimension())
-    return op.emitOpError("number of indices != dimension of array");
+    return emitOpError("number of indices != dimension of array");
   if (indSize == arrTy.getDimension() &&
-      ::adjustedElementType(op.merge().getType()) != arrTy.getEleTy())
-    return op.emitOpError("merged value does not have element type");
-  auto ty = validArraySubobject(op);
-  if (!ty || ty != ::adjustedElementType(op.merge().getType()))
-    return op.emitOpError("merged value and/or indices do not type check");
+      ::adjustedElementType(merge().getType()) != arrTy.getEleTy())
+    return emitOpError("merged value does not have element type");
+  auto ty = validArraySubobject(*this);
+  if (!ty || ty != ::adjustedElementType(merge().getType()))
+    return emitOpError("merged value and/or indices do not type check");
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // ArrayModifyOp
 //===----------------------------------------------------------------------===//
 
-static mlir::LogicalResult verify(fir::ArrayModifyOp op) {
-  auto arrTy = op.sequence().getType().cast<fir::SequenceType>();
-  auto indSize = op.indices().size();
+mlir::LogicalResult ArrayModifyOp::verify() {
+  auto arrTy = sequence().getType().cast<fir::SequenceType>();
+  auto indSize = indices().size();
   if (indSize < arrTy.getDimension())
-    return op.emitOpError("number of indices must match array dimension");
+    return emitOpError("number of indices must match array dimension");
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // BoxAddrOp
 //===----------------------------------------------------------------------===//
 
 mlir::OpFoldResult fir::BoxAddrOp::fold(llvm::ArrayRef<mlir::Attribute> opnds) {

 // CallOp
 //===----------------------------------------------------------------------===//
 
 mlir::FunctionType fir::CallOp::getFunctionType() {
   return mlir::FunctionType::get(getContext(), getOperandTypes(),
                                  getResultTypes());
 }
 
-static void printCallOp(mlir::OpAsmPrinter &p, fir::CallOp &op) {
-  auto callee = op.callee();
-  bool isDirect = callee.hasValue();
+void fir::CallOp::print(mlir::OpAsmPrinter &p) {
+  bool isDirect = callee().hasValue();
   p << ' ';
   if (isDirect)
-    p << callee.getValue();
+    p << callee().getValue();
   else
-    p << op.getOperand(0);
-  p << '(' << op->getOperands().drop_front(isDirect ? 0 : 1) << ')';
-  p.printOptionalAttrDict(op->getAttrs(),
+    p << getOperand(0);
+  p << '(' << (*this)->getOperands().drop_front(isDirect ? 0 : 1) << ')';
+  p.printOptionalAttrDict((*this)->getAttrs(),
                           {fir::CallOp::getCalleeAttrNameStr()});
-  auto resultTypes{op.getResultTypes()};
+  auto resultTypes{getResultTypes()};
   llvm::SmallVector<Type> argTypes(
-      llvm::drop_begin(op.getOperandTypes(), isDirect ? 0 : 1));
-  p << " : " << FunctionType::get(op.getContext(), argTypes, resultTypes);
+      llvm::drop_begin(getOperandTypes(), isDirect ? 0 : 1));
+  p << " : " << FunctionType::get(getContext(), argTypes, resultTypes);
 }
 
-static mlir::ParseResult parseCallOp(mlir::OpAsmParser &parser,
+mlir::ParseResult fir::CallOp::parse(mlir::OpAsmParser &parser,
                                      mlir::OperationState &result) {
   llvm::SmallVector<mlir::OpAsmParser::OperandType> operands;
   if (parser.parseOperandList(operands))
     return mlir::failure();
 
   mlir::NamedAttrList attrs;
   mlir::SymbolRefAttr funcAttr;
   bool isDirect = operands.empty();
static mlir::ParseResult parseCmpOp(mlir::OpAsmParser &parser,
   result.addTypes({i1Type});
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // CharConvertOp
 //===----------------------------------------------------------------------===//
 
-static mlir::LogicalResult verify(fir::CharConvertOp op) {
+mlir::LogicalResult CharConvertOp::verify() {
   auto unwrap = [&](mlir::Type t) {
     t = fir::unwrapSequenceType(fir::dyn_cast_ptrEleTy(t));
     return t.dyn_cast<fir::CharacterType>();
   };
-  auto inTy = unwrap(op.from().getType());
-  auto outTy = unwrap(op.to().getType());
+  auto inTy = unwrap(from().getType());
+  auto outTy = unwrap(to().getType());
   if (!(inTy && outTy))
-    return op.emitOpError("not a reference to a character");
+    return emitOpError("not a reference to a character");
   if (inTy.getFKind() == outTy.getFKind())
-    return op.emitOpError("buffers must have different KIND values");
+    return emitOpError("buffers must have different KIND values");
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // CmpcOp
 //===----------------------------------------------------------------------===//
 
 void fir::buildCmpCOp(OpBuilder &builder, OperationState &result,
                       arith::CmpFPredicate predicate, Value lhs, Value rhs) {
   result.addOperands({lhs, rhs});
   result.types.push_back(builder.getI1Type());
   result.addAttribute(
       fir::CmpcOp::getPredicateAttrName(),
       builder.getI64IntegerAttr(static_cast<int64_t>(predicate)));
 }
 
 mlir::arith::CmpFPredicate
 fir::CmpcOp::getPredicateByName(llvm::StringRef name) {
   auto pred = mlir::arith::symbolizeCmpFPredicate(name);
   assert(pred.hasValue() && "invalid predicate name");
   return pred.getValue();
 }
 
-static void printCmpcOp(OpAsmPrinter &p, fir::CmpcOp op) { printCmpOp(p, op); }
+void CmpcOp::print(OpAsmPrinter &p) { printCmpOp(p, *this); }
 
-mlir::ParseResult fir::parseCmpcOp(mlir::OpAsmParser &parser,
-                                   mlir::OperationState &result) {
+mlir::ParseResult CmpcOp::parse(mlir::OpAsmParser &parser,
   return parseCmpOp<fir::CmpcOp>(parser, result);
 }
 
 //===----------------------------------------------------------------------===//
 // ConstcOp
 //===----------------------------------------------------------------------===//
 
-static mlir::ParseResult parseConstcOp(mlir::OpAsmParser &parser,
-                                       mlir::OperationState &result) {
+mlir::ParseResult ConstcOp::parse(mlir::OpAsmParser &parser,
   fir::RealAttr realp;
   fir::RealAttr imagp;
   mlir::Type type;
   if (parser.parseLParen() ||
       parser.parseAttribute(realp, fir::ConstcOp::realAttrName(),
                             result.attributes) ||
       parser.parseComma() ||
       parser.parseAttribute(imagp, fir::ConstcOp::imagAttrName(),
                             result.attributes) ||
       parser.parseRParen() || parser.parseColonType(type) ||
       parser.addTypesToList(type, result.types))
     return mlir::failure();
   return mlir::success();
 }
 
-static void print(mlir::OpAsmPrinter &p, fir::ConstcOp &op) {
+void ConstcOp::print(mlir::OpAsmPrinter &p) {
   p << '(';
-  p << op.getOperation()->getAttr(fir::ConstcOp::realAttrName()) << ", ";
-  p << op.getOperation()->getAttr(fir::ConstcOp::imagAttrName()) << ") : ";
-  p.printType(op.getType());
+  p << getOperation()->getAttr(fir::ConstcOp::realAttrName()) << ", ";
+  p << getOperation()->getAttr(fir::ConstcOp::imagAttrName()) << ") : ";
+  p.printType(getType());
 }
 
-static mlir::LogicalResult verify(fir::ConstcOp &op) {
-  if (!op.getType().isa<fir::ComplexType>())
-    return op.emitOpError("must be a !fir.complex type");
+mlir::LogicalResult ConstcOp::verify() {
+  if (!getType().isa<fir::ComplexType>())
+    return emitOpError("must be a !fir.complex type");
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // ConvertOp
 //===----------------------------------------------------------------------===//
 
 void fir::ConvertOp::getCanonicalizationPatterns(RewritePatternSet &results,

 
 bool fir::ConvertOp::isPointerCompatible(mlir::Type ty) {
   return ty.isa<fir::ReferenceType>() || ty.isa<fir::PointerType>() ||
          ty.isa<fir::HeapType>() || ty.isa<fir::LLVMPointerType>() ||
          ty.isa<mlir::MemRefType>() || ty.isa<mlir::FunctionType>() ||
          ty.isa<fir::TypeDescType>();
 }
 
-static mlir::LogicalResult verify(fir::ConvertOp &op) {
-  auto inType = op.value().getType();
-  auto outType = op.getType();
+mlir::LogicalResult ConvertOp::verify() {
+  auto inType = value().getType();
+  auto outType = getType();
   if (inType == outType)
     return mlir::success();
-  if ((op.isPointerCompatible(inType) && op.isPointerCompatible(outType)) ||
-      (op.isIntegerCompatible(inType) && op.isIntegerCompatible(outType)) ||
-      (op.isIntegerCompatible(inType) && op.isFloatCompatible(outType)) ||
-      (op.isFloatCompatible(inType) && op.isIntegerCompatible(outType)) ||
-      (op.isFloatCompatible(inType) && op.isFloatCompatible(outType)) ||
-      (op.isIntegerCompatible(inType) && op.isPointerCompatible(outType)) ||
-      (op.isPointerCompatible(inType) && op.isIntegerCompatible(outType)) ||
+  if ((isPointerCompatible(inType) && isPointerCompatible(outType)) ||
+      (isIntegerCompatible(inType) && isIntegerCompatible(outType)) ||
+      (isIntegerCompatible(inType) && isFloatCompatible(outType)) ||
+      (isFloatCompatible(inType) && isIntegerCompatible(outType)) ||
+      (isFloatCompatible(inType) && isFloatCompatible(outType)) ||
+      (isIntegerCompatible(inType) && isPointerCompatible(outType)) ||
+      (isPointerCompatible(inType) && isIntegerCompatible(outType)) ||
       (inType.isa<fir::BoxType>() && outType.isa<fir::BoxType>()) ||
       (fir::isa_complex(inType) && fir::isa_complex(outType)))
     return mlir::success();
-  return op.emitOpError("invalid type conversion");
+  return emitOpError("invalid type conversion");
 }
 
 //===----------------------------------------------------------------------===//
 // CoordinateOp
 //===----------------------------------------------------------------------===//
 
-static void print(mlir::OpAsmPrinter &p, fir::CoordinateOp op) {
-  p << ' ' << op.ref() << ", " << op.coor();
-  p.printOptionalAttrDict(op->getAttrs(), /*elideAttrs=*/{"baseType"});
+void CoordinateOp::print(mlir::OpAsmPrinter &p) {
+  p << ' ' << ref() << ", " << coor();
+  p.printOptionalAttrDict((*this)->getAttrs(), /*elideAttrs=*/{"baseType"});
   p << " : ";
-  p.printFunctionalType(op.getOperandTypes(), op->getResultTypes());
+  p.printFunctionalType(getOperandTypes(), (*this)->getResultTypes());
 }
 
-static mlir::ParseResult parseCoordinateCustom(mlir::OpAsmParser &parser,
-                                               mlir::OperationState &result) {
+mlir::ParseResult CoordinateOp::parse(mlir::OpAsmParser &parser,
   mlir::OpAsmParser::OperandType memref;
   if (parser.parseOperand(memref) || parser.parseComma())
     return mlir::failure();
   llvm::SmallVector<mlir::OpAsmParser::OperandType> coorOperands;
   if (parser.parseOperandList(coorOperands))
     return mlir::failure();
   llvm::SmallVector<mlir::OpAsmParser::OperandType> allOperands;
   allOperands.push_back(memref);
   allOperands.append(coorOperands.begin(), coorOperands.end());
   mlir::FunctionType funcTy;
   auto loc = parser.getCurrentLocation();
   if (parser.parseOptionalAttrDict(result.attributes) ||
       parser.parseColonType(funcTy) ||
       parser.resolveOperands(allOperands, funcTy.getInputs(), loc,
                              result.operands))
     return failure();
   parser.addTypesToList(funcTy.getResults(), result.types);
   result.addAttribute("baseType", mlir::TypeAttr::get(funcTy.getInput(0)));
   return mlir::success();
 }
 
-static mlir::LogicalResult verify(fir::CoordinateOp op) {
-  auto refTy = op.ref().getType();
+mlir::LogicalResult CoordinateOp::verify() {
+  auto refTy = ref().getType();
   if (fir::isa_ref_type(refTy)) {
     auto eleTy = fir::dyn_cast_ptrEleTy(refTy);
     if (auto arrTy = eleTy.dyn_cast<fir::SequenceType>()) {
       if (arrTy.hasUnknownShape())
-        return op.emitOpError("cannot find coordinate in unknown shape");
+        return emitOpError("cannot find coordinate in unknown shape");
       if (arrTy.getConstantRows() < arrTy.getDimension() - 1)
-        return op.emitOpError("cannot find coordinate with unknown extents");
+        return emitOpError("cannot find coordinate with unknown extents");
     }
     if (!(fir::isa_aggregate(eleTy) || fir::isa_complex(eleTy) ||
           fir::isa_char_string(eleTy)))
-      return op.emitOpError("cannot apply coordinate_of to this type");
+      return emitOpError("cannot apply coordinate_of to this type");
   }
   // Recovering a LEN type parameter only makes sense from a boxed value. For a
   // bare reference, the LEN type parameters must be passed as additional
   // arguments to `op`.
-  for (auto co : op.coor())
+  for (auto co : coor())
     if (dyn_cast_or_null<fir::LenParamIndexOp>(co.getDefiningOp())) {
-      if (op.getNumOperands() != 2)
-        return op.emitOpError("len_param_index must be last argument");
-      if (!op.ref().getType().isa<BoxType>())
-        return op.emitOpError("len_param_index must be used on box type");
+      if (getNumOperands() != 2)
+        return emitOpError("len_param_index must be last argument");
+      if (!ref().getType().isa<BoxType>())
+        return emitOpError("len_param_index must be used on box type");
     }
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // DispatchOp
 //===----------------------------------------------------------------------===//
 
 mlir::FunctionType fir::DispatchOp::getFunctionType() {
   return mlir::FunctionType::get(getContext(), getOperandTypes(),
                                  getResultTypes());
 }
 
-static mlir::ParseResult parseDispatchOp(mlir::OpAsmParser &parser,
-                                         mlir::OperationState &result) {
+mlir::ParseResult DispatchOp::parse(mlir::OpAsmParser &parser,
   mlir::FunctionType calleeType;
   llvm::SmallVector<mlir::OpAsmParser::OperandType> operands;
   auto calleeLoc = parser.getNameLoc();
   llvm::StringRef calleeName;
   if (failed(parser.parseOptionalKeyword(&calleeName))) {
     mlir::StringAttr calleeAttr;
     if (parser.parseAttribute(calleeAttr,
                               fir::DispatchOp::getMethodAttrNameStr(),
                               result.attributes))
       return mlir::failure();
   } else {
     result.addAttribute(fir::DispatchOp::getMethodAttrNameStr(),
                         parser.getBuilder().getStringAttr(calleeName));
   }
   if (parser.parseOperandList(operands, mlir::OpAsmParser::Delimiter::Paren) ||
       parser.parseOptionalAttrDict(result.attributes) ||
       parser.parseColonType(calleeType) ||
       parser.addTypesToList(calleeType.getResults(), result.types) ||
       parser.resolveOperands(operands, calleeType.getInputs(), calleeLoc,
                              result.operands))
     return mlir::failure();
   return mlir::success();
 }
 
-static void print(mlir::OpAsmPrinter &p, fir::DispatchOp &op) {
-  p << ' ' << op.getMethodAttr() << '(';
-  p.printOperand(op.object());
-  if (!op.args().empty()) {
+void DispatchOp::print(mlir::OpAsmPrinter &p) {
+  p << ' ' << getMethodAttr() << '(';
+  p.printOperand(object());
+  if (!args().empty()) {
     p << ", ";
-    p.printOperands(op.args());
+    p.printOperands(args());
   }
   p << ") : ";
-  p.printFunctionalType(op.getOperation()->getOperandTypes(),
-                        op.getOperation()->getResultTypes());
+  p.printFunctionalType(getOperation()->getOperandTypes(),
+                        getOperation()->getResultTypes());
 }
 
 //===----------------------------------------------------------------------===//
 // DispatchTableOp
 //===----------------------------------------------------------------------===//
 
 void fir::DispatchTableOp::appendTableEntry(mlir::Operation *op) {
   assert(mlir::isa<fir::DTEntryOp>(*op) && "operation must be a DTEntryOp");
   auto &block = getBlock();
   block.getOperations().insert(block.end(), op);
 }
 
-static mlir::ParseResult parseDispatchTableOp(mlir::OpAsmParser &parser,
-                                              mlir::OperationState &result) {
+mlir::ParseResult DispatchTableOp::parse(mlir::OpAsmParser &parser,
   // Parse the name as a symbol reference attribute.
   SymbolRefAttr nameAttr;
   if (parser.parseAttribute(nameAttr, mlir::SymbolTable::getSymbolAttrName(),
                             result.attributes))
     return failure();
 
   // Convert the parsed name attr into a string attr.
   result.attributes.set(mlir::SymbolTable::getSymbolAttrName(),
                         nameAttr.getRootReference());
 
   // Parse the optional table body.
   mlir::Region *body = result.addRegion();
   OptionalParseResult parseResult = parser.parseOptionalRegion(*body);
   if (parseResult.hasValue() && failed(*parseResult))
     return mlir::failure();
 
   fir::DispatchTableOp::ensureTerminator(*body, parser.getBuilder(),
                                          result.location);
   return mlir::success();
 }
 
-static void print(mlir::OpAsmPrinter &p, fir::DispatchTableOp &op) {
+void DispatchTableOp::print(mlir::OpAsmPrinter &p) {
   auto tableName =
-      op.getOperation()
+      getOperation()
           ->getAttrOfType<StringAttr>(mlir::SymbolTable::getSymbolAttrName())
           .getValue();
   p << " @" << tableName;
 
-  Region &body = op.getOperation()->getRegion(0);
+  Region &body = getOperation()->getRegion(0);
   if (!body.empty()) {
     p << ' ';
     p.printRegion(body, /*printEntryBlockArgs=*/false,
                   /*printBlockTerminators=*/false);
   }
 }
 
-static mlir::LogicalResult verify(fir::DispatchTableOp &op) {
-  for (auto &op : op.getBlock())
+mlir::LogicalResult DispatchTableOp::verify() {
+  for (auto &op : getBlock())
     if (!(isa<fir::DTEntryOp>(op) || isa<fir::FirEndOp>(op)))
       return op.emitOpError("dispatch table must contain dt_entry");
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // EmboxOp
 //===----------------------------------------------------------------------===//
 
-static mlir::LogicalResult verify(fir::EmboxOp op) {
-  auto eleTy = fir::dyn_cast_ptrEleTy(op.memref().getType());
+mlir::LogicalResult EmboxOp::verify() {
+  auto eleTy = fir::dyn_cast_ptrEleTy(memref().getType());
   bool isArray = false;
   if (auto seqTy = eleTy.dyn_cast<fir::SequenceType>()) {
     eleTy = seqTy.getEleTy();
     isArray = true;
   }
-  if (op.hasLenParams()) {
-    auto lenPs = op.numLenParams();
+  if (hasLenParams()) {
+    auto lenPs = numLenParams();
     if (auto rt = eleTy.dyn_cast<fir::RecordType>()) {
       if (lenPs != rt.getNumLenParams())
-        return op.emitOpError("number of LEN params does not correspond"
-                              " to the !fir.type type");
+        return emitOpError("number of LEN params does not correspond"
     } else if (auto strTy = eleTy.dyn_cast<fir::CharacterType>()) {
       if (strTy.getLen() != fir::CharacterType::unknownLen())
-        return op.emitOpError("CHARACTER already has static LEN");
+        return emitOpError("CHARACTER already has static LEN");
     } else {
-      return op.emitOpError("LEN parameters require CHARACTER or derived type");
+      return emitOpError("LEN parameters require CHARACTER or derived type");
     }
-    for (auto lp : op.typeparams())
+    for (auto lp : typeparams())
       if (!fir::isa_integer(lp.getType()))
-        return op.emitOpError("LEN parameters must be integral type");
+        return emitOpError("LEN parameters must be integral type");
   }
-  if (op.getShape() && !isArray)
-    return op.emitOpError("shape must not be provided for a scalar");
-  if (op.getSlice() && !isArray)
-    return op.emitOpError("slice must not be provided for a scalar");
+  if (getShape() && !isArray)
+    return emitOpError("shape must not be provided for a scalar");
+  if (getSlice() && !isArray)
+    return emitOpError("slice must not be provided for a scalar");
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // EmboxCharOp
 //===----------------------------------------------------------------------===//
 
-static mlir::LogicalResult verify(fir::EmboxCharOp &op) {
-  auto eleTy = fir::dyn_cast_ptrEleTy(op.memref().getType());
+mlir::LogicalResult EmboxCharOp::verify() {
+  auto eleTy = fir::dyn_cast_ptrEleTy(memref().getType());
   if (!eleTy.dyn_cast_or_null<CharacterType>())
     return mlir::failure();
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // EmboxProcOp
 //===----------------------------------------------------------------------===//
 
-static mlir::ParseResult parseEmboxProcOp(mlir::OpAsmParser &parser,
-                                          mlir::OperationState &result) {
+mlir::ParseResult EmboxProcOp::parse(mlir::OpAsmParser &parser,
   mlir::SymbolRefAttr procRef;
   if (parser.parseAttribute(procRef, "funcname", result.attributes))
     return mlir::failure();
   bool hasTuple = false;
   mlir::OpAsmParser::OperandType tupleRef;
   if (!parser.parseOptionalComma()) {
     if (parser.parseOperand(tupleRef))
       return mlir::failure();
mlir::ParseResult EmboxProcOp::parse(mlir::OpAsmParser &parser,
   }
   mlir::Type boxType;
   if (parser.parseRParen() || parser.parseArrow() ||
       parser.parseType(boxType) || parser.addTypesToList(boxType, result.types))
     return mlir::failure();
   return mlir::success();
 }
 
-static void print(mlir::OpAsmPrinter &p, fir::EmboxProcOp &op) {
-  p << ' ' << op.getOperation()->getAttr("funcname");
-  auto h = op.host();
+void EmboxProcOp::print(mlir::OpAsmPrinter &p) {
+  p << ' ' << getOperation()->getAttr("funcname");
+  auto h = host();
   if (h) {
     p << ", ";
     p.printOperand(h);
   }
-  p << " : (" << op.getOperation()->getAttr("functype");
+  p << " : (" << getOperation()->getAttr("functype");
   if (h)
     p << ", " << h.getType();
-  p << ") -> " << op.getType();
+  p << ") -> " << getType();
 }
 
-static mlir::LogicalResult verify(fir::EmboxProcOp &op) {
+mlir::LogicalResult EmboxProcOp::verify() {
   // host bindings (optional) must be a reference to a tuple
-  if (auto h = op.host()) {
+  if (auto h = host()) {
     if (auto r = h.getType().dyn_cast<ReferenceType>()) {
       if (!r.getEleTy().dyn_cast<mlir::TupleType>())
         return mlir::failure();
     } else {
       return mlir::failure();
     }
   }
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // GenTypeDescOp
 //===----------------------------------------------------------------------===//
 
 void fir::GenTypeDescOp::build(OpBuilder &, OperationState &result,
                                mlir::TypeAttr inty) {
   result.addAttribute("in_type", inty);
   result.addTypes(TypeDescType::get(inty.getValue()));
 }
 
-static mlir::ParseResult parseGenTypeDescOp(mlir::OpAsmParser &parser,
-                                            mlir::OperationState &result) {
+mlir::ParseResult GenTypeDescOp::parse(mlir::OpAsmParser &parser,
   mlir::Type intype;
   if (parser.parseType(intype))
     return mlir::failure();
   result.addAttribute("in_type", mlir::TypeAttr::get(intype));
   mlir::Type restype = TypeDescType::get(intype);
   if (parser.addTypeToList(restype, result.types))
     return mlir::failure();
   return mlir::success();
 }
 
-static void print(mlir::OpAsmPrinter &p, fir::GenTypeDescOp &op) {
-  p << ' ' << op.getOperation()->getAttr("in_type");
-  p.printOptionalAttrDict(op.getOperation()->getAttrs(), {"in_type"});
+void GenTypeDescOp::print(mlir::OpAsmPrinter &p) {
+  p << ' ' << getOperation()->getAttr("in_type");
+  p.printOptionalAttrDict(getOperation()->getAttrs(), {"in_type"});
 }
 
-static mlir::LogicalResult verify(fir::GenTypeDescOp &op) {
-  mlir::Type resultTy = op.getType();
+mlir::LogicalResult GenTypeDescOp::verify() {
+  mlir::Type resultTy = getType();
   if (auto tdesc = resultTy.dyn_cast<TypeDescType>()) {
-    if (tdesc.getOfTy() != op.getInType())
-      return op.emitOpError("wrapped type mismatched");
+    if (tdesc.getOfTy() != getInType())
+      return emitOpError("wrapped type mismatched");
   } else {
-    return op.emitOpError("must be !fir.tdesc type");
+    return emitOpError("must be !fir.tdesc type");
   }
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // GlobalOp
 //===----------------------------------------------------------------------===//
 
 mlir::Type fir::GlobalOp::resultType() {
   return wrapAllocaResultType(getType());
 }
 
-static ParseResult parseGlobalOp(OpAsmParser &parser, OperationState &result) {
+ParseResult GlobalOp::parse(OpAsmParser &parser, OperationState &result) {
   // Parse the optional linkage
   llvm::StringRef linkage;
   auto &builder = parser.getBuilder();
   if (mlir::succeeded(parser.parseOptionalKeyword(&linkage))) {
     if (fir::GlobalOp::verifyValidLinkage(linkage))
       return mlir::failure();
     mlir::StringAttr linkAttr = builder.getStringAttr(linkage);
     result.addAttribute(fir::GlobalOp::linkageAttrName(), linkAttr);
auto parseResult = parser.parseOptionalRegion(
         *result.addRegion(), /*arguments=*/llvm::None, /*argTypes=*/llvm::None);
     if (parseResult.hasValue() && mlir::failed(*parseResult))
       return mlir::failure();
   }
 
   return mlir::success();
 }
 
-static void print(mlir::OpAsmPrinter &p, fir::GlobalOp &op) {
-  if (op.linkName().hasValue())
-    p << ' ' << op.linkName().getValue();
+void GlobalOp::print(mlir::OpAsmPrinter &p) {
+  if (linkName().hasValue())
+    p << ' ' << linkName().getValue();
   p << ' ';
-  p.printAttributeWithoutType(op.getSymrefAttr());
-  if (auto val = op.getValueOrNull())
+  p.printAttributeWithoutType(getSymrefAttr());
+  if (auto val = getValueOrNull())
     p << '(' << val << ')';
-  if (op.getOperation()->getAttr(fir::GlobalOp::getConstantAttrNameStr()))
+  if (getOperation()->getAttr(fir::GlobalOp::getConstantAttrNameStr()))
     p << " constant";
   p << " : ";
-  p.printType(op.getType());
-  if (op.hasInitializationBody()) {
+  p.printType(getType());
+  if (hasInitializationBody()) {
     p << ' ';
-    p.printRegion(op.getOperation()->getRegion(0),
+    p.printRegion(getOperation()->getRegion(0),
                   /*printEntryBlockArgs=*/false,
                   /*printBlockTerminators=*/true);
   }
 }
 
 void fir::GlobalOp::appendInitialValue(mlir::Operation *op) {
   getBlock().getOperations().push_back(op);
 }
mlir::ParseResult fir::GlobalOp::verifyValidLinkage(StringRef linkage) {
   static const char *validNames[] = {"common", "internal", "linkonce", "weak"};
   return mlir::success(llvm::is_contained(validNames, linkage));
 }
 
 //===----------------------------------------------------------------------===//
 // GlobalLenOp
 //===----------------------------------------------------------------------===//
 
-static mlir::ParseResult parseGlobalLenOp(mlir::OpAsmParser &parser,
-                                          mlir::OperationState &result) {
+mlir::ParseResult GlobalLenOp::parse(mlir::OpAsmParser &parser,
   llvm::StringRef fieldName;
   if (failed(parser.parseOptionalKeyword(&fieldName))) {
     mlir::StringAttr fieldAttr;
     if (parser.parseAttribute(fieldAttr, fir::GlobalLenOp::lenParamAttrName(),
                               result.attributes))
       return mlir::failure();
   } else {
     result.addAttribute(fir::GlobalLenOp::lenParamAttrName(),
                         parser.getBuilder().getStringAttr(fieldName));
   }
   mlir::IntegerAttr constant;
   if (parser.parseComma() ||
       parser.parseAttribute(constant, fir::GlobalLenOp::intAttrName(),
                             result.attributes))
     return mlir::failure();
   return mlir::success();
 }
 
-static void print(mlir::OpAsmPrinter &p, fir::GlobalLenOp &op) {
-  p << ' ' << op.getOperation()->getAttr(fir::GlobalLenOp::lenParamAttrName())
-    << ", " << op.getOperation()->getAttr(fir::GlobalLenOp::intAttrName());
+void GlobalLenOp::print(mlir::OpAsmPrinter &p) {
+  p << ' ' << getOperation()->getAttr(fir::GlobalLenOp::lenParamAttrName())
+    << ", " << getOperation()->getAttr(fir::GlobalLenOp::intAttrName());
 }
 
 //===----------------------------------------------------------------------===//
 // FieldIndexOp
 //===----------------------------------------------------------------------===//
 
-static mlir::ParseResult parseFieldIndexOp(mlir::OpAsmParser &parser,
-                                           mlir::OperationState &result) {
+mlir::ParseResult FieldIndexOp::parse(mlir::OpAsmParser &parser,
   llvm::StringRef fieldName;
   auto &builder = parser.getBuilder();
   mlir::Type recty;
   if (parser.parseOptionalKeyword(&fieldName) || parser.parseComma() ||
       parser.parseType(recty))
     return mlir::failure();
   result.addAttribute(fir::FieldIndexOp::fieldAttrName(),
                       builder.getStringAttr(fieldName));
if (parser.parseOperandList(operands, mlir::OpAsmParser::Delimiter::None) ||
       return mlir::failure();
   }
   mlir::Type fieldType = fir::FieldType::get(builder.getContext());
   if (parser.addTypeToList(fieldType, result.types))
     return mlir::failure();
   return mlir::success();
 }
 
-static void print(mlir::OpAsmPrinter &p, fir::FieldIndexOp &op) {
+void FieldIndexOp::print(mlir::OpAsmPrinter &p) {
   p << ' '
-    << op.getOperation()
+    << getOperation()
            ->getAttrOfType<mlir::StringAttr>(fir::FieldIndexOp::fieldAttrName())
            .getValue()
-    << ", " << op.getOperation()->getAttr(fir::FieldIndexOp::typeAttrName());
-  if (op.getNumOperands()) {
+    << ", " << getOperation()->getAttr(fir::FieldIndexOp::typeAttrName());
+  if (getNumOperands()) {
     p << '(';
-    p.printOperands(op.typeparams());
+    p.printOperands(typeparams());
     const auto *sep = ") : ";
-    for (auto op : op.typeparams()) {
+    for (auto op : typeparams()) {
       p << sep;
       if (op)
         p.printType(op.getType());
       else
         p << "()";
       sep = ", ";
     }
   }
llvm::interleaveComma(
       make_filter_range(
           enumerate,
           [](auto indexed_value) { return indexed_value.index() % 2 != 0; }),
       printer, [&](auto indexed_value) { printer << indexed_value.value(); });
   printer << ")";
 }
 
 /// Range bounds must be nonnegative, and the range must not be empty.
-static mlir::LogicalResult verify(fir::InsertOnRangeOp op) {
-  if (fir::hasDynamicSize(op.seq().getType()))
-    return op.emitOpError("must have constant shape and size");
-  mlir::DenseIntElementsAttr coor = op.coor();
-  if (coor.size() < 2 || coor.size() % 2 != 0)
-    return op.emitOpError("has uneven number of values in ranges");
+mlir::LogicalResult InsertOnRangeOp::verify() {
+  if (fir::hasDynamicSize(seq().getType()))
+    return emitOpError("must have constant shape and size");
+  mlir::DenseIntElementsAttr coorAttr = coor();
+  if (coorAttr.size() < 2 || coorAttr.size() % 2 != 0)
+    return emitOpError("has uneven number of values in ranges");
   bool rangeIsKnownToBeNonempty = false;
-  for (auto i = coor.getValues<int64_t>().end(),
-            b = coor.getValues<int64_t>().begin();
+  for (auto i = coorAttr.getValues<int64_t>().end(),
+            b = coorAttr.getValues<int64_t>().begin();
        i != b;) {
     int64_t ub = (*--i);
     int64_t lb = (*--i);
     if (lb < 0 || ub < 0)
-      return op.emitOpError("negative range bound");
+      return emitOpError("negative range bound");
     if (rangeIsKnownToBeNonempty)
       continue;
     if (lb > ub)
-      return op.emitOpError("empty range");
+      return emitOpError("empty range");
     rangeIsKnownToBeNonempty = lb < ub;
   }
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // InsertValueOp
 //===----------------------------------------------------------------------===//
if (blockArgNum > 0 && blockArgNum <= initArgs().size())
     return initArgs()[blockArgNum - 1];
   return {};
 }
 
 //===----------------------------------------------------------------------===//
 // LenParamIndexOp
 //===----------------------------------------------------------------------===//
 
-static mlir::ParseResult parseLenParamIndexOp(mlir::OpAsmParser &parser,
-                                              mlir::OperationState &result) {
+mlir::ParseResult LenParamIndexOp::parse(mlir::OpAsmParser &parser,
   llvm::StringRef fieldName;
   auto &builder = parser.getBuilder();
   mlir::Type recty;
   if (parser.parseOptionalKeyword(&fieldName) || parser.parseComma() ||
       parser.parseType(recty))
     return mlir::failure();
   result.addAttribute(fir::LenParamIndexOp::fieldAttrName(),
                       builder.getStringAttr(fieldName));
   if (!recty.dyn_cast<RecordType>())
     return mlir::failure();
   result.addAttribute(fir::LenParamIndexOp::typeAttrName(),
                       mlir::TypeAttr::get(recty));
   mlir::Type lenType = fir::LenType::get(builder.getContext());
   if (parser.addTypeToList(lenType, result.types))
     return mlir::failure();
   return mlir::success();
 }
 
-static void print(mlir::OpAsmPrinter &p, fir::LenParamIndexOp &op) {
+void LenParamIndexOp::print(mlir::OpAsmPrinter &p) {
   p << ' '
-    << op.getOperation()
+    << getOperation()
            ->getAttrOfType<mlir::StringAttr>(
                fir::LenParamIndexOp::fieldAttrName())
            .getValue()
-    << ", " << op.getOperation()->getAttr(fir::LenParamIndexOp::typeAttrName());
+    << ", " << getOperation()->getAttr(fir::LenParamIndexOp::typeAttrName());
 }
 
 //===----------------------------------------------------------------------===//
 // LoadOp
 //===----------------------------------------------------------------------===//
 
 void fir::LoadOp::build(mlir::OpBuilder &builder, mlir::OperationState &result,
                         mlir::Value refVal) {

 }
 
 mlir::ParseResult fir::LoadOp::getElementOf(mlir::Type &ele, mlir::Type ref) {
   if ((ele = fir::dyn_cast_ptrEleTy(ref)))
     return mlir::success();
   return mlir::failure();
 }
 
-static mlir::ParseResult parseLoadOp(mlir::OpAsmParser &parser,
-                                     mlir::OperationState &result) {
+mlir::ParseResult LoadOp::parse(mlir::OpAsmParser &parser,
   mlir::Type type;
   mlir::OpAsmParser::OperandType oper;
   if (parser.parseOperand(oper) ||
       parser.parseOptionalAttrDict(result.attributes) ||
       parser.parseColonType(type) ||
       parser.resolveOperand(oper, type, result.operands))
     return mlir::failure();
   mlir::Type eleTy;
   if (fir::LoadOp::getElementOf(eleTy, type) ||
       parser.addTypeToList(eleTy, result.types))
     return mlir::failure();
   return mlir::success();
 }
 
-static void print(mlir::OpAsmPrinter &p, fir::LoadOp &op) {
+void LoadOp::print(mlir::OpAsmPrinter &p) {
   p << ' ';
-  p.printOperand(op.memref());
-  p.printOptionalAttrDict(op.getOperation()->getAttrs(), {});
-  p << " : " << op.memref().getType();
+  p.printOperand(memref());
+  p.printOptionalAttrDict(getOperation()->getAttrs(), {});
+  p << " : " << memref().getType();
 }
 
 //===----------------------------------------------------------------------===//
 // DoLoopOp
 //===----------------------------------------------------------------------===//
 
 void fir::DoLoopOp::build(mlir::OpBuilder &builder,
                           mlir::OperationState &result, mlir::Value lb,
if (blockArgNum > 0 && blockArgNum <= initArgs().size())
     return initArgs()[blockArgNum - 1];
   return {};
 }
 
 //===----------------------------------------------------------------------===//
 // DTEntryOp
 //===----------------------------------------------------------------------===//
 
-static mlir::ParseResult parseDTEntryOp(mlir::OpAsmParser &parser,
-                                        mlir::OperationState &result) {
+mlir::ParseResult DTEntryOp::parse(mlir::OpAsmParser &parser,
   llvm::StringRef methodName;
   // allow `methodName` or `"methodName"`
   if (failed(parser.parseOptionalKeyword(&methodName))) {
     mlir::StringAttr methodAttr;
     if (parser.parseAttribute(methodAttr,
                               fir::DTEntryOp::getMethodAttrNameStr(),
                               result.attributes))
       return mlir::failure();
   } else {
     result.addAttribute(fir::DTEntryOp::getMethodAttrNameStr(),
                         parser.getBuilder().getStringAttr(methodName));
   }
   mlir::SymbolRefAttr calleeAttr;
   if (parser.parseComma() ||
       parser.parseAttribute(calleeAttr, fir::DTEntryOp::getProcAttrNameStr(),
                             result.attributes))
     return mlir::failure();
   return mlir::success();
 }
 
-static void print(mlir::OpAsmPrinter &p, fir::DTEntryOp &op) {
-  p << ' ' << op.getMethodAttr() << ", " << op.getProcAttr();
+void DTEntryOp::print(mlir::OpAsmPrinter &p) {
+  p << ' ' << getMethodAttr() << ", " << getProcAttr();
 }
 
 //===----------------------------------------------------------------------===//
 // ReboxOp
 //===----------------------------------------------------------------------===//
 
 /// Get the scalar type related to a fir.box type.
 /// Example: return f32 for !fir.box<!fir.heap<!fir.array<?x?xf32>>.
 static mlir::Type getBoxScalarEleTy(mlir::Type boxTy) {
   auto eleTy = fir::dyn_cast_ptrOrBoxEleTy(boxTy);
   if (auto seqTy = eleTy.dyn_cast<fir::SequenceType>())
     return seqTy.getEleTy();
   return eleTy;
 }
 
 /// Get the rank from a !fir.box type
 static unsigned getBoxRank(mlir::Type boxTy) {
   auto eleTy = fir::dyn_cast_ptrOrBoxEleTy(boxTy);
   if (auto seqTy = eleTy.dyn_cast<fir::SequenceType>())
     return seqTy.getDimension();
   return 0;
 }
 
-static mlir::LogicalResult verify(fir::ReboxOp op) {
-  auto inputBoxTy = op.box().getType();
+mlir::LogicalResult ReboxOp::verify() {
+  auto inputBoxTy = box().getType();
   if (fir::isa_unknown_size_box(inputBoxTy))
-    return op.emitOpError("box operand must not have unknown rank or type");
-  auto outBoxTy = op.getType();
+    return emitOpError("box operand must not have unknown rank or type");
+  auto outBoxTy = getType();
   if (fir::isa_unknown_size_box(outBoxTy))
-    return op.emitOpError("result type must not have unknown rank or type");
+    return emitOpError("result type must not have unknown rank or type");
   auto inputRank = getBoxRank(inputBoxTy);
   auto inputEleTy = getBoxScalarEleTy(inputBoxTy);
   auto outRank = getBoxRank(outBoxTy);
   auto outEleTy = getBoxScalarEleTy(outBoxTy);
 
-  if (auto slice = op.slice()) {
+  if (auto sliceVal = slice()) {
     // Slicing case
-    if (slice.getType().cast<fir::SliceType>().getRank() != inputRank)
-      return op.emitOpError("slice operand rank must match box operand rank");
-    if (auto shape = op.shape()) {
-      if (auto shiftTy = shape.getType().dyn_cast<fir::ShiftType>()) {
+    if (sliceVal.getType().cast<fir::SliceType>().getRank() != inputRank)
+      return emitOpError("slice operand rank must match box operand rank");
+    if (auto shapeVal = shape()) {
+      if (auto shiftTy = shapeVal.getType().dyn_cast<fir::ShiftType>()) {
         if (shiftTy.getRank() != inputRank)
-          return op.emitOpError("shape operand and input box ranks must match "
-                                "when there is a slice");
+          return emitOpError("shape operand and input box ranks must match "
       } else {
-        return op.emitOpError("shape operand must absent or be a fir.shift "
-                              "when there is a slice");
+        return emitOpError("shape operand must absent or be a fir.shift "
       }
     }
-    if (auto sliceOp = slice.getDefiningOp()) {
+    if (auto sliceOp = sliceVal.getDefiningOp()) {
       auto slicedRank = mlir::cast<fir::SliceOp>(sliceOp).getOutRank();
       if (slicedRank != outRank)
-        return op.emitOpError("result type rank and rank after applying slice "
-                              "operand must match");
+        return emitOpError("result type rank and rank after applying slice "
     }
   } else {
     // Reshaping case
     unsigned shapeRank = inputRank;
-    if (auto shape = op.shape()) {
-      auto ty = shape.getType();
+    if (auto shapeVal = shape()) {
+      auto ty = shapeVal.getType();
       if (auto shapeTy = ty.dyn_cast<fir::ShapeType>()) {
         shapeRank = shapeTy.getRank();
       } else if (auto shapeShiftTy = ty.dyn_cast<fir::ShapeShiftType>()) {
         shapeRank = shapeShiftTy.getRank();
       } else {
         auto shiftTy = ty.cast<fir::ShiftType>();
         shapeRank = shiftTy.getRank();
         if (shapeRank != inputRank)
-          return op.emitOpError("shape operand and input box ranks must match "
-                                "when the shape is a fir.shift");
+          return emitOpError("shape operand and input box ranks must match "
       }
     }
     if (shapeRank != outRank)
-      return op.emitOpError("result type and shape operand ranks must match");
+      return emitOpError("result type and shape operand ranks must match");
   }
 
   if (inputEleTy != outEleTy)
     // TODO: check that outBoxTy is a parent type of inputBoxTy for derived
     // types.
     if (!inputEleTy.isa<fir::RecordType>())
-      return op.emitOpError(
+      return emitOpError(
           "op input and output element types must match for intrinsic types");
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // ResultOp
 //===----------------------------------------------------------------------===//
 
-static mlir::LogicalResult verify(fir::ResultOp op) {
-  auto *parentOp = op->getParentOp();
+mlir::LogicalResult ResultOp::verify() {
+  auto *parentOp = (*this)->getParentOp();
   auto results = parentOp->getResults();
-  auto operands = op->getOperands();
+  auto operands = (*this)->getOperands();
 
-  if (parentOp->getNumResults() != op.getNumOperands())
-    return op.emitOpError() << "parent of result must have same arity";
+  if (parentOp->getNumResults() != getNumOperands())
+    return emitOpError() << "parent of result must have same arity";
   for (auto e : llvm::zip(results, operands))
     if (std::get<0>(e).getType() != std::get<1>(e).getType())
-      return op.emitOpError()
-             << "types mismatch between result op and its parent";
+      return emitOpError() << "types mismatch between result op and its parent";
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // SaveResultOp
 //===----------------------------------------------------------------------===//
 
-static mlir::LogicalResult verify(fir::SaveResultOp op) {
-  auto resultType = op.value().getType();
-  if (resultType != fir::dyn_cast_ptrEleTy(op.memref().getType()))
-    return op.emitOpError("value type must match memory reference type");
+mlir::LogicalResult SaveResultOp::verify() {
+  auto resultType = value().getType();
+  if (resultType != fir::dyn_cast_ptrEleTy(memref().getType()))
+    return emitOpError("value type must match memory reference type");
   if (fir::isa_unknown_size_box(resultType))
-    return op.emitOpError("cannot save !fir.box of unknown rank or type");
+    return emitOpError("cannot save !fir.box of unknown rank or type");
 
   if (resultType.isa<fir::BoxType>()) {
-    if (op.shape() || !op.typeparams().empty())
-      return op.emitOpError(
+    if (shape() || !typeparams().empty())
+      return emitOpError(
           "must not have shape or length operands if the value is a fir.box");
     return mlir::success();
   }
 
   // fir.record or fir.array case.
   unsigned shapeTyRank = 0;
-  if (auto shapeOp = op.shape()) {
-    auto shapeTy = shapeOp.getType();
+  if (auto shapeVal = shape()) {
+    auto shapeTy = shapeVal.getType();
     if (auto s = shapeTy.dyn_cast<fir::ShapeType>())
       shapeTyRank = s.getRank();
     else
       shapeTyRank = shapeTy.cast<fir::ShapeShiftType>().getRank();
   }
 
   auto eleTy = resultType;
   if (auto seqTy = resultType.dyn_cast<fir::SequenceType>()) {
     if (seqTy.getDimension() != shapeTyRank)
-      op.emitOpError("shape operand must be provided and have the value rank "
-                     "when the value is a fir.array");
+      emitOpError("shape operand must be provided and have the value rank "
     eleTy = seqTy.getEleTy();
   } else {
     if (shapeTyRank != 0)
-      op.emitOpError(
+      emitOpError(
           "shape operand should only be provided if the value is a fir.array");
   }
 
   if (auto recTy = eleTy.dyn_cast<fir::RecordType>()) {
-    if (recTy.getNumLenParams() != op.typeparams().size())
-      op.emitOpError("length parameters number must match with the value type "
-                     "length parameters");
+    if (recTy.getNumLenParams() != typeparams().size())
+      emitOpError("length parameters number must match with the value type "
   } else if (auto charTy = eleTy.dyn_cast<fir::CharacterType>()) {
-    if (op.typeparams().size() > 1)
-      op.emitOpError("no more than one length parameter must be provided for "
-                     "character value");
+    if (typeparams().size() > 1)
+      emitOpError("no more than one length parameter must be provided for "
   } else {
-    if (!op.typeparams().empty())
-      op.emitOpError(
-          "length parameters must not be provided for this value type");
+    if (!typeparams().empty())
+      emitOpError("length parameters must not be provided for this value type");
   }
 
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // SelectOp
 //===----------------------------------------------------------------------===//
fir::SelectCaseOp::getSuccessorOperands(mlir::ValueRange operands,
   auto a =
       (*this)->getAttrOfType<mlir::DenseIntElementsAttr>(getTargetOffsetAttr());
   auto segments = (*this)->getAttrOfType<mlir::DenseIntElementsAttr>(
       getOperandSegmentSizeAttr());
   return {getSubOperands(oper, getSubOperands(2, operands, segments), a)};
 }
 
 // parser for fir.select_case Op
-static mlir::ParseResult parseSelectCase(mlir::OpAsmParser &parser,
-                                         mlir::OperationState &result) {
+mlir::ParseResult SelectCaseOp::parse(mlir::OpAsmParser &parser,
   mlir::OpAsmParser::OperandType selector;
   mlir::Type type;
   if (parseSelector(parser, result, selector, type))
     return mlir::failure();
 
   llvm::SmallVector<mlir::Attribute> attrs;
   llvm::SmallVector<mlir::OpAsmParser::OperandType> opers;
   llvm::SmallVector<mlir::Block *> dests;
mlir::ParseResult SelectCaseOp::parse(mlir::OpAsmParser &parser,
   auto &bld = parser.getBuilder();
   result.addAttribute(fir::SelectCaseOp::getOperandSegmentSizeAttr(),
                       bld.getI32VectorAttr({1, offSize, toffSize}));
   result.addAttribute(getCompareOffsetAttr(), bld.getI32VectorAttr(argOffs));
   result.addAttribute(getTargetOffsetAttr(), bld.getI32VectorAttr(targOffs));
   return mlir::success();
 }
 
-static void print(mlir::OpAsmPrinter &p, fir::SelectCaseOp &op) {
+void SelectCaseOp::print(mlir::OpAsmPrinter &p) {
   p << ' ';
-  p.printOperand(op.getSelector());
-  p << " : " << op.getSelector().getType() << " [";
-  auto cases = op.getOperation()
-                   ->getAttrOfType<mlir::ArrayAttr>(op.getCasesAttr())
-                   .getValue();
-  auto count = op.getNumConditions();
+  p.printOperand(getSelector());
+  p << " : " << getSelector().getType() << " [";
+  auto cases =
+      getOperation()->getAttrOfType<mlir::ArrayAttr>(getCasesAttr()).getValue();
+  auto count = getNumConditions();
   for (decltype(count) i = 0; i != count; ++i) {
     if (i)
       p << ", ";
     p << cases[i] << ", ";
     if (!cases[i].isa<mlir::UnitAttr>()) {
-      auto caseArgs = *op.getCompareOperands(i);
+      auto caseArgs = *getCompareOperands(i);
       p.printOperand(*caseArgs.begin());
       p << ", ";
       if (cases[i].isa<fir::ClosedIntervalAttr>()) {
         p.printOperand(*(++caseArgs.begin()));
         p << ", ";
       }
     }
-    op.printSuccessorAtIndex(p, i);
+    printSuccessorAtIndex(p, i);
   }
   p << ']';
-  p.printOptionalAttrDict(op.getOperation()->getAttrs(),
-                          {op.getCasesAttr(), getCompareOffsetAttr(),
-                           getTargetOffsetAttr(),
-                           op.getOperandSegmentSizeAttr()});
+  p.printOptionalAttrDict(getOperation()->getAttrs(),
+                          {getCasesAttr(), getCompareOffsetAttr(),
+                           getTargetOffsetAttr(), getOperandSegmentSizeAttr()});
 }
 
 unsigned fir::SelectCaseOp::compareOffsetSize() {
   return denseElementsSize((*this)->getAttrOfType<mlir::DenseIntElementsAttr>(
       getCompareOffsetAttr()));
 }
 
 unsigned fir::SelectCaseOp::targetOffsetSize() {
if (attr.isa<fir::ClosedIntervalAttr>()) {
       cmpOpers.push_back(mlir::ValueRange({iter, iter + 1}));
       ++iter;
     }
   }
   build(builder, result, selector, compareAttrs, cmpOpers, destinations,
         destOperands, attributes);
 }
 
-static mlir::LogicalResult verify(fir::SelectCaseOp &op) {
-  if (!(op.getSelector().getType().isa<mlir::IntegerType>() ||
-        op.getSelector().getType().isa<mlir::IndexType>() ||
-        op.getSelector().getType().isa<fir::IntegerType>() ||
-        op.getSelector().getType().isa<fir::LogicalType>() ||
-        op.getSelector().getType().isa<fir::CharacterType>()))
-    return op.emitOpError("must be an integer, character, or logical");
-  auto cases = op.getOperation()
-                   ->getAttrOfType<mlir::ArrayAttr>(op.getCasesAttr())
-                   .getValue();
-  auto count = op.getNumDest();
+mlir::LogicalResult SelectCaseOp::verify() {
+  if (!(getSelector().getType().isa<mlir::IntegerType>() ||
+        getSelector().getType().isa<mlir::IndexType>() ||
+        getSelector().getType().isa<fir::IntegerType>() ||
+        getSelector().getType().isa<fir::LogicalType>() ||
+        getSelector().getType().isa<fir::CharacterType>()))
+    return emitOpError("must be an integer, character, or logical");
+  auto cases =
+      getOperation()->getAttrOfType<mlir::ArrayAttr>(getCasesAttr()).getValue();
+  auto count = getNumDest();
   if (count == 0)
-    return op.emitOpError("must have at least one successor");
-  if (op.getNumConditions() != count)
-    return op.emitOpError("number of conditions and successors don't match");
-  if (op.compareOffsetSize() != count)
-    return op.emitOpError("incorrect number of compare operand groups");
-  if (op.targetOffsetSize() != count)
-    return op.emitOpError("incorrect number of successor operand groups");
+    return emitOpError("must have at least one successor");
+  if (getNumConditions() != count)
+    return emitOpError("number of conditions and successors don't match");
+  if (compareOffsetSize() != count)
+    return emitOpError("incorrect number of compare operand groups");
+  if (targetOffsetSize() != count)
+    return emitOpError("incorrect number of successor operand groups");
   for (decltype(count) i = 0; i != count; ++i) {
     auto &attr = cases[i];
     if (!(attr.isa<fir::PointIntervalAttr>() ||
           attr.isa<fir::LowerBoundAttr>() || attr.isa<fir::UpperBoundAttr>() ||
           attr.isa<fir::ClosedIntervalAttr>() || attr.isa<mlir::UnitAttr>()))
-      return op.emitOpError("incorrect select case attribute type");
+      return emitOpError("incorrect select case attribute type");
   }
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // SelectRankOp
 //===----------------------------------------------------------------------===//
 
fir::SelectTypeOp::getSuccessorOperands(llvm::ArrayRef<mlir::Value> operands,
                                         unsigned oper) {
   auto a =
       (*this)->getAttrOfType<mlir::DenseIntElementsAttr>(getTargetOffsetAttr());
   auto segments = (*this)->getAttrOfType<mlir::DenseIntElementsAttr>(
       getOperandSegmentSizeAttr());
   return {getSubOperands(oper, getSubOperands(2, operands, segments), a)};
 }
 
-static ParseResult parseSelectType(OpAsmParser &parser,
-                                   OperationState &result) {
+ParseResult SelectTypeOp::parse(OpAsmParser &parser, OperationState &result) {
   mlir::OpAsmParser::OperandType selector;
   mlir::Type type;
   if (parseSelector(parser, result, selector, type))
     return mlir::failure();
 
   llvm::SmallVector<mlir::Attribute> attrs;
   llvm::SmallVector<mlir::Block *> dests;
   llvm::SmallVector<llvm::SmallVector<mlir::Value>> destArgs;
ParseResult SelectTypeOp::parse(OpAsmParser &parser, OperationState &result) {
   return mlir::success();
 }
 
 unsigned fir::SelectTypeOp::targetOffsetSize() {
   return denseElementsSize((*this)->getAttrOfType<mlir::DenseIntElementsAttr>(
       getTargetOffsetAttr()));
 }
 
-static void print(mlir::OpAsmPrinter &p, fir::SelectTypeOp &op) {
+void SelectTypeOp::print(mlir::OpAsmPrinter &p) {
   p << ' ';
-  p.printOperand(op.getSelector());
-  p << " : " << op.getSelector().getType() << " [";
-  auto cases = op.getOperation()
-                   ->getAttrOfType<mlir::ArrayAttr>(op.getCasesAttr())
-                   .getValue();
-  auto count = op.getNumConditions();
+  p.printOperand(getSelector());
+  p << " : " << getSelector().getType() << " [";
+  auto cases =
+      getOperation()->getAttrOfType<mlir::ArrayAttr>(getCasesAttr()).getValue();
+  auto count = getNumConditions();
   for (decltype(count) i = 0; i != count; ++i) {
     if (i)
       p << ", ";
     p << cases[i] << ", ";
-    op.printSuccessorAtIndex(p, i);
+    printSuccessorAtIndex(p, i);
   }
   p << ']';
-  p.printOptionalAttrDict(op.getOperation()->getAttrs(),
-                          {op.getCasesAttr(), getCompareOffsetAttr(),
+  p.printOptionalAttrDict(getOperation()->getAttrs(),
+                          {getCasesAttr(), getCompareOffsetAttr(),
                            getTargetOffsetAttr(),
                            fir::SelectTypeOp::getOperandSegmentSizeAttr()});
 }
 
-static mlir::LogicalResult verify(fir::SelectTypeOp &op) {
-  if (!(op.getSelector().getType().isa<fir::BoxType>()))
-    return op.emitOpError("must be a boxed type");
-  auto cases = op.getOperation()
-                   ->getAttrOfType<mlir::ArrayAttr>(op.getCasesAttr())
-                   .getValue();
-  auto count = op.getNumDest();
+mlir::LogicalResult SelectTypeOp::verify() {
+  if (!(getSelector().getType().isa<fir::BoxType>()))
+    return emitOpError("must be a boxed type");
+  auto cases =
+      getOperation()->getAttrOfType<mlir::ArrayAttr>(getCasesAttr()).getValue();
+  auto count = getNumDest();
   if (count == 0)
-    return op.emitOpError("must have at least one successor");
-  if (op.getNumConditions() != count)
-    return op.emitOpError("number of conditions and successors don't match");
-  if (op.targetOffsetSize() != count)
-    return op.emitOpError("incorrect number of successor operand groups");
+    return emitOpError("must have at least one successor");
+  if (getNumConditions() != count)
+    return emitOpError("number of conditions and successors don't match");
+  if (targetOffsetSize() != count)
+    return emitOpError("incorrect number of successor operand groups");
   for (decltype(count) i = 0; i != count; ++i) {
     auto &attr = cases[i];
     if (!(attr.isa<fir::ExactTypeAttr>() || attr.isa<fir::SubclassAttr>() ||
           attr.isa<mlir::UnitAttr>()))
-      return op.emitOpError("invalid type-case alternative");
+      return emitOpError("invalid type-case alternative");
   }
   return mlir::success();
 }
 
 void fir::SelectTypeOp::build(mlir::OpBuilder &builder,
                               mlir::OperationState &result,
                               mlir::Value selector,
                               llvm::ArrayRef<mlir::Attribute> typeOperands,
void fir::SelectTypeOp::build(mlir::OpBuilder &builder,
   result.addAttribute(getTargetOffsetAttr(), builder.getI32VectorAttr(argOffs));
   result.addAttributes(attributes);
 }
 
 //===----------------------------------------------------------------------===//
 // ShapeOp
 //===----------------------------------------------------------------------===//
 
-static mlir::LogicalResult verify(fir::ShapeOp &op) {
-  auto size = op.extents().size();
-  auto shapeTy = op.getType().dyn_cast<fir::ShapeType>();
+mlir::LogicalResult ShapeOp::verify() {
+  auto size = extents().size();
+  auto shapeTy = getType().dyn_cast<fir::ShapeType>();
   assert(shapeTy && "must be a shape type");
   if (shapeTy.getRank() != size)
-    return op.emitOpError("shape type rank mismatch");
+    return emitOpError("shape type rank mismatch");
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // ShapeShiftOp
 //===----------------------------------------------------------------------===//
 
-static mlir::LogicalResult verify(fir::ShapeShiftOp &op) {
-  auto size = op.pairs().size();
+mlir::LogicalResult ShapeShiftOp::verify() {
+  auto size = pairs().size();
   if (size < 2 || size > 16 * 2)
-    return op.emitOpError("incorrect number of args");
+    return emitOpError("incorrect number of args");
   if (size % 2 != 0)
-    return op.emitOpError("requires a multiple of 2 args");
-  auto shapeTy = op.getType().dyn_cast<fir::ShapeShiftType>();
+    return emitOpError("requires a multiple of 2 args");
+  auto shapeTy = getType().dyn_cast<fir::ShapeShiftType>();
   assert(shapeTy && "must be a shape shift type");
   if (shapeTy.getRank() * 2 != size)
-    return op.emitOpError("shape type rank mismatch");
+    return emitOpError("shape type rank mismatch");
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // ShiftOp
 //===----------------------------------------------------------------------===//
 
-static mlir::LogicalResult verify(fir::ShiftOp &op) {
-  auto size = op.origins().size();
-  auto shiftTy = op.getType().dyn_cast<fir::ShiftType>();
+mlir::LogicalResult ShiftOp::verify() {
+  auto size = origins().size();
+  auto shiftTy = getType().dyn_cast<fir::ShiftType>();
   assert(shiftTy && "must be a shift type");
   if (shiftTy.getRank() != size)
-    return op.emitOpError("shift type rank mismatch");
+    return emitOpError("shift type rank mismatch");
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // SliceOp
 //===----------------------------------------------------------------------===//
 
 void fir::SliceOp::build(mlir::OpBuilder &builder, mlir::OperationState &result,
for (unsigned i = 1, end = triples.size(); i < end; i += 3) {
       if (!mlir::isa_and_nonnull<fir::UndefOp>(op))
         ++rank;
     }
     assert(rank > 0);
   }
   return rank;
 }
 
-static mlir::LogicalResult verify(fir::SliceOp &op) {
-  auto size = op.triples().size();
+mlir::LogicalResult SliceOp::verify() {
+  auto size = triples().size();
   if (size < 3 || size > 16 * 3)
-    return op.emitOpError("incorrect number of args for triple");
+    return emitOpError("incorrect number of args for triple");
   if (size % 3 != 0)
-    return op.emitOpError("requires a multiple of 3 args");
-  auto sliceTy = op.getType().dyn_cast<fir::SliceType>();
+    return emitOpError("requires a multiple of 3 args");
+  auto sliceTy = getType().dyn_cast<fir::SliceType>();
   assert(sliceTy && "must be a slice type");
   if (sliceTy.getRank() * 3 != size)
-    return op.emitOpError("slice type rank mismatch");
+    return emitOpError("slice type rank mismatch");
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // StoreOp
 //===----------------------------------------------------------------------===//
 
 mlir::Type fir::StoreOp::elementType(mlir::Type refType) {
   return fir::dyn_cast_ptrEleTy(refType);
 }
 
-static mlir::ParseResult parseStoreOp(mlir::OpAsmParser &parser,
-                                      mlir::OperationState &result) {
+mlir::ParseResult StoreOp::parse(mlir::OpAsmParser &parser,
   mlir::Type type;
   mlir::OpAsmParser::OperandType oper;
   mlir::OpAsmParser::OperandType store;
   if (parser.parseOperand(oper) || parser.parseKeyword("to") ||
       parser.parseOperand(store) ||
       parser.parseOptionalAttrDict(result.attributes) ||
       parser.parseColonType(type) ||
       parser.resolveOperand(oper, fir::StoreOp::elementType(type),
                             result.operands) ||
       parser.resolveOperand(store, type, result.operands))
     return mlir::failure();
   return mlir::success();
 }
 
-static void print(mlir::OpAsmPrinter &p, fir::StoreOp &op) {
+void StoreOp::print(mlir::OpAsmPrinter &p) {
   p << ' ';
-  p.printOperand(op.value());
+  p.printOperand(value());
   p << " to ";
-  p.printOperand(op.memref());
-  p.printOptionalAttrDict(op.getOperation()->getAttrs(), {});
-  p << " : " << op.memref().getType();
+  p.printOperand(memref());
+  p.printOptionalAttrDict(getOperation()->getAttrs(), {});
+  p << " : " << memref().getType();
 }
 
-static mlir::LogicalResult verify(fir::StoreOp &op) {
-  if (op.value().getType() != fir::dyn_cast_ptrEleTy(op.memref().getType()))
-    return op.emitOpError("store value type must match memory reference type");
-  if (fir::isa_unknown_size_box(op.value().getType()))
-    return op.emitOpError("cannot store !fir.box of unknown rank or type");
+mlir::LogicalResult StoreOp::verify() {
+  if (value().getType() != fir::dyn_cast_ptrEleTy(memref().getType()))
+    return emitOpError("store value type must match memory reference type");
+  if (fir::isa_unknown_size_box(value().getType()))
+    return emitOpError("cannot store !fir.box of unknown rank or type");
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // StringLitOp
 //===----------------------------------------------------------------------===//
 
 bool fir::StringLitOp::isWideValue() {
void fir::StringLitOp::build(mlir::OpBuilder &builder, OperationState &result,
   auto valAttr =
       builder.getNamedAttr(xlist(), convertToArrayAttr(builder, vlist));
   std::int64_t length = len.hasValue() ? len.getValue() : inType.getLen();
   auto lenAttr = mkNamedIntegerAttr(builder, size(), length);
   result.addAttributes({valAttr, lenAttr});
   result.addTypes(inType);
 }
 
-static mlir::ParseResult parseStringLitOp(mlir::OpAsmParser &parser,
-                                          mlir::OperationState &result) {
+mlir::ParseResult StringLitOp::parse(mlir::OpAsmParser &parser,
   auto &builder = parser.getBuilder();
   mlir::Attribute val;
   mlir::NamedAttrList attrs;
   llvm::SMLoc trailingTypeLoc;
   if (parser.parseAttribute(val, "fake", attrs))
     return mlir::failure();
   if (auto v = val.dyn_cast<mlir::StringAttr>())
     result.attributes.push_back(
if (!charTy)
     return parser.emitError(trailingTypeLoc, "must have character type");
   type = fir::CharacterType::get(builder.getContext(), charTy.getFKind(),
                                  sz.getInt());
   if (!type || parser.addTypesToList(type, result.types))
     return mlir::failure();
   return mlir::success();
 }
 
-static void print(mlir::OpAsmPrinter &p, fir::StringLitOp &op) {
-  p << ' ' << op.getValue() << '(';
-  p << op.getSize().cast<mlir::IntegerAttr>().getValue() << ") : ";
-  p.printType(op.getType());
+void StringLitOp::print(mlir::OpAsmPrinter &p) {
+  p << ' ' << getValue() << '(';
+  p << getSize().cast<mlir::IntegerAttr>().getValue() << ") : ";
+  p.printType(getType());
 }
 
-static mlir::LogicalResult verify(fir::StringLitOp &op) {
-  if (op.getSize().cast<mlir::IntegerAttr>().getValue().isNegative())
-    return op.emitOpError("size must be non-negative");
-  if (auto xl = op.getOperation()->getAttr(fir::StringLitOp::xlist())) {
+mlir::LogicalResult StringLitOp::verify() {
+  if (getSize().cast<mlir::IntegerAttr>().getValue().isNegative())
+    return emitOpError("size must be non-negative");
+  if (auto xl = getOperation()->getAttr(fir::StringLitOp::xlist())) {
     auto xList = xl.cast<mlir::ArrayAttr>();
     for (auto a : xList)
       if (!a.isa<mlir::IntegerAttr>())
-        return op.emitOpError("values in list must be integers");
+        return emitOpError("values in list must be integers");
   }
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // UnboxProcOp
 //===----------------------------------------------------------------------===//
 
-static mlir::LogicalResult verify(fir::UnboxProcOp &op) {
-  if (auto eleTy = fir::dyn_cast_ptrEleTy(op.refTuple().getType()))
+mlir::LogicalResult UnboxProcOp::verify() {
+  if (auto eleTy = fir::dyn_cast_ptrEleTy(refTuple().getType()))
     if (eleTy.isa<mlir::TupleType>())
       return mlir::success();
-  return op.emitOpError("second output argument has bad type");
+  return emitOpError("second output argument has bad type");
 }
 
 //===----------------------------------------------------------------------===//
 // IfOp
 //===----------------------------------------------------------------------===//
 
 void fir::IfOp::build(mlir::OpBuilder &builder, OperationState &result,
                       mlir::Value cond, bool withElseRegion) {