[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 description = [{
     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 = [{
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
```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.
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(); }
```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));
     }]
   >];
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)>,
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() {
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) {

 // 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();

 
 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,
if ((op.isPointerCompatible(inType) && op.isPointerCompatible(outType)) ||
     return mlir::success();
   return op.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
 //===----------------------------------------------------------------------===//
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 = ", ";
     }
   }
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>>.
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,

 //===----------------------------------------------------------------------===//
 // 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
 //===----------------------------------------------------------------------===//