[NFC] Sync code for upstreaming

[schweitz]

Summary

Remove the "use namespace" and some redundant code.

[clementval]

LGTM

flang/include/flang/Optimizer/Dialect/FIROps.h

 class RealAttr;
 
 void buildCmpCOp(mlir::OpBuilder &builder, mlir::OperationState &result,
                  mlir::arith::CmpFPredicate predicate, mlir::Value lhs,
                  mlir::Value rhs);
 unsigned getCaseArgumentOffset(llvm::ArrayRef<mlir::Attribute> cases,
                                unsigned dest);
 DoLoopOp getForInductionVarOwner(mlir::Value val);
-bool isReferenceLike(mlir::Type type);
 mlir::ParseResult isValidCaseAttr(mlir::Attribute attr);
 mlir::ParseResult parseCmpcOp(mlir::OpAsmParser &parser,
                               mlir::OperationState &result);
 mlir::ParseResult parseSelector(mlir::OpAsmParser &parser,
                                 mlir::OperationState &result,
                                 mlir::OpAsmParser::UnresolvedOperand &selector,
                                 mlir::Type &type);
 

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

let extraClassDeclaration = [{
     static bool isIntegerCompatible(mlir::Type ty);
     static bool isFloatCompatible(mlir::Type ty);
     static bool isPointerCompatible(mlir::Type ty);
   }];
   let hasCanonicalizer = 1;
 }
 
 def FortranTypeAttr : Attr<And<[CPred<"$_self.isa<mlir::TypeAttr>()">,
-    Or<[CPred<"$_self.cast<mlir::TypeAttr>().getValue().isa<fir::CharacterType>()">,
-        CPred<"$_self.cast<mlir::TypeAttr>().getValue().isa<fir::ComplexType>()">,
-        CPred<"$_self.cast<mlir::TypeAttr>().getValue().isa<fir::IntegerType>()">,
-        CPred<"$_self.cast<mlir::TypeAttr>().getValue().isa<fir::LogicalType>()">,
-        CPred<"$_self.cast<mlir::TypeAttr>().getValue().isa<fir::RealType>()">,
-        CPred<"$_self.cast<mlir::TypeAttr>().getValue().isa<fir::RecordType>()">]>]>,
+    Or<[CPred<"$_self.cast<mlir::TypeAttr>().getValue().isa<fir::CharacterType,"
+              "fir::ComplexType, fir::IntegerType, fir::LogicalType,"
+              "fir::RealType, fir::RecordType>()">]>]>,
     "Fortran surface type"> {
   let storageType = [{ ::mlir::TypeAttr }];
   let returnType = "mlir::Type";
-  let convertFromStorage = "$_self.getValue().cast<Type>()";
+  let convertFromStorage = "$_self.getValue().cast<mlir::Type>()";
 }
 
 def fir_GenTypeDescOp : fir_OneResultOp<"gentypedesc", [NoSideEffect]> {
   let summary = "generate a type descriptor for a given type";
   let description = [{
     Generates a constant object that is an abstract type descriptor of the
     specified type.  The meta-type of a type descriptor for the type `T`
     is `!fir.tdesc<T>`.

flang/lib/Lower/ConvertExpr.cpp

public:
   ExtValue genLoad(const ExtValue &exv) {
     return ::genLoad(builder, getLoc(), exv);
   }
 
   ExtValue genval(Fortran::semantics::SymbolRef sym) {
     mlir::Location loc = getLoc();
     ExtValue var = gen(sym);
     if (const fir::UnboxedValue *s = var.getUnboxed())
-      if (fir::isReferenceLike(s->getType())) {
+      if (fir::isa_ref_type(s->getType())) {
         // A function with multiple entry points returning different types
         // tags all result variables with one of the largest types to allow
         // them to share the same storage.  A reference to a result variable
         // of one of the other types requires conversion to the actual type.
         fir::UnboxedValue addr = *s;
         if (Fortran::semantics::IsFunctionResult(sym)) {
           mlir::Type resultType = converter.genType(*sym);
           if (addr.getType() != resultType)

flang/lib/Optimizer/Dialect/FIROps.cpp

 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/ADT/TypeSwitch.h"
 
 namespace {
 #include "flang/Optimizer/Dialect/CanonicalizationPatterns.inc"
 } // namespace
-using namespace fir;
-using namespace mlir;
 
 /// Return true if a sequence type is of some incomplete size or a record type
 /// is malformed or contains an incomplete sequence type. An incomplete sequence
 /// type is one with more unknown extents in the type than have been provided
 /// via `dynamicExtents`. Sequence types with an unknown rank are incomplete by
 /// definition.
 static bool verifyInType(mlir::Type inType,
                          llvm::SmallVectorImpl<llvm::StringRef> &visited,
                          unsigned dynamicExtents = 0) {
   if (auto st = inType.dyn_cast<fir::SequenceType>()) {
     auto shape = st.getShape();
     if (shape.size() == 0)
       return true;
-    for (std::size_t i = 0, end{shape.size()}; i < end; ++i) {
+    for (std::size_t i = 0, end = shape.size(); i < end; ++i) {
       if (shape[i] != fir::SequenceType::getUnknownExtent())
         continue;
       if (dynamicExtents-- == 0)
         return true;
     }
   } else if (auto rt = inType.dyn_cast<fir::RecordType>()) {
     // don't recurse if we're already visiting this one
     if (llvm::is_contained(visited, rt.getName()))

 
 //===----------------------------------------------------------------------===//
 // AllocaOp
 //===----------------------------------------------------------------------===//
 
 /// Create a legal memory reference as return type
 static mlir::Type wrapAllocaResultType(mlir::Type intype) {
   // FIR semantics: memory references to memory references are disallowed
-  if (intype.isa<ReferenceType>())
+  if (intype.isa<fir::ReferenceType>())
     return {};
-  return ReferenceType::get(intype);
+  return fir::ReferenceType::get(intype);
 }
 
 mlir::Type fir::AllocaOp::getAllocatedType() {
-  return getType().cast<ReferenceType>().getEleTy();
+  return getType().cast<fir::ReferenceType>().getEleTy();
 }
 
 mlir::Type fir::AllocaOp::getRefTy(mlir::Type ty) {
-  return ReferenceType::get(ty);
+  return fir::ReferenceType::get(ty);
 }
 
 void fir::AllocaOp::build(mlir::OpBuilder &builder,
                           mlir::OperationState &result, mlir::Type inType,
                           llvm::StringRef uniqName, mlir::ValueRange typeparams,
                           mlir::ValueRange shape,
                           llvm::ArrayRef<mlir::NamedAttribute> attributes) {
   auto nameAttr = builder.getStringAttr(uniqName);
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);
 }
 
-mlir::ParseResult fir::AllocaOp::parse(OpAsmParser &parser,
-                                       OperationState &result) {
+mlir::ParseResult fir::AllocaOp::parse(mlir::OpAsmParser &parser,
+                                       mlir::OperationState &result) {
   return parseAllocatableOp(wrapAllocaResultType, parser, result);
 }
 
-void fir::AllocaOp::print(OpAsmPrinter &p) { printAllocatableOp(p, *this); }
+void fir::AllocaOp::print(mlir::OpAsmPrinter &p) {
+  printAllocatableOp(p, *this);
+}
 
 mlir::LogicalResult fir::AllocaOp::verify() {
   llvm::SmallVector<llvm::StringRef> visited;
   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 emitOpError("must be a !fir.ref type");
   if (fir::isa_unknown_size_box(fir::dyn_cast_ptrEleTy(outType)))
     return emitOpError("cannot allocate !fir.box of unknown rank or type");
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // AllocMemOp
 //===----------------------------------------------------------------------===//
 
 /// Create a legal heap reference as return type
 static mlir::Type wrapAllocMemResultType(mlir::Type intype) {
   // Fortran semantics: C852 an entity cannot be both ALLOCATABLE and POINTER
   // 8.5.3 note 1 prohibits ALLOCATABLE procedures as well
   // FIR semantics: one may not allocate a memory reference value
-  if (intype.isa<ReferenceType>() || intype.isa<HeapType>() ||
-      intype.isa<PointerType>() || intype.isa<FunctionType>())
+  if (intype.isa<fir::ReferenceType, fir::HeapType, fir::PointerType,
+                 mlir::FunctionType>())
     return {};
-  return HeapType::get(intype);
+  return fir::HeapType::get(intype);
 }
 
 mlir::Type fir::AllocMemOp::getAllocatedType() {
-  return getType().cast<HeapType>().getEleTy();
+  return getType().cast<fir::HeapType>().getEleTy();
 }
 
 mlir::Type fir::AllocMemOp::getRefTy(mlir::Type ty) {
-  return HeapType::get(ty);
+  return fir::HeapType::get(ty);
 }
 
 void fir::AllocMemOp::build(mlir::OpBuilder &builder,
                             mlir::OperationState &result, mlir::Type inType,
                             llvm::StringRef uniqName,
                             mlir::ValueRange typeparams, mlir::ValueRange shape,
                             llvm::ArrayRef<mlir::NamedAttribute> attributes) {
   auto nameAttr = builder.getStringAttr(uniqName);
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);
 }
 
-mlir::ParseResult AllocMemOp::parse(OpAsmParser &parser,
-                                    OperationState &result) {
+mlir::ParseResult fir::AllocMemOp::parse(mlir::OpAsmParser &parser,
+                                         mlir::OperationState &result) {
   return parseAllocatableOp(wrapAllocMemResultType, parser, result);
 }
 
-void AllocMemOp::print(OpAsmPrinter &p) { printAllocatableOp(p, *this); }
+void fir::AllocMemOp::print(mlir::OpAsmPrinter &p) {
+  printAllocatableOp(p, *this);
+}
 
-mlir::LogicalResult AllocMemOp::verify() {
+mlir::LogicalResult fir::AllocMemOp::verify() {
   llvm::SmallVector<llvm::StringRef> visited;
   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 emitOpError("must be a !fir.heap type");
   if (fir::isa_unknown_size_box(fir::dyn_cast_ptrEleTy(outType)))
     return emitOpError("cannot allocate !fir.box of unknown rank or type");
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // ArrayCoorOp
 //===----------------------------------------------------------------------===//
 
-mlir::LogicalResult ArrayCoorOp::verify() {
+mlir::LogicalResult fir::ArrayCoorOp::verify() {
   auto eleTy = fir::dyn_cast_ptrOrBoxEleTy(getMemref().getType());
   auto arrTy = eleTy.dyn_cast<fir::SequenceType>();
   if (!arrTy)
     return emitOpError("must be a reference to an array");
   auto arrDim = arrTy.getDimension();
 
   if (auto shapeOp = getShape()) {
     auto shapeTy = shapeOp.getType();
if (eleTy.isa<fir::SequenceType>())
       return eleTy;
   }
   return t;
 }
 
 std::vector<mlir::Value> fir::ArrayLoadOp::getExtents() {
   if (auto sh = getShape())
     if (auto *op = sh.getDefiningOp()) {
-      if (auto shOp = dyn_cast<fir::ShapeOp>(op)) {
+      if (auto shOp = mlir::dyn_cast<fir::ShapeOp>(op)) {
         auto extents = shOp.getExtents();
         return {extents.begin(), extents.end()};
       }
-      return cast<fir::ShapeShiftOp>(op).getExtents();
+      return mlir::cast<fir::ShapeShiftOp>(op).getExtents();
     }
   return {};
 }
 
-mlir::LogicalResult ArrayLoadOp::verify() {
+mlir::LogicalResult fir::ArrayLoadOp::verify() {
   auto eleTy = fir::dyn_cast_ptrOrBoxEleTy(getMemref().getType());
   auto arrTy = eleTy.dyn_cast<fir::SequenceType>();
   if (!arrTy)
     return emitOpError("must be a reference to an array");
   auto arrDim = arrTy.getDimension();
 
   if (auto shapeOp = getShape()) {
     auto shapeTy = shapeOp.getType();
-    unsigned shapeTyRank = 0;
+    unsigned shapeTyRank = 0u;
     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 (!getMemref().getType().isa<fir::BoxType>())
mlir::LogicalResult fir::ArrayLoadOp::verify() {
 
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // ArrayMergeStoreOp
 //===----------------------------------------------------------------------===//
 
-mlir::LogicalResult ArrayMergeStoreOp::verify() {
-  if (!isa<ArrayLoadOp>(getOriginal().getDefiningOp()))
+mlir::LogicalResult fir::ArrayMergeStoreOp::verify() {
+  if (!mlir::isa<fir::ArrayLoadOp>(getOriginal().getDefiningOp()))
     return emitOpError("operand #0 must be result of a fir.array_load op");
   if (auto sl = getSlice()) {
     if (auto sliceOp =
             mlir::dyn_cast_or_null<fir::SliceOp>(sl.getDefiningOp())) {
       if (!sliceOp.getSubstr().empty())
         return emitOpError(
             "array_merge_store cannot take a slice with substring");
       if (!sliceOp.getFields().empty()) {

 
 // Template function used for both array_fetch and array_update verification.
 template <typename A>
 mlir::Type validArraySubobject(A op) {
   auto ty = op.getSequence().getType();
   return fir::applyPathToType(ty, op.getIndices());
 }
 
-mlir::LogicalResult ArrayFetchOp::verify() {
+mlir::LogicalResult fir::ArrayFetchOp::verify() {
   auto arrTy = getSequence().getType().cast<fir::SequenceType>();
   auto indSize = getIndices().size();
   if (indSize < arrTy.getDimension())
     return emitOpError("number of indices != dimension of array");
   if (indSize == arrTy.getDimension() &&
       ::adjustedElementType(getElement().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>(getSequence().getDefiningOp()))
+  if (!mlir::isa<fir::ArrayLoadOp>(getSequence().getDefiningOp()))
     return emitOpError("argument #0 must be result of fir.array_load");
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // ArrayAccessOp
 //===----------------------------------------------------------------------===//
 
-mlir::LogicalResult ArrayAccessOp::verify() {
+mlir::LogicalResult fir::ArrayAccessOp::verify() {
   auto arrTy = getSequence().getType().cast<fir::SequenceType>();
   std::size_t indSize = getIndices().size();
   if (indSize < arrTy.getDimension())
     return emitOpError("number of indices != dimension of array");
   if (indSize == arrTy.getDimension() &&
       getElement().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
 //===----------------------------------------------------------------------===//
 
-mlir::LogicalResult ArrayUpdateOp::verify() {
+mlir::LogicalResult fir::ArrayUpdateOp::verify() {
   if (fir::isa_ref_type(getMerge().getType()))
     return emitOpError("does not support reference type for merge");
   auto arrTy = getSequence().getType().cast<fir::SequenceType>();
   auto indSize = getIndices().size();
   if (indSize < arrTy.getDimension())
     return emitOpError("number of indices != dimension of array");
   if (indSize == arrTy.getDimension() &&
       ::adjustedElementType(getMerge().getType()) != arrTy.getEleTy())
     return emitOpError("merged value does not have element type");
   auto ty = validArraySubobject(*this);
   if (!ty || ty != ::adjustedElementType(getMerge().getType()))
     return emitOpError("merged value and/or indices do not type check");
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // ArrayModifyOp
 //===----------------------------------------------------------------------===//
 
-mlir::LogicalResult ArrayModifyOp::verify() {
+mlir::LogicalResult fir::ArrayModifyOp::verify() {
   auto arrTy = getSequence().getType().cast<fir::SequenceType>();
   auto indSize = getIndices().size();
   if (indSize < arrTy.getDimension())
     return emitOpError("number of indices must match array dimension");
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // BoxAddrOp
 //===----------------------------------------------------------------------===//
 
 mlir::OpFoldResult fir::BoxAddrOp::fold(llvm::ArrayRef<mlir::Attribute> opnds) {
   if (auto *v = getVal().getDefiningOp()) {
-    if (auto box = dyn_cast<fir::EmboxOp>(v)) {
+    if (auto box = mlir::dyn_cast<fir::EmboxOp>(v)) {
       if (!box.getSlice()) // Fold only if not sliced
         return box.getMemref();
     }
-    if (auto box = dyn_cast<fir::EmboxCharOp>(v))
+    if (auto box = mlir::dyn_cast<fir::EmboxCharOp>(v))
       return box.getMemref();
   }
   return {};
 }
 
 //===----------------------------------------------------------------------===//
 // BoxCharLenOp
 //===----------------------------------------------------------------------===//
 
 mlir::OpFoldResult
 fir::BoxCharLenOp::fold(llvm::ArrayRef<mlir::Attribute> opnds) {
   if (auto v = getVal().getDefiningOp()) {
-    if (auto box = dyn_cast<fir::EmboxCharOp>(v))
+    if (auto box = mlir::dyn_cast<fir::EmboxCharOp>(v))
       return box.getLen();
   }
   return {};
 }
 
 //===----------------------------------------------------------------------===//
 // BoxDimsOp
 //===----------------------------------------------------------------------===//
void fir::CallOp::print(mlir::OpAsmPrinter &p) {
   if (isDirect)
     p << getCallee().getValue();
   else
     p << getOperand(0);
   p << '(' << (*this)->getOperands().drop_front(isDirect ? 0 : 1) << ')';
   p.printOptionalAttrDict((*this)->getAttrs(),
                           {fir::CallOp::getCalleeAttrNameStr()});
   auto resultTypes{getResultTypes()};
-  llvm::SmallVector<Type> argTypes(
+  llvm::SmallVector<mlir::Type> argTypes(
       llvm::drop_begin(getOperandTypes(), isDirect ? 0 : 1));
-  p << " : " << FunctionType::get(getContext(), argTypes, resultTypes);
+  p << " : " << mlir::FunctionType::get(getContext(), argTypes, resultTypes);
 }
 
 mlir::ParseResult fir::CallOp::parse(mlir::OpAsmParser &parser,
                                      mlir::OperationState &result) {
   llvm::SmallVector<mlir::OpAsmParser::UnresolvedOperand> operands;
   if (parser.parseOperandList(operands))
     return mlir::failure();
 
   mlir::NamedAttrList attrs;
   mlir::SymbolRefAttr funcAttr;
   bool isDirect = operands.empty();
   if (isDirect)
     if (parser.parseAttribute(funcAttr, fir::CallOp::getCalleeAttrNameStr(),
                               attrs))
       return mlir::failure();
 
-  Type type;
+  mlir::Type type;
   if (parser.parseOperandList(operands, mlir::OpAsmParser::Delimiter::Paren) ||
       parser.parseOptionalAttrDict(attrs) || parser.parseColon() ||
       parser.parseType(type))
     return mlir::failure();
 
   auto funcType = type.dyn_cast<mlir::FunctionType>();
   if (!funcType)
     return parser.emitError(parser.getNameLoc(), "expected function type");
mlir::ParseResult fir::CallOp::parse(mlir::OpAsmParser &parser,
   result.addTypes(funcType.getResults());
   result.attributes = attrs;
   return mlir::success();
 }
 
 void fir::CallOp::build(mlir::OpBuilder &builder, mlir::OperationState &result,
                         mlir::func::FuncOp callee, mlir::ValueRange operands) {
   result.addOperands(operands);
-  result.addAttribute(getCalleeAttrNameStr(), SymbolRefAttr::get(callee));
+  result.addAttribute(getCalleeAttrNameStr(), mlir::SymbolRefAttr::get(callee));
   result.addTypes(callee.getFunctionType().getResults());
 }
 
 void fir::CallOp::build(mlir::OpBuilder &builder, mlir::OperationState &result,
                         mlir::SymbolRefAttr callee,
                         llvm::ArrayRef<mlir::Type> results,
                         mlir::ValueRange operands) {
   result.addOperands(operands);
   if (callee)
     result.addAttribute(getCalleeAttrNameStr(), callee);
   result.addTypes(results);
 }
 
 //===----------------------------------------------------------------------===//
 // CmpOp
 //===----------------------------------------------------------------------===//
 
 template <typename OPTY>
-static void printCmpOp(OpAsmPrinter &p, OPTY op) {
+static void printCmpOp(mlir::OpAsmPrinter &p, OPTY op) {
   p << ' ';
   auto predSym = mlir::arith::symbolizeCmpFPredicate(
       op->template getAttrOfType<mlir::IntegerAttr>(
             OPTY::getPredicateAttrName())
           .getInt());
   assert(predSym.hasValue() && "invalid symbol value for predicate");
   p << '"' << mlir::arith::stringifyCmpFPredicate(predSym.getValue()) << '"'
     << ", ";
static mlir::ParseResult parseCmpOp(mlir::OpAsmParser &parser,
   mlir::NamedAttrList attrs;
   mlir::Attribute predicateNameAttr;
   mlir::Type type;
   if (parser.parseAttribute(predicateNameAttr, OPTY::getPredicateAttrName(),
                             attrs) ||
       parser.parseComma() || parser.parseOperandList(ops, 2) ||
       parser.parseOptionalAttrDict(attrs) || parser.parseColonType(type) ||
       parser.resolveOperands(ops, type, result.operands))
-    return failure();
+    return mlir::failure();
 
   if (!predicateNameAttr.isa<mlir::StringAttr>())
     return parser.emitError(parser.getNameLoc(),
                             "expected string comparison predicate attribute");
 
   // Rewrite string attribute to an enum value.
   llvm::StringRef predicateName =
       predicateNameAttr.cast<mlir::StringAttr>().getValue();
   auto predicate = fir::CmpcOp::getPredicateByName(predicateName);
   auto builder = parser.getBuilder();
   mlir::Type i1Type = builder.getI1Type();
   attrs.set(OPTY::getPredicateAttrName(),
-            builder.getI64IntegerAttr(static_cast<int64_t>(predicate)));
+            builder.getI64IntegerAttr(static_cast<std::int64_t>(predicate)));
   result.attributes = attrs;
   result.addTypes({i1Type});
-  return success();
+  return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // CharConvertOp
 //===----------------------------------------------------------------------===//
 
-mlir::LogicalResult CharConvertOp::verify() {
+mlir::LogicalResult fir::CharConvertOp::verify() {
   auto unwrap = [&](mlir::Type t) {
     t = fir::unwrapSequenceType(fir::dyn_cast_ptrEleTy(t));
     return t.dyn_cast<fir::CharacterType>();
   };
   auto inTy = unwrap(getFrom().getType());
   auto outTy = unwrap(getTo().getType());
   if (!(inTy && outTy))
     return emitOpError("not a reference to a character");
   if (inTy.getFKind() == outTy.getFKind())
     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) {
+void fir::buildCmpCOp(mlir::OpBuilder &builder, mlir::OperationState &result,
+                      mlir::arith::CmpFPredicate predicate, mlir::Value lhs,
+                      mlir::Value rhs) {
   result.addOperands({lhs, rhs});
   result.types.push_back(builder.getI1Type());
   result.addAttribute(
       fir::CmpcOp::getPredicateAttrName(),
-      builder.getI64IntegerAttr(static_cast<int64_t>(predicate)));
+      builder.getI64IntegerAttr(static_cast<std::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();
 }
 
-void CmpcOp::print(OpAsmPrinter &p) { printCmpOp(p, *this); }
+void fir::CmpcOp::print(mlir::OpAsmPrinter &p) { printCmpOp(p, *this); }
 
-mlir::ParseResult CmpcOp::parse(mlir::OpAsmParser &parser,
+mlir::ParseResult fir::CmpcOp::parse(mlir::OpAsmParser &parser,
                                      mlir::OperationState &result) {
   return parseCmpOp<fir::CmpcOp>(parser, result);
 }
 
 //===----------------------------------------------------------------------===//
 // ConstcOp
 //===----------------------------------------------------------------------===//
 
-mlir::ParseResult ConstcOp::parse(mlir::OpAsmParser &parser,
+mlir::ParseResult fir::ConstcOp::parse(mlir::OpAsmParser &parser,
                                        mlir::OperationState &result) {
   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();
 }
 
-void ConstcOp::print(mlir::OpAsmPrinter &p) {
+void fir::ConstcOp::print(mlir::OpAsmPrinter &p) {
   p << '(';
   p << getOperation()->getAttr(fir::ConstcOp::realAttrName()) << ", ";
   p << getOperation()->getAttr(fir::ConstcOp::imagAttrName()) << ") : ";
   p.printType(getType());
 }
 
-mlir::LogicalResult ConstcOp::verify() {
+mlir::LogicalResult fir::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,
-                                                 MLIRContext *context) {
+void fir::ConvertOp::getCanonicalizationPatterns(
+    mlir::RewritePatternSet &results, mlir::MLIRContext *context) {
   results.insert<ConvertConvertOptPattern, ConvertAscendingIndexOptPattern,
                  ConvertDescendingIndexOptPattern, RedundantConvertOptPattern,
                  CombineConvertOptPattern, CombineConvertTruncOptPattern,
                  ForwardConstantConvertPattern>(context);
 }
 
 mlir::OpFoldResult fir::ConvertOp::fold(llvm::ArrayRef<mlir::Attribute> opnds) {
   if (getValue().getType() == getType())
     return getValue();
-  if (matchPattern(getValue(), m_Op<fir::ConvertOp>())) {
-    auto inner = cast<fir::ConvertOp>(getValue().getDefiningOp());
+  if (matchPattern(getValue(), mlir::m_Op<fir::ConvertOp>())) {
+    auto inner = mlir::cast<fir::ConvertOp>(getValue().getDefiningOp());
     // (convert (convert 'a : logical -> i1) : i1 -> logical) ==> forward 'a
     if (auto toTy = getType().dyn_cast<fir::LogicalType>())
       if (auto fromTy = inner.getValue().getType().dyn_cast<fir::LogicalType>())
         if (inner.getType().isa<mlir::IntegerType>() && (toTy == fromTy))
           return inner.getValue();
     // (convert (convert 'a : i1 -> logical) : logical -> i1) ==> forward 'a
     if (auto toTy = getType().dyn_cast<mlir::IntegerType>())
       if (auto fromTy =
               inner.getValue().getType().dyn_cast<mlir::IntegerType>())
         if (inner.getType().isa<fir::LogicalType>() && (toTy == fromTy) &&
             (fromTy.getWidth() == 1))
           return inner.getValue();
   }
   return {};
 }
 
 bool fir::ConvertOp::isIntegerCompatible(mlir::Type ty) {
-  return ty.isa<mlir::IntegerType>() || ty.isa<mlir::IndexType>() ||
-         ty.isa<fir::IntegerType>() || ty.isa<fir::LogicalType>();
+  return ty.isa<mlir::IntegerType, mlir::IndexType, fir::IntegerType,
+                fir::LogicalType>();
 }
 
 bool fir::ConvertOp::isFloatCompatible(mlir::Type ty) {
-  return ty.isa<mlir::FloatType>() || ty.isa<fir::RealType>();
+  return ty.isa<mlir::FloatType, fir::RealType>();
 }
 
 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>();
+  return ty.isa<fir::ReferenceType, fir::PointerType, fir::HeapType,
+                fir::LLVMPointerType, mlir::MemRefType, mlir::FunctionType,
+                fir::TypeDescType>();
 }
 
-mlir::LogicalResult ConvertOp::verify() {
+mlir::LogicalResult fir::ConvertOp::verify() {
   auto inType = getValue().getType();
   auto outType = getType();
   if (inType == outType)
     return mlir::success();
   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>()) ||
       (inType.isa<fir::BoxProcType>() && outType.isa<fir::BoxProcType>()) ||
       (fir::isa_complex(inType) && fir::isa_complex(outType)))
     return mlir::success();
   return emitOpError("invalid type conversion");
 }
 
 //===----------------------------------------------------------------------===//
 // CoordinateOp
 //===----------------------------------------------------------------------===//
 
-void CoordinateOp::print(mlir::OpAsmPrinter &p) {
+void fir::CoordinateOp::print(mlir::OpAsmPrinter &p) {
   p << ' ' << getRef() << ", " << getCoor();
   p.printOptionalAttrDict((*this)->getAttrs(), /*elideAttrs=*/{"baseType"});
   p << " : ";
   p.printFunctionalType(getOperandTypes(), (*this)->getResultTypes());
 }
 
-mlir::ParseResult CoordinateOp::parse(mlir::OpAsmParser &parser,
+mlir::ParseResult fir::CoordinateOp::parse(mlir::OpAsmParser &parser,
                                            mlir::OperationState &result) {
   mlir::OpAsmParser::UnresolvedOperand memref;
   if (parser.parseOperand(memref) || parser.parseComma())
     return mlir::failure();
   llvm::SmallVector<mlir::OpAsmParser::UnresolvedOperand> coorOperands;
   if (parser.parseOperandList(coorOperands))
     return mlir::failure();
   llvm::SmallVector<mlir::OpAsmParser::UnresolvedOperand> 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();
+    return mlir::failure();
   parser.addTypesToList(funcTy.getResults(), result.types);
   result.addAttribute("baseType", mlir::TypeAttr::get(funcTy.getInput(0)));
   return mlir::success();
 }
 
-mlir::LogicalResult CoordinateOp::verify() {
+mlir::LogicalResult fir::CoordinateOp::verify() {
   auto refTy = getRef().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 emitOpError("cannot find coordinate in unknown shape");
       if (arrTy.getConstantRows() < arrTy.getDimension() - 1)
         return emitOpError("cannot find coordinate with unknown extents");
     }
     if (!(fir::isa_aggregate(eleTy) || fir::isa_complex(eleTy) ||
           fir::isa_char_string(eleTy)))
       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 : getCoor())
-    if (dyn_cast_or_null<fir::LenParamIndexOp>(co.getDefiningOp())) {
+    if (mlir::dyn_cast_or_null<fir::LenParamIndexOp>(co.getDefiningOp())) {
       if (getNumOperands() != 2)
         return emitOpError("len_param_index must be last argument");
       if (!getRef().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());
 }
 
-mlir::ParseResult DispatchOp::parse(mlir::OpAsmParser &parser,
+mlir::ParseResult fir::DispatchOp::parse(mlir::OpAsmParser &parser,
                                          mlir::OperationState &result) {
   mlir::FunctionType calleeType;
   llvm::SmallVector<mlir::OpAsmParser::UnresolvedOperand> 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();
 }
 
-void DispatchOp::print(mlir::OpAsmPrinter &p) {
+void fir::DispatchOp::print(mlir::OpAsmPrinter &p) {
   p << ' ' << getMethodAttr() << '(';
   p.printOperand(getObject());
   if (!getArgs().empty()) {
     p << ", ";
     p.printOperands(getArgs());
   }
   p << ") : ";
   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);
 }
 
-mlir::ParseResult DispatchTableOp::parse(mlir::OpAsmParser &parser,
+mlir::ParseResult fir::DispatchTableOp::parse(mlir::OpAsmParser &parser,
                                               mlir::OperationState &result) {
   // Parse the name as a symbol reference attribute.
-  SymbolRefAttr nameAttr;
+  mlir::SymbolRefAttr nameAttr;
   if (parser.parseAttribute(nameAttr, mlir::SymbolTable::getSymbolAttrName(),
                             result.attributes))
-    return failure();
+    return mlir::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);
+  mlir::OptionalParseResult parseResult = parser.parseOptionalRegion(*body);
   if (parseResult.hasValue() && failed(*parseResult))
     return mlir::failure();
 
   fir::DispatchTableOp::ensureTerminator(*body, parser.getBuilder(),
                                          result.location);
   return mlir::success();
 }
 
-void DispatchTableOp::print(mlir::OpAsmPrinter &p) {
-  auto tableName =
-      getOperation()
-          ->getAttrOfType<StringAttr>(mlir::SymbolTable::getSymbolAttrName())
+void fir::DispatchTableOp::print(mlir::OpAsmPrinter &p) {
+  auto tableName = getOperation()
+                       ->getAttrOfType<mlir::StringAttr>(
+                           mlir::SymbolTable::getSymbolAttrName())
                        .getValue();
   p << " @" << tableName;
 
-  Region &body = getOperation()->getRegion(0);
+  mlir::Region &body = getOperation()->getRegion(0);
   if (!body.empty()) {
     p << ' ';
     p.printRegion(body, /*printEntryBlockArgs=*/false,
                   /*printBlockTerminators=*/false);
   }
 }
 
-mlir::LogicalResult DispatchTableOp::verify() {
+mlir::LogicalResult fir::DispatchTableOp::verify() {
   for (auto &op : getBlock())
-    if (!(isa<fir::DTEntryOp>(op) || isa<fir::FirEndOp>(op)))
+    if (!mlir::isa<fir::DTEntryOp, fir::FirEndOp>(op))
       return op.emitOpError("dispatch table must contain dt_entry");
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // EmboxOp
 //===----------------------------------------------------------------------===//
 
-mlir::LogicalResult EmboxOp::verify() {
+mlir::LogicalResult fir::EmboxOp::verify() {
   auto eleTy = fir::dyn_cast_ptrEleTy(getMemref().getType());
   bool isArray = false;
   if (auto seqTy = eleTy.dyn_cast<fir::SequenceType>()) {
     eleTy = seqTy.getEleTy();
     isArray = true;
   }
   if (hasLenParams()) {
     auto lenPs = numLenParams();
if (getSlice() && !isArray)
     return emitOpError("slice must not be provided for a scalar");
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // EmboxCharOp
 //===----------------------------------------------------------------------===//
 
-mlir::LogicalResult EmboxCharOp::verify() {
+mlir::LogicalResult fir::EmboxCharOp::verify() {
   auto eleTy = fir::dyn_cast_ptrEleTy(getMemref().getType());
-  if (!eleTy.dyn_cast_or_null<CharacterType>())
+  if (!eleTy.dyn_cast_or_null<fir::CharacterType>())
     return mlir::failure();
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // EmboxProcOp
 //===----------------------------------------------------------------------===//
 
-mlir::LogicalResult EmboxProcOp::verify() {
+mlir::LogicalResult fir::EmboxProcOp::verify() {
   // host bindings (optional) must be a reference to a tuple
   if (auto h = getHost()) {
-    if (auto r = h.getType().dyn_cast<ReferenceType>())
-      if (r.getEleTy().dyn_cast<mlir::TupleType>())
+    if (auto r = h.getType().dyn_cast<fir::ReferenceType>())
+      if (r.getEleTy().isa<mlir::TupleType>())
         return mlir::success();
     return mlir::failure();
   }
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // GenTypeDescOp
 //===----------------------------------------------------------------------===//
 
-void fir::GenTypeDescOp::build(OpBuilder &, OperationState &result,
+void fir::GenTypeDescOp::build(mlir::OpBuilder &, mlir::OperationState &result,
                                mlir::TypeAttr inty) {
   result.addAttribute("in_type", inty);
   result.addTypes(TypeDescType::get(inty.getValue()));
 }
 
-mlir::ParseResult GenTypeDescOp::parse(mlir::OpAsmParser &parser,
+mlir::ParseResult fir::GenTypeDescOp::parse(mlir::OpAsmParser &parser,
                                             mlir::OperationState &result) {
   mlir::Type intype;
   if (parser.parseType(intype))
     return mlir::failure();
   result.addAttribute("in_type", mlir::TypeAttr::get(intype));
-  mlir::Type restype = TypeDescType::get(intype);
+  mlir::Type restype = fir::TypeDescType::get(intype);
   if (parser.addTypeToList(restype, result.types))
     return mlir::failure();
   return mlir::success();
 }
 
-void GenTypeDescOp::print(mlir::OpAsmPrinter &p) {
+void fir::GenTypeDescOp::print(mlir::OpAsmPrinter &p) {
   p << ' ' << getOperation()->getAttr("in_type");
   p.printOptionalAttrDict(getOperation()->getAttrs(), {"in_type"});
 }
 
-mlir::LogicalResult GenTypeDescOp::verify() {
+mlir::LogicalResult fir::GenTypeDescOp::verify() {
   mlir::Type resultTy = getType();
-  if (auto tdesc = resultTy.dyn_cast<TypeDescType>()) {
+  if (auto tdesc = resultTy.dyn_cast<fir::TypeDescType>()) {
     if (tdesc.getOfTy() != getInType())
       return emitOpError("wrapped type mismatched");
-  } else {
-    return emitOpError("must be !fir.tdesc type");
-  }
     return mlir::success();
   }
+  return emitOpError("must be !fir.tdesc type");
+}
 
 //===----------------------------------------------------------------------===//
 // GlobalOp
 //===----------------------------------------------------------------------===//
 
 mlir::Type fir::GlobalOp::resultType() {
   return wrapAllocaResultType(getType());
 }
 
-ParseResult GlobalOp::parse(OpAsmParser &parser, OperationState &result) {
+mlir::ParseResult fir::GlobalOp::parse(mlir::OpAsmParser &parser,
+                                       mlir::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);
   }
 
   // Parse the name as a symbol reference attribute.
   mlir::SymbolRefAttr nameAttr;
   if (parser.parseAttribute(nameAttr, fir::GlobalOp::symbolAttrNameStr(),
                             result.attributes))
     return mlir::failure();
   result.addAttribute(mlir::SymbolTable::getSymbolAttrName(),
                       nameAttr.getRootReference());
 
   bool simpleInitializer = false;
   if (mlir::succeeded(parser.parseOptionalLParen())) {
-    Attribute attr;
+    mlir::Attribute attr;
     if (parser.parseAttribute(attr, "initVal", result.attributes) ||
         parser.parseRParen())
       return mlir::failure();
     simpleInitializer = true;
   }
 
   if (succeeded(parser.parseOptionalKeyword("constant"))) {
     // if "constant" keyword then mark this as a constant, not a variable
if (simpleInitializer) {
     result.addRegion();
   } else {
     // Parse the optional initializer body.
     auto parseResult = parser.parseOptionalRegion(
         *result.addRegion(), /*arguments=*/llvm::None, /*argTypes=*/llvm::None);
     if (parseResult.hasValue() && mlir::failed(*parseResult))
       return mlir::failure();
   }
-
   return mlir::success();
 }
 
-void GlobalOp::print(mlir::OpAsmPrinter &p) {
+void fir::GlobalOp::print(mlir::OpAsmPrinter &p) {
   if (getLinkName().hasValue())
     p << ' ' << getLinkName().getValue();
   p << ' ';
   p.printAttributeWithoutType(getSymrefAttr());
   if (auto val = getValueOrNull())
     p << '(' << val << ')';
   if (getOperation()->getAttr(fir::GlobalOp::getConstantAttrNameStr()))
     p << " constant";
   p << " : ";
   p.printType(getType());
   if (hasInitializationBody()) {
     p << ' ';
     p.printRegion(getOperation()->getRegion(0),
                   /*printEntryBlockArgs=*/false,
                   /*printBlockTerminators=*/true);
   }
 }
 
 void fir::GlobalOp::appendInitialValue(mlir::Operation *op) {
   getBlock().getOperations().push_back(op);
 }
 
-void fir::GlobalOp::build(mlir::OpBuilder &builder, OperationState &result,
-                          StringRef name, bool isConstant, Type type,
-                          Attribute initialVal, StringAttr linkage,
-                          ArrayRef<NamedAttribute> attrs) {
+void fir::GlobalOp::build(mlir::OpBuilder &builder,
+                          mlir::OperationState &result, llvm::StringRef name,
+                          bool isConstant, mlir::Type type,
+                          mlir::Attribute initialVal, mlir::StringAttr linkage,
+                          llvm::ArrayRef<mlir::NamedAttribute> attrs) {
   result.addRegion();
   result.addAttribute(getTypeAttrName(result.name), mlir::TypeAttr::get(type));
   result.addAttribute(mlir::SymbolTable::getSymbolAttrName(),
                       builder.getStringAttr(name));
   result.addAttribute(symbolAttrNameStr(),
-                      SymbolRefAttr::get(builder.getContext(), name));
+                      mlir::SymbolRefAttr::get(builder.getContext(), name));
   if (isConstant)
     result.addAttribute(getConstantAttrName(result.name),
                         builder.getUnitAttr());
   if (initialVal)
     result.addAttribute(getInitValAttrName(result.name), initialVal);
   if (linkage)
     result.addAttribute(linkageAttrName(), linkage);
   result.attributes.append(attrs.begin(), attrs.end());
 }
 
-void fir::GlobalOp::build(mlir::OpBuilder &builder, OperationState &result,
-                          StringRef name, Type type, Attribute initialVal,
-                          StringAttr linkage, ArrayRef<NamedAttribute> attrs) {
+void fir::GlobalOp::build(mlir::OpBuilder &builder,
+                          mlir::OperationState &result, llvm::StringRef name,
+                          mlir::Type type, mlir::Attribute initialVal,
+                          mlir::StringAttr linkage,
+                          llvm::ArrayRef<mlir::NamedAttribute> attrs) {
   build(builder, result, name, /*isConstant=*/false, type, {}, linkage, attrs);
 }
 
-void fir::GlobalOp::build(mlir::OpBuilder &builder, OperationState &result,
-                          StringRef name, bool isConstant, Type type,
-                          StringAttr linkage, ArrayRef<NamedAttribute> attrs) {
+void fir::GlobalOp::build(mlir::OpBuilder &builder,
+                          mlir::OperationState &result, llvm::StringRef name,
+                          bool isConstant, mlir::Type type,
+                          mlir::StringAttr linkage,
+                          llvm::ArrayRef<mlir::NamedAttribute> attrs) {
   build(builder, result, name, isConstant, type, {}, linkage, attrs);
 }
 
-void fir::GlobalOp::build(mlir::OpBuilder &builder, OperationState &result,
-                          StringRef name, Type type, StringAttr linkage,
-                          ArrayRef<NamedAttribute> attrs) {
+void fir::GlobalOp::build(mlir::OpBuilder &builder,
+                          mlir::OperationState &result, llvm::StringRef name,
+                          mlir::Type type, mlir::StringAttr linkage,
+                          llvm::ArrayRef<mlir::NamedAttribute> attrs) {
   build(builder, result, name, /*isConstant=*/false, type, {}, linkage, attrs);
 }
 
-void fir::GlobalOp::build(mlir::OpBuilder &builder, OperationState &result,
-                          StringRef name, bool isConstant, Type type,
-                          ArrayRef<NamedAttribute> attrs) {
-  build(builder, result, name, isConstant, type, StringAttr{}, attrs);
+void fir::GlobalOp::build(mlir::OpBuilder &builder,
+                          mlir::OperationState &result, llvm::StringRef name,
+                          bool isConstant, mlir::Type type,
+                          llvm::ArrayRef<mlir::NamedAttribute> attrs) {
+  build(builder, result, name, isConstant, type, mlir::StringAttr{}, attrs);
 }
 
-void fir::GlobalOp::build(mlir::OpBuilder &builder, OperationState &result,
-                          StringRef name, Type type,
-                          ArrayRef<NamedAttribute> attrs) {
+void fir::GlobalOp::build(mlir::OpBuilder &builder,
+                          mlir::OperationState &result, llvm::StringRef name,
+                          mlir::Type type,
+                          llvm::ArrayRef<mlir::NamedAttribute> attrs) {
   build(builder, result, name, /*isConstant=*/false, type, attrs);
 }
 
-mlir::ParseResult fir::GlobalOp::verifyValidLinkage(StringRef linkage) {
+mlir::ParseResult fir::GlobalOp::verifyValidLinkage(llvm::StringRef linkage) {
   // Supporting only a subset of the LLVM linkage types for now
   static const char *validNames[] = {"common", "internal", "linkonce",
                                      "linkonce_odr", "weak"};
   return mlir::success(llvm::is_contained(validNames, linkage));
 }
 
 //===----------------------------------------------------------------------===//
 // GlobalLenOp
 //===----------------------------------------------------------------------===//
 
-mlir::ParseResult GlobalLenOp::parse(mlir::OpAsmParser &parser,
+mlir::ParseResult fir::GlobalLenOp::parse(mlir::OpAsmParser &parser,
                                           mlir::OperationState &result) {
   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();
 }
 
-void GlobalLenOp::print(mlir::OpAsmPrinter &p) {
+void fir::GlobalLenOp::print(mlir::OpAsmPrinter &p) {
   p << ' ' << getOperation()->getAttr(fir::GlobalLenOp::lenParamAttrName())
     << ", " << getOperation()->getAttr(fir::GlobalLenOp::intAttrName());
 }
 
 //===----------------------------------------------------------------------===//
 // FieldIndexOp
 //===----------------------------------------------------------------------===//
 
-mlir::ParseResult FieldIndexOp::parse(mlir::OpAsmParser &parser,
+mlir::ParseResult fir::FieldIndexOp::parse(mlir::OpAsmParser &parser,
                                            mlir::OperationState &result) {
   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 (!recty.dyn_cast<RecordType>())
+  if (!recty.dyn_cast<fir::RecordType>())
     return mlir::failure();
   result.addAttribute(fir::FieldIndexOp::typeAttrName(),
                       mlir::TypeAttr::get(recty));
   if (!parser.parseOptionalLParen()) {
     llvm::SmallVector<mlir::OpAsmParser::UnresolvedOperand> operands;
     llvm::SmallVector<mlir::Type> types;
     auto loc = parser.getNameLoc();
     if (parser.parseOperandList(operands, mlir::OpAsmParser::Delimiter::None) ||
         parser.parseColonTypeList(types) || parser.parseRParen() ||
         parser.resolveOperands(operands, types, loc, result.operands))
       return mlir::failure();
   }
   mlir::Type fieldType = fir::FieldType::get(builder.getContext());
   if (parser.addTypeToList(fieldType, result.types))
     return mlir::failure();
   return mlir::success();
 }
 
-void FieldIndexOp::print(mlir::OpAsmPrinter &p) {
+void fir::FieldIndexOp::print(mlir::OpAsmPrinter &p) {
   p << ' '
     << getOperation()
            ->getAttrOfType<mlir::StringAttr>(fir::FieldIndexOp::fieldAttrName())
            .getValue()
     << ", " << getOperation()->getAttr(fir::FieldIndexOp::typeAttrName());
   if (getNumOperands()) {
     p << '(';
     p.printOperands(getTypeparams());
void fir::FieldIndexOp::print(mlir::OpAsmPrinter &p) {
   }
 }
 
 void fir::FieldIndexOp::build(mlir::OpBuilder &builder,
                               mlir::OperationState &result,
                               llvm::StringRef fieldName, mlir::Type recTy,
                               mlir::ValueRange operands) {
   result.addAttribute(fieldAttrName(), builder.getStringAttr(fieldName));
-  result.addAttribute(typeAttrName(), TypeAttr::get(recTy));
+  result.addAttribute(typeAttrName(), mlir::TypeAttr::get(recTy));
   result.addOperands(operands);
 }
 
 llvm::SmallVector<mlir::Attribute> fir::FieldIndexOp::getAttributes() {
   llvm::SmallVector<mlir::Attribute> attrs;
   attrs.push_back(getFieldIdAttr());
   attrs.push_back(getOnTypeAttr());
   return attrs;
 }
 
 //===----------------------------------------------------------------------===//
 // InsertOnRangeOp
 //===----------------------------------------------------------------------===//
 
-static ParseResult
+static mlir::ParseResult
 parseCustomRangeSubscript(mlir::OpAsmParser &parser,
                           mlir::DenseIntElementsAttr &coord) {
-  llvm::SmallVector<int64_t> lbounds;
-  llvm::SmallVector<int64_t> ubounds;
+  llvm::SmallVector<std::int64_t> lbounds;
+  llvm::SmallVector<std::int64_t> ubounds;
   if (parser.parseKeyword("from") ||
       parser.parseCommaSeparatedList(
-          AsmParser::Delimiter::Paren,
+          mlir::AsmParser::Delimiter::Paren,
           [&] { return parser.parseInteger(lbounds.emplace_back(0)); }) ||
       parser.parseKeyword("to") ||
-      parser.parseCommaSeparatedList(AsmParser::Delimiter::Paren, [&] {
+      parser.parseCommaSeparatedList(mlir::AsmParser::Delimiter::Paren, [&] {
         return parser.parseInteger(ubounds.emplace_back(0));
       }))
-    return failure();
-  llvm::SmallVector<int64_t> zippedBounds;
+    return mlir::failure();
+  llvm::SmallVector<std::int64_t> zippedBounds;
   for (auto zip : llvm::zip(lbounds, ubounds)) {
     zippedBounds.push_back(std::get<0>(zip));
     zippedBounds.push_back(std::get<1>(zip));
   }
   coord = mlir::Builder(parser.getContext()).getIndexTensorAttr(zippedBounds);
-  return success();
+  return mlir::success();
 }
 
-void printCustomRangeSubscript(mlir::OpAsmPrinter &printer, InsertOnRangeOp op,
+static void printCustomRangeSubscript(mlir::OpAsmPrinter &printer,
+                                      fir::InsertOnRangeOp op,
                                       mlir::DenseIntElementsAttr coord) {
   printer << "from (";
-  auto enumerate = llvm::enumerate(coord.getValues<int64_t>());
+  auto enumerate = llvm::enumerate(coord.getValues<std::int64_t>());
   // Even entries are the lower bounds.
   llvm::interleaveComma(
       make_filter_range(
           enumerate,
           [](auto indexed_value) { return indexed_value.index() % 2 == 0; }),
       printer, [&](auto indexed_value) { printer << indexed_value.value(); });
   printer << ") to (";
   // Odd entries are the upper bounds.
   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.
-mlir::LogicalResult InsertOnRangeOp::verify() {
+mlir::LogicalResult fir::InsertOnRangeOp::verify() {
   if (fir::hasDynamicSize(getSeq().getType()))
     return emitOpError("must have constant shape and size");
   mlir::DenseIntElementsAttr coorAttr = getCoor();
   if (coorAttr.size() < 2 || coorAttr.size() % 2 != 0)
     return emitOpError("has uneven number of values in ranges");
   bool rangeIsKnownToBeNonempty = false;
-  for (auto i = coorAttr.getValues<int64_t>().end(),
-            b = coorAttr.getValues<int64_t>().begin();
+  for (auto i = coorAttr.getValues<std::int64_t>().end(),
+            b = coorAttr.getValues<std::int64_t>().begin();
        i != b;) {
     int64_t ub = (*--i);
     int64_t lb = (*--i);
     if (lb < 0 || ub < 0)
       return emitOpError("negative range bound");
     if (rangeIsKnownToBeNonempty)
       continue;
     if (lb > ub)
       return emitOpError("empty range");
     rangeIsKnownToBeNonempty = lb < ub;
   }
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // InsertValueOp
 //===----------------------------------------------------------------------===//
 
-static bool checkIsIntegerConstant(mlir::Attribute attr, int64_t conVal) {
+static bool checkIsIntegerConstant(mlir::Attribute attr, std::int64_t conVal) {
   if (auto iattr = attr.dyn_cast<mlir::IntegerAttr>())
     return iattr.getInt() == conVal;
   return false;
 }
+
 static bool isZero(mlir::Attribute a) { return checkIsIntegerConstant(a, 0); }
 static bool isOne(mlir::Attribute a) { return checkIsIntegerConstant(a, 1); }
 
 // Undo some complex patterns created in the front-end and turn them back into
 // complex ops.
 template <typename FltOp, typename CpxOp>
 struct UndoComplexPattern : public mlir::RewritePattern {
   UndoComplexPattern(mlir::MLIRContext *ctx)
       : mlir::RewritePattern("fir.insert_value", 2, ctx) {}
 
   mlir::LogicalResult
   matchAndRewrite(mlir::Operation *op,
                   mlir::PatternRewriter &rewriter) const override {
-    auto insval = dyn_cast_or_null<fir::InsertValueOp>(op);
+    auto insval = mlir::dyn_cast_or_null<fir::InsertValueOp>(op);
     if (!insval || !insval.getType().isa<fir::ComplexType>())
       return mlir::failure();
-    auto insval2 =
-        dyn_cast_or_null<fir::InsertValueOp>(insval.getAdt().getDefiningOp());
-    if (!insval2 || !isa<fir::UndefOp>(insval2.getAdt().getDefiningOp()))
-      return mlir::failure();
-    auto binf = dyn_cast_or_null<FltOp>(insval.getVal().getDefiningOp());
-    auto binf2 = dyn_cast_or_null<FltOp>(insval2.getVal().getDefiningOp());
+    auto insval2 = mlir::dyn_cast_or_null<fir::InsertValueOp>(
+        insval.getAdt().getDefiningOp());
+    if (!insval2 || !mlir::isa<fir::UndefOp>(insval2.getAdt().getDefiningOp()))
+      return mlir::failure();
+    auto binf = mlir::dyn_cast_or_null<FltOp>(insval.getVal().getDefiningOp());
+    auto binf2 =
+        mlir::dyn_cast_or_null<FltOp>(insval2.getVal().getDefiningOp());
     if (!binf || !binf2 || insval.getCoor().size() != 1 ||
         !isOne(insval.getCoor()[0]) || insval2.getCoor().size() != 1 ||
         !isZero(insval2.getCoor()[0]))
       return mlir::failure();
-    auto eai =
-        dyn_cast_or_null<fir::ExtractValueOp>(binf.getLhs().getDefiningOp());
-    auto ebi =
-        dyn_cast_or_null<fir::ExtractValueOp>(binf.getRhs().getDefiningOp());
-    auto ear =
-        dyn_cast_or_null<fir::ExtractValueOp>(binf2.getLhs().getDefiningOp());
-    auto ebr =
-        dyn_cast_or_null<fir::ExtractValueOp>(binf2.getRhs().getDefiningOp());
+    auto eai = mlir::dyn_cast_or_null<fir::ExtractValueOp>(
+        binf.getLhs().getDefiningOp());
+    auto ebi = mlir::dyn_cast_or_null<fir::ExtractValueOp>(
+        binf.getRhs().getDefiningOp());
+    auto ear = mlir::dyn_cast_or_null<fir::ExtractValueOp>(
+        binf2.getLhs().getDefiningOp());
+    auto ebr = mlir::dyn_cast_or_null<fir::ExtractValueOp>(
+        binf2.getRhs().getDefiningOp());
     if (!eai || !ebi || !ear || !ebr || ear.getAdt() != eai.getAdt() ||
         ebr.getAdt() != ebi.getAdt() || eai.getCoor().size() != 1 ||
         !isOne(eai.getCoor()[0]) || ebi.getCoor().size() != 1 ||
         !isOne(ebi.getCoor()[0]) || ear.getCoor().size() != 1 ||
         !isZero(ear.getCoor()[0]) || ebr.getCoor().size() != 1 ||
         !isZero(ebr.getCoor()[0]))
       return mlir::failure();
     rewriter.replaceOpWithNewOp<CpxOp>(op, ear.getAdt(), ebr.getAdt());
if (finalCountValue) {
     result.addTypes(builder.getIndexType());
     result.addAttribute(getFinalValueAttrNameStr(), builder.getUnitAttr());
   }
   result.addTypes(iterate.getType());
   result.addOperands(iterArgs);
   for (auto v : iterArgs)
     result.addTypes(v.getType());
   mlir::Region *bodyRegion = result.addRegion();
-  bodyRegion->push_back(new Block{});
+  bodyRegion->push_back(new mlir::Block{});
   bodyRegion->front().addArgument(builder.getIndexType(), result.location);
   bodyRegion->front().addArgument(iterate.getType(), result.location);
   bodyRegion->front().addArguments(
       iterArgs.getTypes(),
-      SmallVector<Location>(iterArgs.size(), result.location));
+      llvm::SmallVector<mlir::Location>(iterArgs.size(), result.location));
   result.addAttributes(attributes);
 }
 
-mlir::ParseResult IterWhileOp::parse(mlir::OpAsmParser &parser,
+mlir::ParseResult fir::IterWhileOp::parse(mlir::OpAsmParser &parser,
                                           mlir::OperationState &result) {
   auto &builder = parser.getBuilder();
   mlir::OpAsmParser::UnresolvedOperand inductionVariable, lb, ub, step;
   if (parser.parseLParen() || parser.parseRegionArgument(inductionVariable) ||
       parser.parseEqual())
     return mlir::failure();
 
   // Parse loop bounds.
   auto indexType = builder.getIndexType();
mlir::ParseResult fir::IterWhileOp::parse(mlir::OpAsmParser &parser,
   regionArgs.push_back(iterateVar);
 
   if (succeeded(parser.parseOptionalKeyword("iter_args"))) {
     llvm::SmallVector<mlir::OpAsmParser::UnresolvedOperand> operands;
     llvm::SmallVector<mlir::Type> regionTypes;
     // Parse assignment list and results type list.
     if (parser.parseAssignmentList(regionArgs, operands) ||
         parser.parseArrowTypeList(regionTypes))
-      return failure();
+      return mlir::failure();
     if (regionTypes.size() == operands.size() + 2)
       prependCount = true;
     llvm::ArrayRef<mlir::Type> resTypes = regionTypes;
     resTypes = prependCount ? resTypes.drop_front(2) : resTypes;
     // Resolve input operands.
     for (auto operandType : llvm::zip(operands, resTypes))
       if (parser.resolveOperand(std::get<0>(operandType),
                                 std::get<1>(operandType), result.operands))
-        return failure();
+        return mlir::failure();
     if (prependCount) {
       result.addTypes(regionTypes);
     } else {
       result.addTypes(i1Type);
       result.addTypes(resTypes);
     }
   } else if (succeeded(parser.parseOptionalArrow())) {
     llvm::SmallVector<mlir::Type> typeList;
     if (parser.parseLParen() || parser.parseTypeList(typeList) ||
         parser.parseRParen())
-      return failure();
+      return mlir::failure();
     // Type list must be "(index, i1)".
     if (typeList.size() != 2 || !typeList[0].isa<mlir::IndexType>() ||
         !typeList[1].isSignlessInteger(1))
-      return failure();
+      return mlir::failure();
     result.addTypes(typeList);
     prependCount = true;
   } else {
     result.addTypes(i1Type);
   }
 
   if (parser.parseOptionalAttrDictWithKeyword(result.attributes))
     return mlir::failure();
mlir::ParseResult fir::IterWhileOp::parse(mlir::OpAsmParser &parser,
   // Parse the body region.
   auto *body = result.addRegion();
   if (regionArgs.size() != argTypes.size())
     return parser.emitError(
         parser.getNameLoc(),
         "mismatch in number of loop-carried values and defined values");
 
   if (parser.parseRegion(*body, regionArgs, argTypes))
-    return failure();
+    return mlir::failure();
 
   fir::IterWhileOp::ensureTerminator(*body, builder, result.location);
-
   return mlir::success();
 }
 
-mlir::LogicalResult IterWhileOp::verify() {
+mlir::LogicalResult fir::IterWhileOp::verify() {
   // Check that the body defines as single block argument for the induction
   // variable.
   auto *body = getBody();
   if (!body->getArgument(1).getType().isInteger(1))
     return emitOpError(
         "expected body second argument to be an index argument for "
         "the induction variable");
   if (!body->getArgument(0).getType().isIndex())
if (getNumIterOperands() != opNumResults)
     return emitOpError(
         "mismatch in number of loop-carried values and defined values");
   if (getNumRegionIterArgs() != opNumResults)
     return emitOpError(
         "mismatch in number of basic block args and defined values");
   auto iterOperands = getIterOperands();
   auto iterArgs = getRegionIterArgs();
   auto opResults = getFinalValue() ? getResults().drop_front() : getResults();
-  unsigned i = 0;
+  unsigned i = 0u;
   for (auto e : llvm::zip(iterOperands, iterArgs, opResults)) {
     if (std::get<0>(e).getType() != std::get<2>(e).getType())
       return emitOpError() << "types mismatch between " << i
                            << "th iter operand and defined value";
     if (std::get<1>(e).getType() != std::get<2>(e).getType())
       return emitOpError() << "types mismatch between " << i
                            << "th iter region arg and defined value";
 
     i++;
   }
   return mlir::success();
 }
 
-void IterWhileOp::print(mlir::OpAsmPrinter &p) {
+void fir::IterWhileOp::print(mlir::OpAsmPrinter &p) {
   p << " (" << getInductionVar() << " = " << getLowerBound() << " to "
     << getUpperBound() << " step " << getStep() << ") and (";
   assert(hasIterOperands());
   auto regionArgs = getRegionIterArgs();
   auto operands = getIterOperands();
   p << regionArgs.front() << " = " << *operands.begin() << ")";
   if (regionArgs.size() > 1) {
     p << " iter_args(";
if (blockArgNum > 0 && blockArgNum <= getInitArgs().size())
     return getInitArgs()[blockArgNum - 1];
   return {};
 }
 
 //===----------------------------------------------------------------------===//
 // LenParamIndexOp
 //===----------------------------------------------------------------------===//
 
-mlir::ParseResult LenParamIndexOp::parse(mlir::OpAsmParser &parser,
+mlir::ParseResult fir::LenParamIndexOp::parse(mlir::OpAsmParser &parser,
                                               mlir::OperationState &result) {
   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>())
+  if (!recty.dyn_cast<fir::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();
 }
 
-void LenParamIndexOp::print(mlir::OpAsmPrinter &p) {
+void fir::LenParamIndexOp::print(mlir::OpAsmPrinter &p) {
   p << ' '
     << getOperation()
            ->getAttrOfType<mlir::StringAttr>(
                fir::LenParamIndexOp::fieldAttrName())
            .getValue()
     << ", " << getOperation()->getAttr(fir::LenParamIndexOp::typeAttrName());
 }
 

 }
 
 mlir::ParseResult fir::LoadOp::getElementOf(mlir::Type &ele, mlir::Type ref) {
   if ((ele = fir::dyn_cast_ptrEleTy(ref)))
     return mlir::success();
   return mlir::failure();
 }
 
-mlir::ParseResult LoadOp::parse(mlir::OpAsmParser &parser,
+mlir::ParseResult fir::LoadOp::parse(mlir::OpAsmParser &parser,
                                      mlir::OperationState &result) {
   mlir::Type type;
   mlir::OpAsmParser::UnresolvedOperand 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();
 }
 
-void LoadOp::print(mlir::OpAsmPrinter &p) {
+void fir::LoadOp::print(mlir::OpAsmPrinter &p) {
   p << ' ';
   p.printOperand(getMemref());
   p.printOptionalAttrDict(getOperation()->getAttrs(), {});
   p << " : " << getMemref().getType();
 }
 
 //===----------------------------------------------------------------------===//
 // DoLoopOp
void fir::DoLoopOp::build(mlir::OpBuilder &builder,
   if (finalCountValue) {
     result.addTypes(builder.getIndexType());
     result.addAttribute(getFinalValueAttrName(result.name),
                         builder.getUnitAttr());
   }
   for (auto v : iterArgs)
     result.addTypes(v.getType());
   mlir::Region *bodyRegion = result.addRegion();
-  bodyRegion->push_back(new Block{});
+  bodyRegion->push_back(new mlir::Block{});
   if (iterArgs.empty() && !finalCountValue)
-    DoLoopOp::ensureTerminator(*bodyRegion, builder, result.location);
+    fir::DoLoopOp::ensureTerminator(*bodyRegion, builder, result.location);
   bodyRegion->front().addArgument(builder.getIndexType(), result.location);
   bodyRegion->front().addArguments(
       iterArgs.getTypes(),
-      SmallVector<Location>(iterArgs.size(), result.location));
+      llvm::SmallVector<mlir::Location>(iterArgs.size(), result.location));
   if (unordered)
     result.addAttribute(getUnorderedAttrName(result.name),
                         builder.getUnitAttr());
   result.addAttributes(attributes);
 }
 
-mlir::ParseResult DoLoopOp::parse(mlir::OpAsmParser &parser,
+mlir::ParseResult fir::DoLoopOp::parse(mlir::OpAsmParser &parser,
                                        mlir::OperationState &result) {
   auto &builder = parser.getBuilder();
   mlir::OpAsmParser::UnresolvedOperand inductionVariable, lb, ub, step;
   // Parse the induction variable followed by '='.
   if (parser.parseRegionArgument(inductionVariable) || parser.parseEqual())
     return mlir::failure();
 
   // Parse loop bounds.
   auto indexType = builder.getIndexType();
   if (parser.parseOperand(lb) ||
       parser.resolveOperand(lb, indexType, result.operands) ||
       parser.parseKeyword("to") || parser.parseOperand(ub) ||
       parser.resolveOperand(ub, indexType, result.operands) ||
       parser.parseKeyword("step") || parser.parseOperand(step) ||
       parser.resolveOperand(step, indexType, result.operands))
-    return failure();
+    return mlir::failure();
 
   if (mlir::succeeded(parser.parseOptionalKeyword("unordered")))
     result.addAttribute("unordered", builder.getUnitAttr());
 
   // Parse the optional initial iteration arguments.
   llvm::SmallVector<mlir::OpAsmParser::UnresolvedOperand> regionArgs, operands;
   llvm::SmallVector<mlir::Type> argTypes;
-  auto prependCount = false;
+  bool prependCount = false;
   regionArgs.push_back(inductionVariable);
 
   if (succeeded(parser.parseOptionalKeyword("iter_args"))) {
     // Parse assignment list and results type list.
     if (parser.parseAssignmentList(regionArgs, operands) ||
         parser.parseArrowTypeList(result.types))
-      return failure();
+      return mlir::failure();
     if (result.types.size() == operands.size() + 1)
       prependCount = true;
     // Resolve input operands.
     llvm::ArrayRef<mlir::Type> resTypes = result.types;
     for (auto operand_type :
          llvm::zip(operands, prependCount ? resTypes.drop_front() : resTypes))
       if (parser.resolveOperand(std::get<0>(operand_type),
                                 std::get<1>(operand_type), result.operands))
-        return failure();
+        return mlir::failure();
   } else if (succeeded(parser.parseOptionalArrow())) {
     if (parser.parseKeyword("index"))
-      return failure();
+      return mlir::failure();
     result.types.push_back(indexType);
     prependCount = true;
   }
 
   if (parser.parseOptionalAttrDictWithKeyword(result.attributes))
     return mlir::failure();
 
   // Induction variable.
   if (prependCount)
     result.addAttribute(DoLoopOp::getFinalValueAttrName(result.name),
                         builder.getUnitAttr());
   else
     argTypes.push_back(indexType);
   // Loop carried variables
   argTypes.append(result.types.begin(), result.types.end());
   // Parse the body region.
   auto *body = result.addRegion();
   if (regionArgs.size() != argTypes.size())
     return parser.emitError(
         parser.getNameLoc(),
         "mismatch in number of loop-carried values and defined values");
 
   if (parser.parseRegion(*body, regionArgs, argTypes))
-    return failure();
+    return mlir::failure();
 
   DoLoopOp::ensureTerminator(*body, builder, result.location);
 
   return mlir::success();
 }
 
 fir::DoLoopOp fir::getForInductionVarOwner(mlir::Value val) {
   auto ivArg = val.dyn_cast<mlir::BlockArgument>();
   if (!ivArg)
     return {};
   assert(ivArg.getOwner() && "unlinked block argument");
   auto *containingInst = ivArg.getOwner()->getParentOp();
-  return dyn_cast_or_null<fir::DoLoopOp>(containingInst);
+  return mlir::dyn_cast_or_null<fir::DoLoopOp>(containingInst);
 }
 
 // Lifted from loop.loop
-mlir::LogicalResult DoLoopOp::verify() {
+mlir::LogicalResult fir::DoLoopOp::verify() {
   // Check that the body defines as single block argument for the induction
   // variable.
   auto *body = getBody();
   if (!body->getArgument(0).getType().isIndex())
     return emitOpError(
         "expected body first argument to be an index argument for "
         "the induction variable");
 
   auto opNumResults = getNumResults();
   if (opNumResults == 0)
-    return success();
+    return mlir::success();
 
   if (getFinalValue()) {
     if (getUnordered())
       return emitOpError("unordered loop has no final value");
     opNumResults--;
   }
   if (getNumIterOperands() != opNumResults)
     return emitOpError(
         "mismatch in number of loop-carried values and defined values");
   if (getNumRegionIterArgs() != opNumResults)
     return emitOpError(
         "mismatch in number of basic block args and defined values");
   auto iterOperands = getIterOperands();
   auto iterArgs = getRegionIterArgs();
   auto opResults = getFinalValue() ? getResults().drop_front() : getResults();
-  unsigned i = 0;
+  unsigned i = 0u;
   for (auto e : llvm::zip(iterOperands, iterArgs, opResults)) {
     if (std::get<0>(e).getType() != std::get<2>(e).getType())
       return emitOpError() << "types mismatch between " << i
                            << "th iter operand and defined value";
     if (std::get<1>(e).getType() != std::get<2>(e).getType())
       return emitOpError() << "types mismatch between " << i
                            << "th iter region arg and defined value";
 
     i++;
   }
-  return success();
+  return mlir::success();
 }
 
-void DoLoopOp::print(mlir::OpAsmPrinter &p) {
+void fir::DoLoopOp::print(mlir::OpAsmPrinter &p) {
   bool printBlockTerminators = false;
   p << ' ' << getInductionVar() << " = " << getLowerBound() << " to "
     << getUpperBound() << " step " << getStep();
   if (getUnordered())
     p << " unordered";
   if (hasIterOperands()) {
     p << " iter_args(";
     auto regionArgs = getRegionIterArgs();
if (blockArgNum > 0 && blockArgNum <= getInitArgs().size())
     return getInitArgs()[blockArgNum - 1];
   return {};
 }
 
 //===----------------------------------------------------------------------===//
 // DTEntryOp
 //===----------------------------------------------------------------------===//
 
-mlir::ParseResult DTEntryOp::parse(mlir::OpAsmParser &parser,
+mlir::ParseResult fir::DTEntryOp::parse(mlir::OpAsmParser &parser,
                                         mlir::OperationState &result) {
   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();
 }
 
-void DTEntryOp::print(mlir::OpAsmPrinter &p) {
+void fir::DTEntryOp::print(mlir::OpAsmPrinter &p) {
   p << ' ' << getMethodAttr() << ", " << getProcAttr();
 }
 
 //===----------------------------------------------------------------------===//
 // ReboxOp
 //===----------------------------------------------------------------------===//
 
 /// Get the scalar type related to a fir.box type.
static bool areCompatibleCharacterTypes(mlir::Type t1, mlir::Type t2) {
   auto c2 = t2.dyn_cast<fir::CharacterType>();
   if (!c1 || !c2)
     return false;
   if (c1.hasDynamicLen() || c2.hasDynamicLen())
     return true;
   return c1.getLen() == c2.getLen();
 }
 
-mlir::LogicalResult ReboxOp::verify() {
+mlir::LogicalResult fir::ReboxOp::verify() {
   auto inputBoxTy = getBox().getType();
   if (fir::isa_unknown_size_box(inputBoxTy))
     return emitOpError("box operand must not have unknown rank or type");
   auto outBoxTy = getType();
   if (fir::isa_unknown_size_box(outBoxTy))
     return emitOpError("result type must not have unknown rank or type");
   auto inputRank = getBoxRank(inputBoxTy);
   auto inputEleTy = getBoxScalarEleTy(inputBoxTy);
mlir::LogicalResult fir::ReboxOp::verify() {
   }
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // ResultOp
 //===----------------------------------------------------------------------===//
 
-mlir::LogicalResult ResultOp::verify() {
+mlir::LogicalResult fir::ResultOp::verify() {
   auto *parentOp = (*this)->getParentOp();
   auto results = parentOp->getResults();
   auto operands = (*this)->getOperands();
 
   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 emitOpError() << "types mismatch between result op and its parent";
-  return success();
+  return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // SaveResultOp
 //===----------------------------------------------------------------------===//
 
-mlir::LogicalResult SaveResultOp::verify() {
+mlir::LogicalResult fir::SaveResultOp::verify() {
   auto resultType = getValue().getType();
   if (resultType != fir::dyn_cast_ptrEleTy(getMemref().getType()))
     return emitOpError("value type must match memory reference type");
   if (fir::isa_unknown_size_box(resultType))
     return emitOpError("cannot save !fir.box of unknown rank or type");
 
   if (resultType.isa<fir::BoxType>()) {
     if (getShape() || !getTypeparams().empty())
static constexpr llvm::StringRef getCompareOffsetAttr() {
   return "compare_operand_offsets";
 }
 
 static constexpr llvm::StringRef getTargetOffsetAttr() {
   return "target_operand_offsets";
 }
 
 template <typename OpT>
-static LogicalResult verifyIntegralSwitchTerminator(OpT op) {
-  if (!(op.getSelector().getType().template isa<mlir::IntegerType>() ||
-        op.getSelector().getType().template isa<mlir::IndexType>() ||
-        op.getSelector().getType().template isa<fir::IntegerType>()))
+static mlir::LogicalResult verifyIntegralSwitchTerminator(OpT op) {
+  if (!op.getSelector()
+           .getType()
+           .template isa<mlir::IntegerType, mlir::IndexType,
+                         fir::IntegerType>())
     return op.emitOpError("must be an integer");
   auto cases =
       op->template getAttrOfType<mlir::ArrayAttr>(op.getCasesAttr()).getValue();
   auto count = op.getNumDest();
   if (count == 0)
     return op.emitOpError("must have at least one successor");
   if (op.getNumConditions() != count)
     return op.emitOpError("number of cases and targets don't match");
   if (op.targetOffsetSize() != count)
     return op.emitOpError("incorrect number of successor operand groups");
   for (decltype(count) i = 0; i != count; ++i) {
-    if (!(cases[i].template isa<mlir::IntegerAttr, mlir::UnitAttr>()))
+    if (!cases[i].template isa<mlir::IntegerAttr, mlir::UnitAttr>())
       return op.emitOpError("invalid case alternative");
   }
   return mlir::success();
 }
 
 static mlir::ParseResult parseIntegralSwitchTerminator(
     mlir::OpAsmParser &parser, mlir::OperationState &result,
     llvm::StringRef casesAttr, llvm::StringRef operandSegmentAttr) {
   mlir::OpAsmParser::UnresolvedOperand selector;
   mlir::Type type;
-  if (parseSelector(parser, result, selector, type))
+  if (fir::parseSelector(parser, result, selector, type))
     return mlir::failure();
 
   llvm::SmallVector<mlir::Attribute> ivalues;
   llvm::SmallVector<mlir::Block *> dests;
   llvm::SmallVector<llvm::SmallVector<mlir::Value>> destArgs;
   while (true) {
     mlir::Attribute ivalue; // Integer or Unit
     mlir::Block *dest;
static A getSubOperands(unsigned pos, A allArgs,
   for (unsigned i = 0; i < pos; ++i)
     start += (*(ranges.begin() + i)).getZExtValue();
   return allArgs.slice(start, (*(ranges.begin() + pos)).getZExtValue(),
                        std::forward<AdditionalArgs>(additionalArgs)...);
 }
 
 static mlir::MutableOperandRange
 getMutableSuccessorOperands(unsigned pos, mlir::MutableOperandRange operands,
-                            StringRef offsetAttr) {
-  Operation *owner = operands.getOwner();
-  NamedAttribute targetOffsetAttr =
+                            llvm::StringRef offsetAttr) {
+  mlir::Operation *owner = operands.getOwner();
+  mlir::NamedAttribute targetOffsetAttr =
       *owner->getAttrDictionary().getNamed(offsetAttr);
   return getSubOperands(
-      pos, operands, targetOffsetAttr.getValue().cast<DenseIntElementsAttr>(),
+      pos, operands,
+      targetOffsetAttr.getValue().cast<mlir::DenseIntElementsAttr>(),
       mlir::MutableOperandRange::OperandSegment(pos, targetOffsetAttr));
 }
 
 static unsigned denseElementsSize(mlir::DenseIntElementsAttr attr) {
   return attr.getNumElements();
 }
 
 llvm::Optional<mlir::OperandRange> fir::SelectOp::getCompareOperands(unsigned) {
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
-mlir::ParseResult SelectCaseOp::parse(mlir::OpAsmParser &parser,
+mlir::ParseResult fir::SelectCaseOp::parse(mlir::OpAsmParser &parser,
                                            mlir::OperationState &result) {
   mlir::OpAsmParser::UnresolvedOperand selector;
   mlir::Type type;
-  if (parseSelector(parser, result, selector, type))
+  if (fir::parseSelector(parser, result, selector, type))
     return mlir::failure();
 
   llvm::SmallVector<mlir::Attribute> attrs;
   llvm::SmallVector<mlir::OpAsmParser::UnresolvedOperand> opers;
   llvm::SmallVector<mlir::Block *> dests;
   llvm::SmallVector<llvm::SmallVector<mlir::Value>> destArgs;
-  llvm::SmallVector<int32_t> argOffs;
-  int32_t offSize = 0;
+  llvm::SmallVector<std::int32_t> argOffs;
+  std::int32_t offSize = 0;
   while (true) {
     mlir::Attribute attr;
     mlir::Block *dest;
     llvm::SmallVector<mlir::Value> destArg;
     mlir::NamedAttrList temp;
     if (parser.parseAttribute(attr, "a", temp) || isValidCaseAttr(attr) ||
         parser.parseComma())
       return mlir::failure();
mlir::ParseResult fir::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();
 }
 
-void SelectCaseOp::print(mlir::OpAsmPrinter &p) {
+void fir::SelectCaseOp::print(mlir::OpAsmPrinter &p) {
   p << ' ';
   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)
void fir::SelectCaseOp::build(mlir::OpBuilder &builder,
   for (auto ops : cmpOperands)
     result.addOperands(ops);
   result.addAttribute(getCompareOffsetAttr(),
                       builder.getI32VectorAttr(operOffs));
   const auto count = destinations.size();
   for (auto d : destinations)
     result.addSuccessors(d);
   const auto opCount = destOperands.size();
-  llvm::SmallVector<int32_t> argOffs;
-  int32_t sumArgs = 0;
+  llvm::SmallVector<std::int32_t> argOffs;
+  std::int32_t sumArgs = 0;
   for (std::remove_const_t<decltype(count)> i = 0; i != count; ++i) {
     if (i < opCount) {
       result.addOperands(destOperands[i]);
       const auto argSz = destOperands[i].size();
       argOffs.push_back(argSz);
       sumArgs += argSz;
     } else {
       argOffs.push_back(0);
void fir::SelectCaseOp::build(mlir::OpBuilder &builder,
                               llvm::ArrayRef<mlir::ValueRange> destOperands,
                               llvm::ArrayRef<mlir::NamedAttribute> attributes) {
   llvm::SmallVector<mlir::ValueRange> cmpOpers;
   auto iter = cmpOpList.begin();
   for (auto &attr : compareAttrs) {
     if (attr.isa<fir::ClosedIntervalAttr>()) {
       cmpOpers.push_back(mlir::ValueRange({iter, iter + 2}));
       iter += 2;
-    } else if (attr.isa<UnitAttr>()) {
+    } else if (attr.isa<mlir::UnitAttr>()) {
       cmpOpers.push_back(mlir::ValueRange{});
     } else {
       cmpOpers.push_back(mlir::ValueRange({iter, iter + 1}));
       ++iter;
     }
   }
   build(builder, result, selector, compareAttrs, cmpOpers, destinations,
         destOperands, attributes);
 }
 
-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>()))
+mlir::LogicalResult fir::SelectCaseOp::verify() {
+  if (!getSelector()
+           .getType()
+           .isa<mlir::IntegerType, mlir::IndexType, fir::IntegerType,
+                fir::LogicalType, 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 emitOpError("must have at least one successor");
   if (getNumConditions() != count)
     return emitOpError("number of conditions and successors don't match");
mlir::LogicalResult fir::SelectCaseOp::verify() {
   }
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // SelectRankOp
 //===----------------------------------------------------------------------===//
 
-LogicalResult fir::SelectRankOp::verify() {
+mlir::LogicalResult fir::SelectRankOp::verify() {
   return verifyIntegralSwitchTerminator(*this);
 }
 
 mlir::ParseResult fir::SelectRankOp::parse(mlir::OpAsmParser &parser,
                                            mlir::OperationState &result) {
   return parseIntegralSwitchTerminator(parser, result, getCasesAttr(),
                                        getOperandSegmentSizeAttr());
 }
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)};
 }
 
-ParseResult SelectTypeOp::parse(OpAsmParser &parser, OperationState &result) {
+mlir::ParseResult fir::SelectTypeOp::parse(mlir::OpAsmParser &parser,
+                                           mlir::OperationState &result) {
   mlir::OpAsmParser::UnresolvedOperand selector;
   mlir::Type type;
-  if (parseSelector(parser, result, selector, type))
+  if (fir::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;
   while (true) {
     mlir::Attribute attr;
     mlir::Block *dest;
mlir::ParseResult fir::SelectTypeOp::parse(mlir::OpAsmParser &parser,
   return mlir::success();
 }
 
 unsigned fir::SelectTypeOp::targetOffsetSize() {
   return denseElementsSize((*this)->getAttrOfType<mlir::DenseIntElementsAttr>(
       getTargetOffsetAttr()));
 }
 
-void SelectTypeOp::print(mlir::OpAsmPrinter &p) {
+void fir::SelectTypeOp::print(mlir::OpAsmPrinter &p) {
   p << ' ';
   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] << ", ";
     printSuccessorAtIndex(p, i);
   }
   p << ']';
   p.printOptionalAttrDict(getOperation()->getAttrs(),
                           {getCasesAttr(), getCompareOffsetAttr(),
                            getTargetOffsetAttr(),
                            fir::SelectTypeOp::getOperandSegmentSizeAttr()});
 }
 
-mlir::LogicalResult SelectTypeOp::verify() {
+mlir::LogicalResult fir::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 emitOpError("must have at least one successor");
   if (getNumConditions() != count)
void fir::SelectTypeOp::build(mlir::OpBuilder &builder,
   result.addAttribute(getTargetOffsetAttr(), builder.getI32VectorAttr(argOffs));
   result.addAttributes(attributes);
 }
 
 //===----------------------------------------------------------------------===//
 // ShapeOp
 //===----------------------------------------------------------------------===//
 
-mlir::LogicalResult ShapeOp::verify() {
+mlir::LogicalResult fir::ShapeOp::verify() {
   auto size = getExtents().size();
   auto shapeTy = getType().dyn_cast<fir::ShapeType>();
   assert(shapeTy && "must be a shape type");
   if (shapeTy.getRank() != size)
     return emitOpError("shape type rank mismatch");
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // ShapeShiftOp
 //===----------------------------------------------------------------------===//
 
-mlir::LogicalResult ShapeShiftOp::verify() {
+mlir::LogicalResult fir::ShapeShiftOp::verify() {
   auto size = getPairs().size();
   if (size < 2 || size > 16 * 2)
     return emitOpError("incorrect number of args");
   if (size % 2 != 0)
     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 emitOpError("shape type rank mismatch");
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // ShiftOp
 //===----------------------------------------------------------------------===//
 
-mlir::LogicalResult ShiftOp::verify() {
+mlir::LogicalResult fir::ShiftOp::verify() {
   auto size = getOrigins().size();
   auto shiftTy = getType().dyn_cast<fir::ShiftType>();
   assert(shiftTy && "must be a shift type");
   if (shiftTy.getRank() != size)
     return emitOpError("shift type rank mismatch");
   return mlir::success();
 }
 
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;
 }
 
-mlir::LogicalResult SliceOp::verify() {
+mlir::LogicalResult fir::SliceOp::verify() {
   auto size = getTriples().size();
   if (size < 3 || size > 16 * 3)
     return emitOpError("incorrect number of args for triple");
   if (size % 3 != 0)
     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 emitOpError("slice type rank mismatch");
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // StoreOp
 //===----------------------------------------------------------------------===//
 
 mlir::Type fir::StoreOp::elementType(mlir::Type refType) {
   return fir::dyn_cast_ptrEleTy(refType);
 }
 
-mlir::ParseResult StoreOp::parse(mlir::OpAsmParser &parser,
+mlir::ParseResult fir::StoreOp::parse(mlir::OpAsmParser &parser,
                                       mlir::OperationState &result) {
   mlir::Type type;
   mlir::OpAsmParser::UnresolvedOperand oper;
   mlir::OpAsmParser::UnresolvedOperand 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();
 }
 
-void StoreOp::print(mlir::OpAsmPrinter &p) {
+void fir::StoreOp::print(mlir::OpAsmPrinter &p) {
   p << ' ';
   p.printOperand(getValue());
   p << " to ";
   p.printOperand(getMemref());
   p.printOptionalAttrDict(getOperation()->getAttrs(), {});
   p << " : " << getMemref().getType();
 }
 
-mlir::LogicalResult StoreOp::verify() {
+mlir::LogicalResult fir::StoreOp::verify() {
   if (getValue().getType() != fir::dyn_cast_ptrEleTy(getMemref().getType()))
     return emitOpError("store value type must match memory reference type");
   if (fir::isa_unknown_size_box(getValue().getType()))
     return emitOpError("cannot store !fir.box of unknown rank or type");
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // StringLitOp
 //===----------------------------------------------------------------------===//
 
 bool fir::StringLitOp::isWideValue() {
   auto eleTy = getType().cast<fir::SequenceType>().getEleTy();
   return eleTy.cast<fir::CharacterType>().getFKind() != 1;
 }
 
 static mlir::NamedAttribute
 mkNamedIntegerAttr(mlir::OpBuilder &builder, llvm::StringRef name, int64_t v) {
   assert(v > 0);
   return builder.getNamedAttr(
       name, builder.getIntegerAttr(builder.getIntegerType(64), v));
 }
 
-void fir::StringLitOp::build(mlir::OpBuilder &builder, OperationState &result,
+void fir::StringLitOp::build(mlir::OpBuilder &builder,
+                             mlir::OperationState &result,
                              fir::CharacterType inType, llvm::StringRef val,
                              llvm::Optional<int64_t> len) {
   auto valAttr = builder.getNamedAttr(value(), builder.getStringAttr(val));
   int64_t length = len.hasValue() ? len.getValue() : inType.getLen();
   auto lenAttr = mkNamedIntegerAttr(builder, size(), length);
   result.addAttributes({valAttr, lenAttr});
   result.addTypes(inType);
 }
 
 template <typename C>
 static mlir::ArrayAttr convertToArrayAttr(mlir::OpBuilder &builder,
                                           llvm::ArrayRef<C> xlist) {
   llvm::SmallVector<mlir::Attribute> attrs;
   auto ty = builder.getIntegerType(8 * sizeof(C));
   for (auto ch : xlist)
     attrs.push_back(builder.getIntegerAttr(ty, ch));
   return builder.getArrayAttr(attrs);
 }
 
-void fir::StringLitOp::build(mlir::OpBuilder &builder, OperationState &result,
+void fir::StringLitOp::build(mlir::OpBuilder &builder,
+                             mlir::OperationState &result,
                              fir::CharacterType inType,
                              llvm::ArrayRef<char> vlist,
-                             llvm::Optional<int64_t> len) {
+                             llvm::Optional<std::int64_t> len) {
   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);
 }
 
-void fir::StringLitOp::build(mlir::OpBuilder &builder, OperationState &result,
+void fir::StringLitOp::build(mlir::OpBuilder &builder,
+                             mlir::OperationState &result,
                              fir::CharacterType inType,
                              llvm::ArrayRef<char16_t> vlist,
-                             llvm::Optional<int64_t> len) {
+                             llvm::Optional<std::int64_t> len) {
   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);
 }
 
-void fir::StringLitOp::build(mlir::OpBuilder &builder, OperationState &result,
+void fir::StringLitOp::build(mlir::OpBuilder &builder,
+                             mlir::OperationState &result,
                              fir::CharacterType inType,
                              llvm::ArrayRef<char32_t> vlist,
-                             llvm::Optional<int64_t> len) {
+                             llvm::Optional<std::int64_t> len) {
   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);
 }
 
-mlir::ParseResult StringLitOp::parse(mlir::OpAsmParser &parser,
+mlir::ParseResult fir::StringLitOp::parse(mlir::OpAsmParser &parser,
                                           mlir::OperationState &result) {
   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();
 }
 
-void StringLitOp::print(mlir::OpAsmPrinter &p) {
+void fir::StringLitOp::print(mlir::OpAsmPrinter &p) {
   p << ' ' << getValue() << '(';
   p << getSize().cast<mlir::IntegerAttr>().getValue() << ") : ";
   p.printType(getType());
 }
 
-mlir::LogicalResult StringLitOp::verify() {
+mlir::LogicalResult fir::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 emitOpError("values in list must be integers");
   }
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // UnboxProcOp
 //===----------------------------------------------------------------------===//
 
-mlir::LogicalResult UnboxProcOp::verify() {
+mlir::LogicalResult fir::UnboxProcOp::verify() {
   if (auto eleTy = fir::dyn_cast_ptrEleTy(getRefTuple().getType()))
     if (eleTy.isa<mlir::TupleType>())
       return mlir::success();
   return emitOpError("second output argument has bad type");
 }
 
 //===----------------------------------------------------------------------===//
 // IfOp
 //===----------------------------------------------------------------------===//
 
-void fir::IfOp::build(mlir::OpBuilder &builder, OperationState &result,
+void fir::IfOp::build(mlir::OpBuilder &builder, mlir::OperationState &result,
                       mlir::Value cond, bool withElseRegion) {
   build(builder, result, llvm::None, cond, withElseRegion);
 }
 
-void fir::IfOp::build(mlir::OpBuilder &builder, OperationState &result,
+void fir::IfOp::build(mlir::OpBuilder &builder, mlir::OperationState &result,
                       mlir::TypeRange resultTypes, mlir::Value cond,
                       bool withElseRegion) {
   result.addOperands(cond);
   result.addTypes(resultTypes);
 
   mlir::Region *thenRegion = result.addRegion();
   thenRegion->push_back(new mlir::Block());
   if (resultTypes.empty())
     IfOp::ensureTerminator(*thenRegion, builder, result.location);
 
   mlir::Region *elseRegion = result.addRegion();
   if (withElseRegion) {
     elseRegion->push_back(new mlir::Block());
     if (resultTypes.empty())
       IfOp::ensureTerminator(*elseRegion, builder, result.location);
   }
 }
 
-mlir::ParseResult IfOp::parse(OpAsmParser &parser, OperationState &result) {
+mlir::ParseResult fir::IfOp::parse(mlir::OpAsmParser &parser,
+                                   mlir::OperationState &result) {
   result.regions.reserve(2);
   mlir::Region *thenRegion = result.addRegion();
   mlir::Region *elseRegion = result.addRegion();
 
   auto &builder = parser.getBuilder();
-  OpAsmParser::UnresolvedOperand cond;
+  mlir::OpAsmParser::UnresolvedOperand cond;
   mlir::Type i1Type = builder.getIntegerType(1);
   if (parser.parseOperand(cond) ||
       parser.resolveOperand(cond, i1Type, result.operands))
     return mlir::failure();
 
   if (parser.parseOptionalArrowTypeList(result.types))
     return mlir::failure();
 
   if (parser.parseRegion(*thenRegion, {}, {}))
     return mlir::failure();
-  IfOp::ensureTerminator(*thenRegion, parser.getBuilder(), result.location);
+  fir::IfOp::ensureTerminator(*thenRegion, parser.getBuilder(),
+                              result.location);
 
   if (mlir::succeeded(parser.parseOptionalKeyword("else"))) {
     if (parser.parseRegion(*elseRegion, {}, {}))
       return mlir::failure();
-    IfOp::ensureTerminator(*elseRegion, parser.getBuilder(), result.location);
+    fir::IfOp::ensureTerminator(*elseRegion, parser.getBuilder(),
+                                result.location);
   }
 
   // Parse the optional attribute list.
   if (parser.parseOptionalAttrDict(result.attributes))
     return mlir::failure();
   return mlir::success();
 }
 
-LogicalResult IfOp::verify() {
+mlir::LogicalResult fir::IfOp::verify() {
   if (getNumResults() != 0 && getElseRegion().empty())
     return emitOpError("must have an else block if defining values");
 
   return mlir::success();
 }
 
-void IfOp::print(mlir::OpAsmPrinter &p) {
+void fir::IfOp::print(mlir::OpAsmPrinter &p) {
   bool printBlockTerminators = false;
   p << ' ' << getCondition();
   if (!getResults().empty()) {
     p << " -> (" << getResultTypes() << ')';
     printBlockTerminators = true;
   }
   p << ' ';
   p.printRegion(getThenRegion(), /*printEntryBlockArgs=*/false,
void fir::IfOp::resultToSourceOps(llvm::SmallVectorImpl<mlir::Value> &results,
   term = getElseRegion().front().getTerminator();
   if (resultNum < term->getNumOperands())
     results.push_back(term->getOperand(resultNum));
 }
 
 //===----------------------------------------------------------------------===//
 
 mlir::ParseResult fir::isValidCaseAttr(mlir::Attribute attr) {
-  if (attr.dyn_cast_or_null<mlir::UnitAttr>() ||
-      attr.dyn_cast_or_null<ClosedIntervalAttr>() ||
-      attr.dyn_cast_or_null<PointIntervalAttr>() ||
-      attr.dyn_cast_or_null<LowerBoundAttr>() ||
-      attr.dyn_cast_or_null<UpperBoundAttr>())
+  if (attr.isa<mlir::UnitAttr, fir::ClosedIntervalAttr, fir::PointIntervalAttr,
+               fir::LowerBoundAttr, fir::UpperBoundAttr>())
     return mlir::success();
   return mlir::failure();
 }
 
 unsigned fir::getCaseArgumentOffset(llvm::ArrayRef<mlir::Attribute> cases,
                                     unsigned dest) {
   unsigned o = 0;
   for (unsigned i = 0; i < dest; ++i) {
     auto &attr = cases[i];
     if (!attr.dyn_cast_or_null<mlir::UnitAttr>()) {
       ++o;
-      if (attr.dyn_cast_or_null<ClosedIntervalAttr>())
+      if (attr.dyn_cast_or_null<fir::ClosedIntervalAttr>())
         ++o;
     }
   }
   return o;
 }
 
 mlir::ParseResult
 fir::parseSelector(mlir::OpAsmParser &parser, mlir::OperationState &result,
                    mlir::OpAsmParser::UnresolvedOperand &selector,
                    mlir::Type &type) {
   if (parser.parseOperand(selector) || parser.parseColonType(type) ||
       parser.resolveOperand(selector, type, result.operands) ||
       parser.parseLSquare())
     return mlir::failure();
   return mlir::success();
 }
 
-bool fir::isReferenceLike(mlir::Type type) {
-  return type.isa<fir::ReferenceType>() || type.isa<fir::HeapType>() ||
-         type.isa<fir::PointerType>();
-}
-
 mlir::func::FuncOp
-fir::createFuncOp(mlir::Location loc, mlir::ModuleOp module, StringRef name,
-                  mlir::FunctionType type,
+fir::createFuncOp(mlir::Location loc, mlir::ModuleOp module,
+                  llvm::StringRef name, mlir::FunctionType type,
                   llvm::ArrayRef<mlir::NamedAttribute> attrs) {
   if (auto f = module.lookupSymbol<mlir::func::FuncOp>(name))
     return f;
   mlir::OpBuilder modBuilder(module.getBodyRegion());
   modBuilder.setInsertionPointToEnd(module.getBody());
   auto result = modBuilder.create<mlir::func::FuncOp>(loc, name, type, attrs);
   result.setVisibility(mlir::SymbolTable::Visibility::Private);
   return result;
 }
 
 fir::GlobalOp fir::createGlobalOp(mlir::Location loc, mlir::ModuleOp module,
-                                  StringRef name, mlir::Type type,
+                                  llvm::StringRef name, mlir::Type type,
                                   llvm::ArrayRef<mlir::NamedAttribute> attrs) {
   if (auto g = module.lookupSymbol<fir::GlobalOp>(name))
     return g;
   mlir::OpBuilder modBuilder(module.getBodyRegion());
   auto result = modBuilder.create<fir::GlobalOp>(loc, name, type, attrs);
   result.setVisibility(mlir::SymbolTable::Visibility::Private);
   return result;
 }