[NFC] Synchronize more code to reduce deltas for upstreaming.

[clementval]

LGTM

[schweitz]

Fix clang-format issue.

flang/lib/Optimizer/CodeGen/CodeGen.cpp

 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/Matchers.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Target/LLVMIR/ModuleTranslation.h"
 #include "llvm/ADT/ArrayRef.h"
 
 #define DEBUG_TYPE "flang-codegen"
 
-using namespace mlir;
-
 // fir::LLVMTypeConverter for converting to LLVM IR dialect types.
 #include "TypeConverter.h"
 
 // TODO: This should really be recovered from the specified target.
 static constexpr unsigned defaultAlign = 8;
 
 /// `fir.box` attribute values as defined for CFI_attribute_t in
 /// flang/ISO_Fortran_binding.h.
 static constexpr unsigned kAttrPointer = CFI_attribute_pointer;
 static constexpr unsigned kAttrAllocatable = CFI_attribute_allocatable;
 
 static inline mlir::Type getVoidPtrType(mlir::MLIRContext *context) {
   return mlir::LLVM::LLVMPointerType::get(mlir::IntegerType::get(context, 8));
 }
 
 static mlir::LLVM::ConstantOp
 genConstantIndex(mlir::Location loc, mlir::Type ity,
                  mlir::ConversionPatternRewriter &rewriter,
                  std::int64_t offset) {
   auto cattr = rewriter.getI64IntegerAttr(offset);
   return rewriter.create<mlir::LLVM::ConstantOp>(loc, ity, cattr);
 }
 
-static Block *createBlock(mlir::ConversionPatternRewriter &rewriter,
+static mlir::Block *createBlock(mlir::ConversionPatternRewriter &rewriter,
                                 mlir::Block *insertBefore) {
   assert(insertBefore && "expected valid insertion block");
   return rewriter.createBlock(insertBefore->getParent(),
                               mlir::Region::iterator(insertBefore));
 }
 
 namespace {
 /// FIR conversion pattern template
 template <typename FromOp>
mlir::Value getValueFromBox(mlir::Location loc, mlir::Value box,
     auto pty = mlir::LLVM::LLVMPointerType::get(resultTy);
     auto p = rewriter.create<mlir::LLVM::GEPOp>(
         loc, pty, box, mlir::ValueRange{c0, cValuePos});
     return rewriter.create<mlir::LLVM::LoadOp>(loc, resultTy, p);
   }
 
   /// Method to construct code sequence to get the triple for dimension `dim`
   /// from a box.
-  SmallVector<mlir::Value, 3>
-  getDimsFromBox(mlir::Location loc, ArrayRef<mlir::Type> retTys,
+  llvm::SmallVector<mlir::Value, 3>
+  getDimsFromBox(mlir::Location loc, llvm::ArrayRef<mlir::Type> retTys,
                  mlir::Value box, mlir::Value dim,
                  mlir::ConversionPatternRewriter &rewriter) const {
     mlir::LLVM::ConstantOp c0 = genConstantOffset(loc, rewriter, 0);
     mlir::LLVM::ConstantOp cDims =
         genConstantOffset(loc, rewriter, kDimsPosInBox);
     mlir::LLVM::LoadOp l0 =
         loadFromOffset(loc, box, c0, cDims, dim, 0, retTys[0], rewriter);
     mlir::LLVM::LoadOp l1 =
mlir::Value genBoxAttributeCheck(mlir::Location loc, mlir::Value box,
     return rewriter.create<mlir::LLVM::ICmpOp>(
         loc, mlir::LLVM::ICmpPredicate::ne, maskRes, c0);
   }
 
   template <typename... ARGS>
   mlir::LLVM::GEPOp genGEP(mlir::Location loc, mlir::Type ty,
                            mlir::ConversionPatternRewriter &rewriter,
                            mlir::Value base, ARGS... args) const {
-    SmallVector<mlir::Value> cv{args...};
+    llvm::SmallVector<mlir::Value> cv{args...};
     return rewriter.create<mlir::LLVM::GEPOp>(loc, ty, base, cv);
   }
 
   fir::LLVMTypeConverter &lowerTy() const {
     return *static_cast<fir::LLVMTypeConverter *>(this->getTypeConverter());
   }
 
   const fir::FIRToLLVMPassOptions &options;
struct AddrOfOpConversion : public FIROpConversion<fir::AddrOfOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::LogicalResult
   matchAndRewrite(fir::AddrOfOp addr, OpAdaptor adaptor,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     auto ty = convertType(addr.getType());
     rewriter.replaceOpWithNewOp<mlir::LLVM::AddressOfOp>(
         addr, ty, addr.getSymbol().getRootReference().getValue());
-    return success();
+    return mlir::success();
   }
 };
 } // namespace
 
 /// Lookup the function to compute the memory size of this parametric derived
 /// type. The size of the object may depend on the LEN type parameters of the
 /// derived type.
 static mlir::LLVM::LLVMFuncOp
if (ty == resultTy) {
       // Do not emit the bitcast if ty and resultTy are the same.
       rewriter.replaceOpWithNewOp<mlir::LLVM::AllocaOp>(alloc, ty, size,
                                                         alloc->getAttrs());
     } else {
       auto al = rewriter.create<mlir::LLVM::AllocaOp>(loc, ty, size,
                                                       alloc->getAttrs());
       rewriter.replaceOpWithNewOp<mlir::LLVM::BitcastOp>(alloc, resultTy, al);
     }
-    return success();
+    return mlir::success();
   }
 };
 } // namespace
 
 /// Construct an `llvm.extractvalue` instruction. It will return value at
 /// element \p x from  \p tuple.
 static mlir::LLVM::ExtractValueOp
 genExtractValueWithIndex(mlir::Location loc, mlir::Value tuple, mlir::Type ty,
matchAndRewrite(fir::BoxAddrOp boxaddr, OpAdaptor adaptor,
     if (auto argty = boxaddr.getVal().getType().dyn_cast<fir::BoxType>()) {
       rewriter.replaceOp(boxaddr, loadBaseAddrFromBox(loc, ty, a, rewriter));
     } else {
       auto c0attr = rewriter.getI32IntegerAttr(0);
       auto c0 = mlir::ArrayAttr::get(boxaddr.getContext(), c0attr);
       rewriter.replaceOpWithNewOp<mlir::LLVM::ExtractValueOp>(boxaddr, ty, a,
                                                               c0);
     }
-    return success();
+    return mlir::success();
   }
 };
 
 /// Convert `!fir.boxchar_len` to  `!llvm.extractvalue` for the 2nd part of the
 /// boxchar.
 struct BoxCharLenOpConversion : public FIROpConversion<fir::BoxCharLenOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::LogicalResult
   matchAndRewrite(fir::BoxCharLenOp boxCharLen, OpAdaptor adaptor,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     mlir::Value boxChar = adaptor.getOperands()[0];
     mlir::Location loc = boxChar.getLoc();
     mlir::MLIRContext *ctx = boxChar.getContext();
     mlir::Type returnValTy = boxCharLen.getResult().getType();
 
     constexpr int boxcharLenIdx = 1;
     mlir::LLVM::ExtractValueOp len = genExtractValueWithIndex(
         loc, boxChar, boxChar.getType(), rewriter, ctx, boxcharLenIdx);
     mlir::Value lenAfterCast = integerCast(loc, rewriter, returnValTy, len);
     rewriter.replaceOp(boxCharLen, lenAfterCast);
 
-    return success();
+    return mlir::success();
   }
 };
 
 /// Lower `fir.box_dims` to a sequence of operations to extract the requested
 /// dimension infomartion from the boxed value.
 /// Result in a triple set of GEPs and loads.
 struct BoxDimsOpConversion : public FIROpConversion<fir::BoxDimsOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::LogicalResult
   matchAndRewrite(fir::BoxDimsOp boxdims, OpAdaptor adaptor,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    SmallVector<mlir::Type, 3> resultTypes = {
+    llvm::SmallVector<mlir::Type, 3> resultTypes = {
         convertType(boxdims.getResult(0).getType()),
         convertType(boxdims.getResult(1).getType()),
         convertType(boxdims.getResult(2).getType()),
     };
     auto results =
         getDimsFromBox(boxdims.getLoc(), resultTypes, adaptor.getOperands()[0],
                        adaptor.getOperands()[1], rewriter);
     rewriter.replaceOp(boxdims, results);
-    return success();
+    return mlir::success();
   }
 };
 
 /// Lower `fir.box_elesize` to a sequence of operations ro extract the size of
 /// an element in the boxed value.
 struct BoxEleSizeOpConversion : public FIROpConversion<fir::BoxEleSizeOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::LogicalResult
   matchAndRewrite(fir::BoxEleSizeOp boxelesz, OpAdaptor adaptor,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     mlir::Value a = adaptor.getOperands()[0];
     auto loc = boxelesz.getLoc();
     auto ty = convertType(boxelesz.getType());
     auto elemSize = getValueFromBox(loc, a, ty, rewriter, kElemLenPosInBox);
     rewriter.replaceOp(boxelesz, elemSize);
-    return success();
+    return mlir::success();
   }
 };
 
 /// Lower `fir.box_isalloc` to a sequence of operations to determine if the
 /// boxed value was from an ALLOCATABLE entity.
 struct BoxIsAllocOpConversion : public FIROpConversion<fir::BoxIsAllocOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::LogicalResult
   matchAndRewrite(fir::BoxIsAllocOp boxisalloc, OpAdaptor adaptor,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     mlir::Value box = adaptor.getOperands()[0];
     auto loc = boxisalloc.getLoc();
     mlir::Value check =
         genBoxAttributeCheck(loc, box, rewriter, kAttrAllocatable);
     rewriter.replaceOp(boxisalloc, check);
-    return success();
+    return mlir::success();
   }
 };
 
 /// Lower `fir.box_isarray` to a sequence of operations to determine if the
 /// boxed is an array.
 struct BoxIsArrayOpConversion : public FIROpConversion<fir::BoxIsArrayOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::LogicalResult
   matchAndRewrite(fir::BoxIsArrayOp boxisarray, OpAdaptor adaptor,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     mlir::Value a = adaptor.getOperands()[0];
     auto loc = boxisarray.getLoc();
     auto rank =
         getValueFromBox(loc, a, rewriter.getI32Type(), rewriter, kRankPosInBox);
     auto c0 = genConstantOffset(loc, rewriter, 0);
     rewriter.replaceOpWithNewOp<mlir::LLVM::ICmpOp>(
         boxisarray, mlir::LLVM::ICmpPredicate::ne, rank, c0);
-    return success();
+    return mlir::success();
   }
 };
 
 /// Lower `fir.box_isptr` to a sequence of operations to determined if the
 /// boxed value was from a POINTER entity.
 struct BoxIsPtrOpConversion : public FIROpConversion<fir::BoxIsPtrOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::LogicalResult
   matchAndRewrite(fir::BoxIsPtrOp boxisptr, OpAdaptor adaptor,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     mlir::Value box = adaptor.getOperands()[0];
     auto loc = boxisptr.getLoc();
     mlir::Value check = genBoxAttributeCheck(loc, box, rewriter, kAttrPointer);
     rewriter.replaceOp(boxisptr, check);
-    return success();
+    return mlir::success();
   }
 };
 
 /// Lower `fir.box_rank` to the sequence of operation to extract the rank from
 /// the box.
 struct BoxRankOpConversion : public FIROpConversion<fir::BoxRankOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::LogicalResult
   matchAndRewrite(fir::BoxRankOp boxrank, OpAdaptor adaptor,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     mlir::Value a = adaptor.getOperands()[0];
     auto loc = boxrank.getLoc();
     mlir::Type ty = convertType(boxrank.getType());
     auto result = getValueFromBox(loc, a, ty, rewriter, kRankPosInBox);
     rewriter.replaceOp(boxrank, result);
-    return success();
+    return mlir::success();
   }
 };
 
 /// Lower `fir.boxproc_host` operation. Extracts the host pointer from the
 /// boxproc.
 /// TODO: Part of supporting Fortran 2003 procedure pointers.
 struct BoxProcHostOpConversion : public FIROpConversion<fir::BoxProcHostOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::LogicalResult
   matchAndRewrite(fir::BoxProcHostOp boxprochost, OpAdaptor adaptor,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     TODO(boxprochost.getLoc(), "fir.boxproc_host codegen");
-    return failure();
+    return mlir::failure();
   }
 };
 
 /// Lower `fir.box_tdesc` to the sequence of operations to extract the type
 /// descriptor from the box.
 struct BoxTypeDescOpConversion : public FIROpConversion<fir::BoxTypeDescOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::LogicalResult
   matchAndRewrite(fir::BoxTypeDescOp boxtypedesc, OpAdaptor adaptor,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     mlir::Value box = adaptor.getOperands()[0];
     auto loc = boxtypedesc.getLoc();
     mlir::Type typeTy =
         fir::getDescFieldTypeModel<kTypePosInBox>()(boxtypedesc.getContext());
     auto result = getValueFromBox(loc, box, typeTy, rewriter, kTypePosInBox);
     auto typePtrTy = mlir::LLVM::LLVMPointerType::get(typeTy);
     rewriter.replaceOpWithNewOp<mlir::LLVM::IntToPtrOp>(boxtypedesc, typePtrTy,
                                                         result);
-    return success();
+    return mlir::success();
   }
 };
 
 /// Lower `fir.string_lit` to LLVM IR dialect operation.
 struct StringLitOpConversion : public FIROpConversion<fir::StringLitOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::LogicalResult
   matchAndRewrite(fir::StringLitOp constop, OpAdaptor adaptor,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     auto ty = convertType(constop.getType());
     auto attr = constop.getValue();
     if (attr.isa<mlir::StringAttr>()) {
       rewriter.replaceOpWithNewOp<mlir::LLVM::ConstantOp>(constop, ty, attr);
-      return success();
+      return mlir::success();
     }
 
     auto charTy = constop.getType().cast<fir::CharacterType>();
     unsigned bits = lowerTy().characterBitsize(charTy);
     mlir::Type intTy = rewriter.getIntegerType(bits);
     mlir::Location loc = constop.getLoc();
     mlir::Value cst = rewriter.create<mlir::LLVM::UndefOp>(loc, ty);
     if (auto arr = attr.dyn_cast<mlir::DenseElementsAttr>()) {
       cst = rewriter.create<mlir::LLVM::ConstantOp>(loc, ty, arr);
     } else if (auto arr = attr.dyn_cast<mlir::ArrayAttr>()) {
       for (auto a : llvm::enumerate(arr.getValue())) {
         // convert each character to a precise bitsize
         auto elemAttr = mlir::IntegerAttr::get(
             intTy,
             a.value().cast<mlir::IntegerAttr>().getValue().zextOrTrunc(bits));
         auto elemCst =
             rewriter.create<mlir::LLVM::ConstantOp>(loc, intTy, elemAttr);
         auto index = mlir::ArrayAttr::get(
             constop.getContext(), rewriter.getI32IntegerAttr(a.index()));
         cst = rewriter.create<mlir::LLVM::InsertValueOp>(loc, ty, cst, elemCst,
                                                          index);
       }
     } else {
-      return failure();
+      return mlir::failure();
     }
     rewriter.replaceOp(constop, cst);
-    return success();
+    return mlir::success();
   }
 };
 
 // `fir.call` -> `llvm.call`
 struct CallOpConversion : public FIROpConversion<fir::CallOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::LogicalResult
   matchAndRewrite(fir::CallOp call, OpAdaptor adaptor,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    SmallVector<mlir::Type> resultTys;
+    llvm::SmallVector<mlir::Type> resultTys;
     for (auto r : call.getResults())
       resultTys.push_back(convertType(r.getType()));
     rewriter.replaceOpWithNewOp<mlir::LLVM::CallOp>(
         call, resultTys, adaptor.getOperands(), call->getAttrs());
-    return success();
+    return mlir::success();
   }
 };
 } // namespace
 
 static mlir::Type getComplexEleTy(mlir::Type complex) {
   if (auto cc = complex.dyn_cast<mlir::ComplexType>())
     return cc.getElementType();
   return complex.cast<fir::ComplexType>().getElementType();
struct CmpcOpConversion : public FIROpConversion<fir::CmpcOp> {
   matchAndRewrite(fir::CmpcOp cmp, OpAdaptor adaptor,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     mlir::ValueRange operands = adaptor.getOperands();
     mlir::MLIRContext *ctxt = cmp.getContext();
     mlir::Type eleTy = convertType(getComplexEleTy(cmp.getLhs().getType()));
     mlir::Type resTy = convertType(cmp.getType());
     mlir::Location loc = cmp.getLoc();
     auto pos0 = mlir::ArrayAttr::get(ctxt, rewriter.getI32IntegerAttr(0));
-    SmallVector<mlir::Value, 2> rp{rewriter.create<mlir::LLVM::ExtractValueOp>(
-                                       loc, eleTy, operands[0], pos0),
-                                   rewriter.create<mlir::LLVM::ExtractValueOp>(
-                                       loc, eleTy, operands[1], pos0)};
+    llvm::SmallVector<mlir::Value, 2> rp{
+        rewriter.create<mlir::LLVM::ExtractValueOp>(loc, eleTy, operands[0],
+                                                    pos0),
+        rewriter.create<mlir::LLVM::ExtractValueOp>(loc, eleTy, operands[1],
+                                                    pos0)};
     auto rcp =
         rewriter.create<mlir::LLVM::FCmpOp>(loc, resTy, rp, cmp->getAttrs());
     auto pos1 = mlir::ArrayAttr::get(ctxt, rewriter.getI32IntegerAttr(1));
-    SmallVector<mlir::Value, 2> ip{rewriter.create<mlir::LLVM::ExtractValueOp>(
-                                       loc, eleTy, operands[0], pos1),
-                                   rewriter.create<mlir::LLVM::ExtractValueOp>(
-                                       loc, eleTy, operands[1], pos1)};
+    llvm::SmallVector<mlir::Value, 2> ip{
+        rewriter.create<mlir::LLVM::ExtractValueOp>(loc, eleTy, operands[0],
+                                                    pos1),
+        rewriter.create<mlir::LLVM::ExtractValueOp>(loc, eleTy, operands[1],
+                                                    pos1)};
     auto icp =
         rewriter.create<mlir::LLVM::FCmpOp>(loc, resTy, ip, cmp->getAttrs());
-    SmallVector<mlir::Value, 2> cp{rcp, icp};
+    llvm::SmallVector<mlir::Value, 2> cp{rcp, icp};
     switch (cmp.getPredicate()) {
     case mlir::arith::CmpFPredicate::OEQ: // .EQ.
       rewriter.replaceOpWithNewOp<mlir::LLVM::AndOp>(cmp, resTy, cp);
       break;
     case mlir::arith::CmpFPredicate::UNE: // .NE.
       rewriter.replaceOpWithNewOp<mlir::LLVM::OrOp>(cmp, resTy, cp);
       break;
     default:
       rewriter.replaceOp(cmp, rcp.getResult());
       break;
     }
-    return success();
+    return mlir::success();
   }
 };
 
 /// Lower complex constants
 struct ConstcOpConversion : public FIROpConversion<fir::ConstcOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::LogicalResult
auto imPart =
         rewriter.create<mlir::LLVM::ConstantOp>(loc, ety, imFloatAttr);
     auto realIndex = mlir::ArrayAttr::get(ctx, rewriter.getI32IntegerAttr(0));
     auto imIndex = mlir::ArrayAttr::get(ctx, rewriter.getI32IntegerAttr(1));
     auto undef = rewriter.create<mlir::LLVM::UndefOp>(loc, ty);
     auto setReal = rewriter.create<mlir::LLVM::InsertValueOp>(
         loc, ty, undef, realPart, realIndex);
     rewriter.replaceOpWithNewOp<mlir::LLVM::InsertValueOp>(conc, ty, setReal,
                                                            imPart, imIndex);
-    return success();
+    return mlir::success();
   }
 
-  inline APFloat getValue(mlir::Attribute attr) const {
+  inline llvm::APFloat getValue(mlir::Attribute attr) const {
     return attr.cast<fir::RealAttr>().getValue();
   }
 };
 
 /// convert value of from-type to value of to-type
 struct ConvertOpConversion : public FIROpConversion<fir::ConvertOp> {
   using FIROpConversion::FIROpConversion;
 
   static bool isFloatingPointTy(mlir::Type ty) {
     return ty.isa<mlir::FloatType>();
   }
 
   mlir::LogicalResult
   matchAndRewrite(fir::ConvertOp convert, OpAdaptor adaptor,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     auto fromFirTy = convert.getValue().getType();
     auto toFirTy = convert.getRes().getType();
     auto fromTy = convertType(fromFirTy);
     auto toTy = convertType(toFirTy);
     mlir::Value op0 = adaptor.getOperands()[0];
     if (fromTy == toTy) {
       rewriter.replaceOp(convert, op0);
-      return success();
+      return mlir::success();
     }
     auto loc = convert.getLoc();
     auto convertFpToFp = [&](mlir::Value val, unsigned fromBits,
                              unsigned toBits, mlir::Type toTy) -> mlir::Value {
       if (fromBits == toBits) {
         // TODO: Converting between two floating-point representations with the
         // same bitwidth is not allowed for now.
         mlir::emitError(loc,

 /// table.
 struct DispatchOpConversion : public FIROpConversion<fir::DispatchOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::LogicalResult
   matchAndRewrite(fir::DispatchOp dispatch, OpAdaptor adaptor,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     TODO(dispatch.getLoc(), "fir.dispatch codegen");
-    return failure();
+    return mlir::failure();
   }
 };
 
 /// Lower `fir.dispatch_table` operation. The dispatch table for a Fortran
 /// derived type.
 struct DispatchTableOpConversion
     : public FIROpConversion<fir::DispatchTableOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::LogicalResult
   matchAndRewrite(fir::DispatchTableOp dispTab, OpAdaptor adaptor,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     TODO(dispTab.getLoc(), "fir.dispatch_table codegen");
-    return failure();
+    return mlir::failure();
   }
 };
 
 /// Lower `fir.dt_entry` operation. An entry in a dispatch table; binds a
 /// method-name to a function.
 struct DTEntryOpConversion : public FIROpConversion<fir::DTEntryOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::LogicalResult
   matchAndRewrite(fir::DTEntryOp dtEnt, OpAdaptor adaptor,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     TODO(dtEnt.getLoc(), "fir.dt_entry codegen");
-    return failure();
+    return mlir::failure();
   }
 };
 
 /// Lower `fir.global_len` operation.
 struct GlobalLenOpConversion : public FIROpConversion<fir::GlobalLenOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::LogicalResult
   matchAndRewrite(fir::GlobalLenOp globalLen, OpAdaptor adaptor,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     TODO(globalLen.getLoc(), "fir.global_len codegen");
-    return failure();
+    return mlir::failure();
   }
 };
 
 /// Lower fir.len_param_index
 struct LenParamIndexOpConversion
     : public FIROpConversion<fir::LenParamIndexOp> {
   using FIROpConversion::FIROpConversion;
 

 /// element is the length of the character buffer (`#n`).
 struct EmboxCharOpConversion : public FIROpConversion<fir::EmboxCharOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::LogicalResult
   matchAndRewrite(fir::EmboxCharOp emboxChar, OpAdaptor adaptor,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     mlir::ValueRange operands = adaptor.getOperands();
-    MLIRContext *ctx = emboxChar.getContext();
+    auto *ctx = emboxChar.getContext();
 
     mlir::Value charBuffer = operands[0];
     mlir::Value charBufferLen = operands[1];
 
     mlir::Location loc = emboxChar.getLoc();
     mlir::Type llvmStructTy = convertType(emboxChar.getType());
     auto llvmStruct = rewriter.create<mlir::LLVM::UndefOp>(loc, llvmStructTy);
 
     mlir::Type lenTy =
         llvmStructTy.cast<mlir::LLVM::LLVMStructType>().getBody()[1];
     mlir::Value lenAfterCast = integerCast(loc, rewriter, lenTy, charBufferLen);
 
     auto c0 = mlir::ArrayAttr::get(ctx, rewriter.getI32IntegerAttr(0));
     auto c1 = mlir::ArrayAttr::get(ctx, rewriter.getI32IntegerAttr(1));
     auto insertBufferOp = rewriter.create<mlir::LLVM::InsertValueOp>(
         loc, llvmStructTy, llvmStruct, charBuffer, c0);
     rewriter.replaceOpWithNewOp<mlir::LLVM::InsertValueOp>(
         emboxChar, llvmStructTy, insertBufferOp, lenAfterCast, c1);
 
-    return success();
+    return mlir::success();
   }
 };
 } // namespace
 
 /// Return the LLVMFuncOp corresponding to the standard malloc call.
 static mlir::LLVM::LLVMFuncOp
 getMalloc(fir::AllocMemOp op, mlir::ConversionPatternRewriter &rewriter) {
   auto module = op->getParentOfType<mlir::ModuleOp>();
matchAndRewrite(fir::AllocMemOp heap, OpAdaptor adaptor,
     for (mlir::Value opnd : adaptor.getOperands())
       size = rewriter.create<mlir::LLVM::MulOp>(
           loc, ity, size, integerCast(loc, rewriter, ity, opnd));
     heap->setAttr("callee", mlir::SymbolRefAttr::get(mallocFunc));
     auto malloc = rewriter.create<mlir::LLVM::CallOp>(
         loc, ::getVoidPtrType(heap.getContext()), size, heap->getAttrs());
     rewriter.replaceOpWithNewOp<mlir::LLVM::BitcastOp>(heap, ty,
                                                        malloc.getResult(0));
-    return success();
+    return mlir::success();
   }
 
   // Compute the (allocation) size of the allocmem type in bytes.
   mlir::Value genTypeSizeInBytes(mlir::Location loc, mlir::Type idxTy,
                                  mlir::ConversionPatternRewriter &rewriter,
                                  mlir::Type llTy) const {
     // Use the primitive size, if available.
     auto ptrTy = llTy.dyn_cast<mlir::LLVM::LLVMPointerType>();
matchAndRewrite(fir::FreeMemOp freemem, OpAdaptor adaptor,
     mlir::LLVM::LLVMFuncOp freeFunc = getFree(freemem, rewriter);
     mlir::Location loc = freemem.getLoc();
     auto bitcast = rewriter.create<mlir::LLVM::BitcastOp>(
         freemem.getLoc(), voidPtrTy(), adaptor.getOperands()[0]);
     freemem->setAttr("callee", mlir::SymbolRefAttr::get(freeFunc));
     rewriter.create<mlir::LLVM::CallOp>(
         loc, mlir::TypeRange{}, mlir::ValueRange{bitcast}, freemem->getAttrs());
     rewriter.eraseOp(freemem);
-    return success();
+    return mlir::success();
   }
 };
 } // namespace
 
 namespace {} // namespace
 
 /// Common base class for embox to descriptor conversion.
 template <typename OP>
if (fir::isa_ref_type(boxEleTy)) {
               this->genConstantOffset(loc, rewriter, CFI_type_cptr)};
     }
     fir::emitFatalError(loc, "unhandled type in fir.box code generation");
   }
 
   /// Basic pattern to write a field in the descriptor
   mlir::Value insertField(mlir::ConversionPatternRewriter &rewriter,
                           mlir::Location loc, mlir::Value dest,
-                          ArrayRef<unsigned> fldIndexes, mlir::Value value,
-                          bool bitcast = false) const {
+                          llvm::ArrayRef<unsigned> fldIndexes,
+                          mlir::Value value, bool bitcast = false) const {
     auto boxTy = dest.getType();
     auto fldTy = this->getBoxEleTy(boxTy, fldIndexes);
     if (bitcast)
       value = rewriter.create<mlir::LLVM::BitcastOp>(loc, fldTy, value);
     else
       value = this->integerCast(loc, rewriter, fldTy, value);
-    SmallVector<mlir::Attribute, 2> attrs;
+    llvm::SmallVector<mlir::Attribute, 2> attrs;
     for (auto i : fldIndexes)
       attrs.push_back(rewriter.getI32IntegerAttr(i));
     auto indexesAttr = mlir::ArrayAttr::get(rewriter.getContext(), attrs);
     return rewriter.create<mlir::LLVM::InsertValueOp>(loc, boxTy, dest, value,
                                                       indexesAttr);
   }
 
   inline mlir::Value
matchAndRewrite(fir::EmboxOp embox, OpAdaptor adaptor,
     auto [boxTy, dest, eleSize] =
         consDescriptorPrefix(embox, rewriter, /*rank=*/0,
                              /*lenParams=*/adaptor.getOperands().drop_front(1));
     dest = insertBaseAddress(rewriter, embox.getLoc(), dest,
                              adaptor.getOperands()[0]);
     if (isDerivedTypeWithLenParams(boxTy)) {
       TODO(embox.getLoc(),
            "fir.embox codegen of derived with length parameters");
-      return failure();
+      return mlir::failure();
     }
     auto result = placeInMemoryIfNotGlobalInit(rewriter, embox.getLoc(), dest);
     rewriter.replaceOp(embox, result);
-    return success();
+    return mlir::success();
   }
 };
 
 /// Create a generic box on a memory reference.
 struct XEmboxOpConversion : public EmboxCommonConversion<fir::cg::XEmboxOp> {
   using EmboxCommonConversion::EmboxCommonConversion;
 
   mlir::LogicalResult
if (hasSlice || hasSubcomp || !xbox.substr().empty()) {
                                   operands[xbox.substrOffset()]);
     }
     dest = insertBaseAddress(rewriter, loc, dest, base);
     if (isDerivedTypeWithLenParams(boxTy))
       TODO(loc, "fir.embox codegen of derived with length parameters");
 
     mlir::Value result = placeInMemoryIfNotGlobalInit(rewriter, loc, dest);
     rewriter.replaceOp(xbox, result);
-    return success();
+    return mlir::success();
   }
 
   /// Return true if `xbox` has a normalized lower bounds attribute. A box value
   /// that is neither a POINTER nor an ALLOCATABLE should be normalized to a
   /// zero origin lower bound for interoperability with BIND(C).
   inline static bool normalizedLowerBound(fir::cg::XEmboxOp xbox) {
     return xbox->hasAttr(fir::getNormalizedLowerBoundAttrName());
   }
auto [boxTy, dest, eleSize] =
         consDescriptorPrefix(rebox, rewriter, rebox.getOutRank(), lenParams);
 
     // Read input extents, strides, and base address
     llvm::SmallVector<mlir::Value> inputExtents;
     llvm::SmallVector<mlir::Value> inputStrides;
     const unsigned inputRank = rebox.getRank();
     for (unsigned i = 0; i < inputRank; ++i) {
       mlir::Value dim = genConstantIndex(loc, idxTy, rewriter, i);
-      SmallVector<mlir::Value, 3> dimInfo =
+      llvm::SmallVector<mlir::Value, 3> dimInfo =
           getDimsFromBox(loc, {idxTy, idxTy, idxTy}, loweredBox, dim, rewriter);
       inputExtents.emplace_back(dimInfo[1]);
       inputStrides.emplace_back(dimInfo[2]);
     }
 
     mlir::Type baseTy = getBaseAddrTypeFromBox(loweredBox.getType());
     mlir::Value baseAddr =
         loadBaseAddrFromBox(loc, baseTy, loweredBox, rewriter);
for (auto iter : llvm::enumerate(llvm::zip(extents, strides))) {
       dest = insertLowerBound(rewriter, loc, dest, dim, lb);
       dest = insertExtent(rewriter, loc, dest, dim, extent);
       dest = insertStride(rewriter, loc, dest, dim, std::get<1>(iter.value()));
     }
     dest = insertBaseAddress(rewriter, loc, dest, base);
     mlir::Value result =
         placeInMemoryIfNotGlobalInit(rewriter, rebox.getLoc(), dest);
     rewriter.replaceOp(rebox, result);
-    return success();
+    return mlir::success();
   }
 
   // Apply slice given the base address, extents and strides of the input box.
   mlir::LogicalResult
   sliceBox(fir::cg::XReboxOp rebox, mlir::Value dest, mlir::Value base,
            mlir::ValueRange inputExtents, mlir::ValueRange inputStrides,
            mlir::ValueRange operands,
            mlir::ConversionPatternRewriter &rewriter) const {

 /// TODO: Part of supporting Fortran 2003 procedure pointers.
 struct EmboxProcOpConversion : public FIROpConversion<fir::EmboxProcOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::LogicalResult
   matchAndRewrite(fir::EmboxProcOp emboxproc, OpAdaptor adaptor,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     TODO(emboxproc.getLoc(), "fir.emboxproc codegen");
-    return failure();
+    return mlir::failure();
   }
 };
 
 // Code shared between insert_value and extract_value Ops.
 struct ValueOpCommon {
   // Translate the arguments pertaining to any multidimensional array to
   // row-major order for LLVM-IR.
-  static void toRowMajor(SmallVectorImpl<mlir::Attribute> &attrs,
+  static void toRowMajor(llvm::SmallVectorImpl<mlir::Attribute> &attrs,
                          mlir::Type ty) {
     assert(ty && "type is null");
     const auto end = attrs.size();
     for (std::remove_const_t<decltype(end)> i = 0; i < end; ++i) {
       if (auto seq = ty.dyn_cast<mlir::LLVM::LLVMArrayType>()) {
         const auto dim = getDimension(seq);
         if (dim > 1) {
           auto ub = std::min(i + dim, end);
struct ExtractValueOpConversion
   mlir::LogicalResult
   doRewrite(fir::ExtractValueOp extractVal, mlir::Type ty, OpAdaptor adaptor,
             mlir::ConversionPatternRewriter &rewriter) const override {
     auto attrs = collectIndices(rewriter, extractVal.getCoor());
     toRowMajor(attrs, adaptor.getOperands()[0].getType());
     auto position = mlir::ArrayAttr::get(extractVal.getContext(), attrs);
     rewriter.replaceOpWithNewOp<mlir::LLVM::ExtractValueOp>(
         extractVal, ty, adaptor.getOperands()[0], position);
-    return success();
+    return mlir::success();
   }
 };
 
 /// InsertValue is the generalized instruction for the composition of new
 /// aggregate type values.
 struct InsertValueOpConversion
     : public FIROpAndTypeConversion<fir::InsertValueOp>,
       public ValueOpCommon {
   using FIROpAndTypeConversion::FIROpAndTypeConversion;
 
   mlir::LogicalResult
   doRewrite(fir::InsertValueOp insertVal, mlir::Type ty, OpAdaptor adaptor,
             mlir::ConversionPatternRewriter &rewriter) const override {
     auto attrs = collectIndices(rewriter, insertVal.getCoor());
     toRowMajor(attrs, adaptor.getOperands()[0].getType());
     auto position = mlir::ArrayAttr::get(insertVal.getContext(), attrs);
     rewriter.replaceOpWithNewOp<mlir::LLVM::InsertValueOp>(
         insertVal, ty, adaptor.getOperands()[0], adaptor.getOperands()[1],
         position);
-    return success();
+    return mlir::success();
   }
 };
 
 /// InsertOnRange inserts a value into a sequence over a range of offsets.
 struct InsertOnRangeOpConversion
     : public FIROpAndTypeConversion<fir::InsertOnRangeOp> {
   using FIROpAndTypeConversion::FIROpAndTypeConversion;
 
   // Increments an array of subscripts in a row major fasion.
-  void incrementSubscripts(const SmallVector<uint64_t> &dims,
-                           SmallVector<uint64_t> &subscripts) const {
+  void incrementSubscripts(const llvm::SmallVector<uint64_t> &dims,
+                           llvm::SmallVector<uint64_t> &subscripts) const {
     for (size_t i = dims.size(); i > 0; --i) {
       if (++subscripts[i - 1] < dims[i - 1]) {
         return;
       }
       subscripts[i - 1] = 0;
     }
   }
 
   mlir::LogicalResult
   doRewrite(fir::InsertOnRangeOp range, mlir::Type ty, OpAdaptor adaptor,
             mlir::ConversionPatternRewriter &rewriter) const override {
 
     llvm::SmallVector<uint64_t> dims;
     auto type = adaptor.getOperands()[0].getType();
 
     // Iteratively extract the array dimensions from the type.
     while (auto t = type.dyn_cast<mlir::LLVM::LLVMArrayType>()) {
       dims.push_back(t.getNumElements());
       type = t.getElementType();
     }
 
-    SmallVector<uint64_t> lBounds;
-    SmallVector<uint64_t> uBounds;
+    llvm::SmallVector<uint64_t> lBounds;
+    llvm::SmallVector<uint64_t> uBounds;
 
     // Unzip the upper and lower bound and convert to a row major format.
     mlir::DenseIntElementsAttr coor = range.getCoor();
     auto reversedCoor = llvm::reverse(coor.getValues<int64_t>());
     for (auto i = reversedCoor.begin(), e = reversedCoor.end(); i != e; ++i) {
       uBounds.push_back(*i++);
       lBounds.push_back(*i);
     }
 
     auto &subscripts = lBounds;
     auto loc = range.getLoc();
     mlir::Value lastOp = adaptor.getOperands()[0];
     mlir::Value insertVal = adaptor.getOperands()[1];
 
     auto i64Ty = rewriter.getI64Type();
     while (subscripts != uBounds) {
       // Convert uint64_t's to Attribute's.
-      SmallVector<mlir::Attribute> subscriptAttrs;
+      llvm::SmallVector<mlir::Attribute> subscriptAttrs;
       for (const auto &subscript : subscripts)
-        subscriptAttrs.push_back(IntegerAttr::get(i64Ty, subscript));
+        subscriptAttrs.push_back(mlir::IntegerAttr::get(i64Ty, subscript));
       lastOp = rewriter.create<mlir::LLVM::InsertValueOp>(
           loc, ty, lastOp, insertVal,
-          ArrayAttr::get(range.getContext(), subscriptAttrs));
+          mlir::ArrayAttr::get(range.getContext(), subscriptAttrs));
 
       incrementSubscripts(dims, subscripts);
     }
 
     // Convert uint64_t's to Attribute's.
-    SmallVector<mlir::Attribute> subscriptAttrs;
+    llvm::SmallVector<mlir::Attribute> subscriptAttrs;
     for (const auto &subscript : subscripts)
       subscriptAttrs.push_back(
-          IntegerAttr::get(rewriter.getI64Type(), subscript));
+          mlir::IntegerAttr::get(rewriter.getI64Type(), subscript));
     mlir::ArrayRef<mlir::Attribute> arrayRef(subscriptAttrs);
 
     rewriter.replaceOpWithNewOp<mlir::LLVM::InsertValueOp>(
         range, ty, lastOp, insertVal,
-        ArrayAttr::get(range.getContext(), arrayRef));
+        mlir::ArrayAttr::get(range.getContext(), arrayRef));
 
-    return success();
+    return mlir::success();
   }
 };
 } // namespace
 
 namespace {
 /// XArrayCoor is the address arithmetic on a dynamically shaped, sliced,
 /// shifted etc. array.
 /// (See the static restriction on coordinate_of.) array_coor determines the
if (baseIsBoxed) {
           loadBaseAddrFromBox(loc, baseTy, adaptor.getOperands()[0], rewriter);
       mlir::Type voidPtrTy = getVoidPtrType();
       base = rewriter.create<mlir::LLVM::BitcastOp>(loc, voidPtrTy, base);
       llvm::SmallVector<mlir::Value> args{offset};
       auto addr =
           rewriter.create<mlir::LLVM::GEPOp>(loc, voidPtrTy, base, args);
       if (coor.subcomponent().empty()) {
         rewriter.replaceOpWithNewOp<mlir::LLVM::BitcastOp>(coor, baseTy, addr);
-        return success();
+        return mlir::success();
       }
       auto casted = rewriter.create<mlir::LLVM::BitcastOp>(loc, baseTy, addr);
       args.clear();
       args.push_back(zero);
       if (!coor.lenParams().empty()) {
         // If type parameters are present, then we don't want to use a GEPOp
         // as below, as the LLVM struct type cannot be statically defined.
         TODO(loc, "derived type with type parameters");
       }
       // TODO: array offset subcomponents must be converted to LLVM's
       // row-major layout here.
       for (auto i = coor.subcomponentOffset(); i != coor.indicesOffset(); ++i)
         args.push_back(operands[i]);
       rewriter.replaceOpWithNewOp<mlir::LLVM::GEPOp>(coor, baseTy, casted,
                                                      args);
-      return success();
+      return mlir::success();
     }
 
     // The array was not boxed, so it must be contiguous. offset is therefore an
     // element offset and the base type is kept in the GEP unless the element
     // type size is itself dynamic.
     mlir::Value base;
     if (coor.subcomponent().empty()) {
       // No subcomponent.
if (coor.subcomponent().empty()) {
       assert(ptrTy && "expected pointer type");
       mlir::Type eleTy = ptrTy.getElementType();
       while (auto arrTy = eleTy.dyn_cast<mlir::LLVM::LLVMArrayType>())
         eleTy = arrTy.getElementType();
       auto newTy = mlir::LLVM::LLVMPointerType::get(eleTy);
       base = rewriter.create<mlir::LLVM::BitcastOp>(loc, newTy,
                                                     adaptor.getOperands()[0]);
     }
-    SmallVector<mlir::Value> args = {offset};
+    llvm::SmallVector<mlir::Value> args = {offset};
     for (auto i = coor.subcomponentOffset(); i != coor.indicesOffset(); ++i)
       args.push_back(operands[i]);
     rewriter.replaceOpWithNewOp<mlir::LLVM::GEPOp>(coor, ty, base, args);
-    return success();
+    return mlir::success();
   }
 };
 } // namespace
 
 /// Convert to (memory) reference to a reference to a subobject.
 /// The coordinate_of op is a Swiss army knife operation that can be used on
 /// (memory) references to records, arrays, complex, etc. as well as boxes.
 /// With unboxed arrays, there is the restriction that the array have a static
doRewrite(fir::CoordinateOp coor, mlir::Type ty, OpAdaptor adaptor,
 
     // Complex type - basically, extract the real or imaginary part
     if (fir::isa_complex(objectTy)) {
       mlir::LLVM::ConstantOp c0 =
           genConstantIndex(loc, lowerTy().indexType(), rewriter, 0);
       llvm::SmallVector<mlir::Value> offs = {c0, operands[1]};
       mlir::Value gep = genGEP(loc, ty, rewriter, base, offs);
       rewriter.replaceOp(coor, gep);
-      return success();
+      return mlir::success();
     }
 
     // Boxed type - get the base pointer from the box
     if (baseObjectTy.dyn_cast<fir::BoxType>())
       return doRewriteBox(coor, ty, operands, loc, rewriter);
 
     // Reference, pointer or a heap type
     if (baseObjectTy.isa<fir::ReferenceType, fir::PointerType, fir::HeapType>())
return fir::hasDynamicSize(ty)
                      .getInt()
                : getIntValue(op);
   }
 
   static int64_t getIntValue(mlir::Value val) {
     assert(val && val.dyn_cast<mlir::OpResult>() && "must not be null value");
     mlir::Operation *defop = val.getDefiningOp();
 
-    if (auto constOp = dyn_cast<mlir::arith::ConstantIntOp>(defop))
+    if (auto constOp = mlir::dyn_cast<mlir::arith::ConstantIntOp>(defop))
       return constOp.value();
-    if (auto llConstOp = dyn_cast<mlir::LLVM::ConstantOp>(defop))
+    if (auto llConstOp = mlir::dyn_cast<mlir::LLVM::ConstantOp>(defop))
       if (auto attr = llConstOp.getValue().dyn_cast<mlir::IntegerAttr>())
         return attr.getValue().getSExtValue();
     fir::emitFatalError(val.getLoc(), "must be a constant");
   }
 
   static bool hasSubDimensions(mlir::Type type) {
     return type.isa<fir::SequenceType, fir::RecordType, mlir::TupleType>();
   }
doRewriteBox(fir::CoordinateOp coor, mlir::Type ty, mlir::ValueRange operands,
 
     // 1. SPECIAL CASE (uses `fir.len_param_index`):
     //   %box = ... : !fir.box<!fir.type<derived{len1:i32}>>
     //   %lenp = fir.len_param_index len1, !fir.type<derived{len1:i32}>
     //   %addr = coordinate_of %box, %lenp
     if (coor.getNumOperands() == 2) {
       mlir::Operation *coordinateDef =
           (*coor.getCoor().begin()).getDefiningOp();
-      if (isa_and_nonnull<fir::LenParamIndexOp>(coordinateDef))
+      if (mlir::isa_and_nonnull<fir::LenParamIndexOp>(coordinateDef))
         TODO(loc,
              "fir.coordinate_of - fir.len_param_index is not supported yet");
     }
 
     // 2. GENERAL CASE:
     // 2.1. (`fir.array`)
     //   %box = ... : !fix.box<!fir.array<?xU>>
     //   %idx = ... : index
for (unsigned i = 1, last = operands.size(); i < last; ++i) {
           mlir::Value stride =
               loadStrideFromBox(loc, operands[0], index - i, rewriter);
           auto sc = rewriter.create<mlir::LLVM::MulOp>(loc, idxTy,
                                                        operands[index], stride);
           off = rewriter.create<mlir::LLVM::AddOp>(loc, idxTy, sc, off);
         }
         auto voidPtrBase =
             rewriter.create<mlir::LLVM::BitcastOp>(loc, voidPtrTy, resultAddr);
-        SmallVector<mlir::Value> args{off};
+        llvm::SmallVector<mlir::Value> args{off};
         resultAddr = rewriter.create<mlir::LLVM::GEPOp>(loc, voidPtrTy,
                                                         voidPtrBase, args);
         i += arrTy.getDimension() - 1;
         cpnTy = arrTy.getEleTy();
       } else if (auto recTy = cpnTy.dyn_cast<fir::RecordType>()) {
         auto recRefTy =
             mlir::LLVM::LLVMPointerType::get(lowerTy().convertType(recTy));
         mlir::Value nxtOpnd = operands[i];
         auto memObj =
             rewriter.create<mlir::LLVM::BitcastOp>(loc, recRefTy, resultAddr);
         llvm::SmallVector<mlir::Value> args = {c0, nxtOpnd};
         cpnTy = recTy.getType(getFieldNumber(recTy, nxtOpnd));
         auto llvmCurrentObjTy = lowerTy().convertType(cpnTy);
         auto gep = rewriter.create<mlir::LLVM::GEPOp>(
             loc, mlir::LLVM::LLVMPointerType::get(llvmCurrentObjTy), memObj,
             args);
         resultAddr =
             rewriter.create<mlir::LLVM::BitcastOp>(loc, voidPtrTy, gep);
       } else {
         fir::emitFatalError(loc, "unexpected type in coordinate_of");
       }
     }
 
     rewriter.replaceOpWithNewOp<mlir::LLVM::BitcastOp>(coor, ty, resultAddr);
-    return success();
+    return mlir::success();
   }
 
   mlir::LogicalResult
   doRewriteRefOrPtr(fir::CoordinateOp coor, mlir::Type ty,
                     mlir::ValueRange operands, mlir::Location loc,
                     mlir::ConversionPatternRewriter &rewriter) const {
     mlir::Type baseObjectTy = coor.getBaseType();
 
if (auto arrTy = cpnTy.dyn_cast<fir::SequenceType>()) {
       }
     }
 
     if (fir::hasDynamicSize(fir::unwrapSequenceType(cpnTy)))
       return mlir::emitError(
           loc, "fir.coordinate_of with a dynamic element size is unsupported");
 
     if (hasKnownShape || columnIsDeferred) {
-      SmallVector<mlir::Value> offs;
+      llvm::SmallVector<mlir::Value> offs;
       if (hasKnownShape && hasSubdimension) {
         mlir::LLVM::ConstantOp c0 =
             genConstantIndex(loc, lowerTy().indexType(), rewriter, 0);
         offs.push_back(c0);
       }
-      Optional<int> dims;
-      SmallVector<mlir::Value> arrIdx;
+      llvm::Optional<int> dims;
+      llvm::SmallVector<mlir::Value> arrIdx;
       for (std::size_t i = 1, sz = operands.size(); i < sz; ++i) {
         mlir::Value nxtOpnd = operands[i];
 
         if (!cpnTy)
           return mlir::emitError(loc, "invalid coordinate/check failed");
 
         // check if the i-th coordinate relates to an array
         if (dims.hasValue()) {
if (hasKnownShape || columnIsDeferred) {
 
         offs.push_back(nxtOpnd);
       }
       if (dims.hasValue())
         offs.append(arrIdx.rbegin(), arrIdx.rend());
       mlir::Value base = operands[0];
       mlir::Value retval = genGEP(loc, ty, rewriter, base, offs);
       rewriter.replaceOp(coor, retval);
-      return success();
+      return mlir::success();
     }
 
     return mlir::emitError(
         loc, "fir.coordinate_of base operand has unsupported type");
   }
 };
 
 /// Convert `fir.field_index`. The conversion depends on whether the size of
 /// the record is static or dynamic.
 struct FieldIndexOpConversion : public FIROpConversion<fir::FieldIndexOp> {
   using FIROpConversion::FIROpConversion;
 
   // NB: most field references should be resolved by this point
   mlir::LogicalResult
   matchAndRewrite(fir::FieldIndexOp field, OpAdaptor adaptor,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     auto recTy = field.getOnType().cast<fir::RecordType>();
     unsigned index = recTy.getFieldIndex(field.getFieldId());
 
     if (!fir::hasDynamicSize(recTy)) {
       // Derived type has compile-time constant layout. Return index of the
       // component type in the parent type (to be used in GEP).
       rewriter.replaceOp(field, mlir::ValueRange{genConstantOffset(
                                     field.getLoc(), rewriter, index)});
-      return success();
+      return mlir::success();
     }
 
     // Derived type has compile-time constant layout. Call the compiler
     // generated function to determine the byte offset of the field at runtime.
     // This returns a non-constant.
-    FlatSymbolRefAttr symAttr = mlir::SymbolRefAttr::get(
+    mlir::FlatSymbolRefAttr symAttr = mlir::SymbolRefAttr::get(
         field.getContext(), getOffsetMethodName(recTy, field.getFieldId()));
-    NamedAttribute callAttr = rewriter.getNamedAttr("callee", symAttr);
-    NamedAttribute fieldAttr = rewriter.getNamedAttr(
+    mlir::NamedAttribute callAttr = rewriter.getNamedAttr("callee", symAttr);
+    mlir::NamedAttribute fieldAttr = rewriter.getNamedAttr(
         "field", mlir::IntegerAttr::get(lowerTy().indexType(), index));
     rewriter.replaceOpWithNewOp<mlir::LLVM::CallOp>(
         field, lowerTy().offsetType(), adaptor.getOperands(),
         llvm::ArrayRef<mlir::NamedAttribute>{callAttr, fieldAttr});
-    return success();
+    return mlir::success();
   }
 
   // Re-Construct the name of the compiler generated method that calculates the
   // offset
   inline static std::string getOffsetMethodName(fir::RecordType recTy,
                                                 llvm::StringRef field) {
     return recTy.getName().str() + "P." + field.str() + ".offset";
   }
 };
 
 /// Convert `fir.end`
 struct FirEndOpConversion : public FIROpConversion<fir::FirEndOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::LogicalResult
   matchAndRewrite(fir::FirEndOp firEnd, OpAdaptor,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     TODO(firEnd.getLoc(), "fir.end codegen");
-    return failure();
+    return mlir::failure();
   }
 };
 
 /// Lower `fir.gentypedesc` to a global constant.
 struct GenTypeDescOpConversion : public FIROpConversion<fir::GenTypeDescOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::LogicalResult
   matchAndRewrite(fir::GenTypeDescOp gentypedesc, OpAdaptor adaptor,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     TODO(gentypedesc.getLoc(), "fir.gentypedesc codegen");
-    return failure();
+    return mlir::failure();
   }
 };
 
 /// Lower `fir.has_value` operation to `llvm.return` operation.
 struct HasValueOpConversion : public FIROpConversion<fir::HasValueOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::LogicalResult
   matchAndRewrite(fir::HasValueOp op, OpAdaptor adaptor,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    rewriter.replaceOpWithNewOp<LLVM::ReturnOp>(op, adaptor.getOperands());
-    return success();
+    rewriter.replaceOpWithNewOp<mlir::LLVM::ReturnOp>(op,
+                                                      adaptor.getOperands());
+    return mlir::success();
   }
 };
 
 /// Lower `fir.global` operation to `llvm.global` operation.
 /// `fir.insert_on_range` operations are replaced with constant dense attribute
 /// if they are applied on the full range.
 struct GlobalOpConversion : public FIROpConversion<fir::GlobalOp> {
   using FIROpConversion::FIROpConversion;
if (!gr.empty()) {
         if (isFullRange(insertOp.getCoor(), insertOp.getType())) {
           auto seqTyAttr = convertType(insertOp.getType());
           auto *op = insertOp.getVal().getDefiningOp();
           auto constant = mlir::dyn_cast<mlir::arith::ConstantOp>(op);
           if (!constant) {
             auto convertOp = mlir::dyn_cast<fir::ConvertOp>(op);
             if (!convertOp)
               continue;
-            constant = cast<mlir::arith::ConstantOp>(
+            constant = mlir::cast<mlir::arith::ConstantOp>(
                 convertOp.getValue().getDefiningOp());
           }
           mlir::Type vecType = mlir::VectorType::get(
               insertOp.getType().getShape(), constant.getType());
           auto denseAttr = mlir::DenseElementsAttr::get(
-              vecType.cast<ShapedType>(), constant.getValue());
+              vecType.cast<mlir::ShapedType>(), constant.getValue());
           rewriter.setInsertionPointAfter(insertOp);
           rewriter.replaceOpWithNewOp<mlir::arith::ConstantOp>(
               insertOp, seqTyAttr, denseAttr);
         }
       }
     }
     rewriter.eraseOp(global);
-    return success();
+    return mlir::success();
   }
 
   bool isFullRange(mlir::DenseIntElementsAttr indexes,
                    fir::SequenceType seqTy) const {
     auto extents = seqTy.getShape();
     if (indexes.size() / 2 != static_cast<int64_t>(extents.size()))
       return false;
     auto cur_index = indexes.value_begin<int64_t>();
     for (unsigned i = 0; i < indexes.size(); i += 2) {
       if (*(cur_index++) != 0)
         return false;
       if (*(cur_index++) != extents[i / 2] - 1)
         return false;
     }
     return true;
   }
 
   // TODO: String comparaison should be avoided. Replace linkName with an
   // enumeration.
-  mlir::LLVM::Linkage convertLinkage(Optional<StringRef> optLinkage) const {
+  mlir::LLVM::Linkage
+  convertLinkage(llvm::Optional<llvm::StringRef> optLinkage) const {
     if (optLinkage.hasValue()) {
       auto name = optLinkage.getValue();
       if (name == "internal")
         return mlir::LLVM::Linkage::Internal;
       if (name == "linkonce")
         return mlir::LLVM::Linkage::Linkonce;
       if (name == "linkonce_odr")
         return mlir::LLVM::Linkage::LinkonceODR;
matchAndRewrite(fir::LoadOp load, OpAdaptor adaptor,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     // fir.box is a special case because it is considered as an ssa values in
     // fir, but it is lowered as a pointer to a descriptor. So fir.ref<fir.box>
     // and fir.box end up being the same llvm types and loading a
     // fir.ref<fir.box> is actually a no op in LLVM.
     if (load.getType().isa<fir::BoxType>()) {
       rewriter.replaceOp(load, adaptor.getOperands()[0]);
     } else {
-      mlir::Type ty = convertType(load.getType());
-      ArrayRef<NamedAttribute> at = load->getAttrs();
       rewriter.replaceOpWithNewOp<mlir::LLVM::LoadOp>(
-          load, ty, adaptor.getOperands(), at);
+          load, convertType(load.getType()), adaptor.getOperands(),
+          load->getAttrs());
     }
-    return success();
+    return mlir::success();
   }
 };
 
 /// Lower `fir.no_reassoc` to LLVM IR dialect.
 /// TODO: how do we want to enforce this in LLVM-IR? Can we manipulate the fast
 /// math flags?
 struct NoReassocOpConversion : public FIROpConversion<fir::NoReassocOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::LogicalResult
   matchAndRewrite(fir::NoReassocOp noreassoc, OpAdaptor adaptor,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     rewriter.replaceOp(noreassoc, adaptor.getOperands()[0]);
-    return success();
+    return mlir::success();
   }
 };
 
 static void genCondBrOp(mlir::Location loc, mlir::Value cmp, mlir::Block *dest,
-                        Optional<mlir::ValueRange> destOps,
+                        llvm::Optional<mlir::ValueRange> destOps,
                         mlir::ConversionPatternRewriter &rewriter,
                         mlir::Block *newBlock) {
   if (destOps.hasValue())
     rewriter.create<mlir::LLVM::CondBrOp>(loc, cmp, dest, destOps.getValue(),
                                           newBlock, mlir::ValueRange());
   else
     rewriter.create<mlir::LLVM::CondBrOp>(loc, cmp, dest, newBlock);
 }
 
 template <typename A, typename B>
-static void genBrOp(A caseOp, mlir::Block *dest, Optional<B> destOps,
+static void genBrOp(A caseOp, mlir::Block *dest, llvm::Optional<B> destOps,
                     mlir::ConversionPatternRewriter &rewriter) {
   if (destOps.hasValue())
     rewriter.replaceOpWithNewOp<mlir::LLVM::BrOp>(caseOp, destOps.getValue(),
                                                   dest);
   else
     rewriter.replaceOpWithNewOp<mlir::LLVM::BrOp>(caseOp, llvm::None, dest);
 }
 
 static void genCaseLadderStep(mlir::Location loc, mlir::Value cmp,
                               mlir::Block *dest,
-                              Optional<mlir::ValueRange> destOps,
+                              llvm::Optional<mlir::ValueRange> destOps,
                               mlir::ConversionPatternRewriter &rewriter) {
   auto *thisBlock = rewriter.getInsertionBlock();
   auto *newBlock = createBlock(rewriter, dest);
   rewriter.setInsertionPointToEnd(thisBlock);
   genCondBrOp(loc, cmp, dest, destOps, rewriter, newBlock);
   rewriter.setInsertionPointToEnd(newBlock);
 }
 
struct SelectCaseOpConversion : public FIROpConversion<fir::SelectCaseOp> {
   matchAndRewrite(fir::SelectCaseOp caseOp, OpAdaptor adaptor,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     unsigned conds = caseOp.getNumConditions();
     llvm::ArrayRef<mlir::Attribute> cases = caseOp.getCases().getValue();
     // Type can be CHARACTER, INTEGER, or LOGICAL (C1145)
     auto ty = caseOp.getSelector().getType();
     if (ty.isa<fir::CharacterType>()) {
       TODO(caseOp.getLoc(), "fir.select_case codegen with character type");
-      return failure();
+      return mlir::failure();
     }
     mlir::Value selector = caseOp.getSelector(adaptor.getOperands());
     auto loc = caseOp.getLoc();
     for (unsigned t = 0; t != conds; ++t) {
       mlir::Block *dest = caseOp.getSuccessor(t);
       llvm::Optional<mlir::ValueRange> destOps =
           caseOp.getSuccessorOperands(adaptor.getOperands(), t);
       llvm::Optional<mlir::ValueRange> cmpOps =
for (unsigned t = 0; t != conds; ++t) {
         genCondBrOp(loc, cmp0, dest, destOps, rewriter, newBlock2);
         rewriter.setInsertionPointToEnd(newBlock2);
         continue;
       }
       assert(attr.isa<mlir::UnitAttr>());
       assert((t + 1 == conds) && "unit must be last");
       genBrOp(caseOp, dest, destOps, rewriter);
     }
-    return success();
+    return mlir::success();
   }
 };
 
 template <typename OP>
 static void selectMatchAndRewrite(fir::LLVMTypeConverter &lowering, OP select,
                                   typename OP::Adaptor adaptor,
                                   mlir::ConversionPatternRewriter &rewriter) {
   unsigned conds = select.getNumConditions();
static void selectMatchAndRewrite(fir::LLVMTypeConverter &lowering, OP select,
 
   for (unsigned t = 0; t != conds; ++t) {
     mlir::Block *dest = select.getSuccessor(t);
     auto destOps = select.getSuccessorOperands(adaptor.getOperands(), t);
     const mlir::Attribute &attr = cases[t];
     if (auto intAttr = attr.template dyn_cast<mlir::IntegerAttr>()) {
       destinations.push_back(dest);
       destinationsOperands.push_back(destOps.hasValue() ? *destOps
-                                                        : ValueRange());
+                                                        : mlir::ValueRange{});
       caseValues.push_back(intAttr.getInt());
       continue;
     }
     assert(attr.template dyn_cast_or_null<mlir::UnitAttr>());
     assert((t + 1 == conds) && "unit must be last");
     defaultDestination = dest;
-    defaultOperands = destOps.hasValue() ? *destOps : ValueRange();
+    defaultOperands = destOps.hasValue() ? *destOps : mlir::ValueRange{};
   }
 
   // LLVM::SwitchOp takes a i32 type for the selector.
   if (select.getSelector().getType() != rewriter.getI32Type())
-    selector =
-        rewriter.create<LLVM::TruncOp>(loc, rewriter.getI32Type(), selector);
+    selector = rewriter.create<mlir::LLVM::TruncOp>(loc, rewriter.getI32Type(),
+                                                    selector);
 
   rewriter.replaceOpWithNewOp<mlir::LLVM::SwitchOp>(
       select, selector,
       /*defaultDestination=*/defaultDestination,
       /*defaultOperands=*/defaultOperands,
       /*caseValues=*/caseValues,
       /*caseDestinations=*/destinations,
       /*caseOperands=*/destinationsOperands,
-      /*branchWeights=*/ArrayRef<int32_t>());
+      /*branchWeights=*/llvm::ArrayRef<std::int32_t>());
 }
 
 /// conversion of fir::SelectOp to an if-then-else ladder
 struct SelectOpConversion : public FIROpConversion<fir::SelectOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::LogicalResult
   matchAndRewrite(fir::SelectOp op, OpAdaptor adaptor,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     selectMatchAndRewrite<fir::SelectOp>(lowerTy(), op, adaptor, rewriter);
-    return success();
+    return mlir::success();
   }
 };
 
 /// conversion of fir::SelectRankOp to an if-then-else ladder
 struct SelectRankOpConversion : public FIROpConversion<fir::SelectRankOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::LogicalResult
   matchAndRewrite(fir::SelectRankOp op, OpAdaptor adaptor,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     selectMatchAndRewrite<fir::SelectRankOp>(lowerTy(), op, adaptor, rewriter);
-    return success();
+    return mlir::success();
   }
 };
 
 /// Lower `fir.select_type` to LLVM IR dialect.
 struct SelectTypeOpConversion : public FIROpConversion<fir::SelectTypeOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::LogicalResult
   matchAndRewrite(fir::SelectTypeOp select, OpAdaptor adaptor,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     mlir::emitError(select.getLoc(),
                     "fir.select_type should have already been converted");
-    return failure();
+    return mlir::failure();
   }
 };
 
 /// `fir.store` --> `llvm.store`
 struct StoreOpConversion : public FIROpConversion<fir::StoreOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::LogicalResult
   matchAndRewrite(fir::StoreOp store, OpAdaptor adaptor,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     if (store.getValue().getType().isa<fir::BoxType>()) {
       // fir.box value is actually in memory, load it first before storing it.
       mlir::Location loc = store.getLoc();
       mlir::Type boxPtrTy = adaptor.getOperands()[0].getType();
       auto val = rewriter.create<mlir::LLVM::LoadOp>(
           loc, boxPtrTy.cast<mlir::LLVM::LLVMPointerType>().getElementType(),
           adaptor.getOperands()[0]);
       rewriter.replaceOpWithNewOp<mlir::LLVM::StoreOp>(
           store, val, adaptor.getOperands()[1]);
     } else {
       rewriter.replaceOpWithNewOp<mlir::LLVM::StoreOp>(
           store, adaptor.getOperands()[0], adaptor.getOperands()[1]);
     }
-    return success();
+    return mlir::success();
   }
 };
 
 namespace {
 
 /// Convert `fir.unboxchar` into two `llvm.extractvalue` instructions. One for
 /// the character buffer and one for the buffer length.
 struct UnboxCharOpConversion : public FIROpConversion<fir::UnboxCharOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::LogicalResult
   matchAndRewrite(fir::UnboxCharOp unboxchar, OpAdaptor adaptor,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    MLIRContext *ctx = unboxchar.getContext();
+    auto *ctx = unboxchar.getContext();
 
     mlir::Type lenTy = convertType(unboxchar.getType(1));
     mlir::Value tuple = adaptor.getOperands()[0];
     mlir::Type tupleTy = tuple.getType();
 
     mlir::Location loc = unboxchar.getLoc();
     mlir::Value ptrToBuffer =
         genExtractValueWithIndex(loc, tuple, tupleTy, rewriter, ctx, 0);
 
     mlir::LLVM::ExtractValueOp len =
         genExtractValueWithIndex(loc, tuple, tupleTy, rewriter, ctx, 1);
     mlir::Value lenAfterCast = integerCast(loc, rewriter, lenTy, len);
 
     rewriter.replaceOp(unboxchar,
-                       ArrayRef<mlir::Value>{ptrToBuffer, lenAfterCast});
-    return success();
+                       llvm::ArrayRef<mlir::Value>{ptrToBuffer, lenAfterCast});
+    return mlir::success();
   }
 };
 
 /// Lower `fir.unboxproc` operation. Unbox a procedure box value, yielding its
 /// components.
 /// TODO: Part of supporting Fortran 2003 procedure pointers.
 struct UnboxProcOpConversion : public FIROpConversion<fir::UnboxProcOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::LogicalResult
   matchAndRewrite(fir::UnboxProcOp unboxproc, OpAdaptor adaptor,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     TODO(unboxproc.getLoc(), "fir.unboxproc codegen");
-    return failure();
+    return mlir::failure();
   }
 };
 
 /// convert to LLVM IR dialect `undef`
 struct UndefOpConversion : public FIROpConversion<fir::UndefOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::LogicalResult
   matchAndRewrite(fir::UndefOp undef, OpAdaptor,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     rewriter.replaceOpWithNewOp<mlir::LLVM::UndefOp>(
         undef, convertType(undef.getType()));
-    return success();
+    return mlir::success();
   }
 };
 
 struct ZeroOpConversion : public FIROpConversion<fir::ZeroOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::LogicalResult
   matchAndRewrite(fir::ZeroOp zero, OpAdaptor,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     mlir::Type ty = convertType(zero.getType());
     if (ty.isa<mlir::LLVM::LLVMPointerType>()) {
       rewriter.replaceOpWithNewOp<mlir::LLVM::NullOp>(zero, ty);
     } else if (ty.isa<mlir::IntegerType>()) {
       rewriter.replaceOpWithNewOp<mlir::LLVM::ConstantOp>(
           zero, ty, mlir::IntegerAttr::get(zero.getType(), 0));
     } else if (mlir::LLVM::isCompatibleFloatingPointType(ty)) {
       rewriter.replaceOpWithNewOp<mlir::LLVM::ConstantOp>(
           zero, ty, mlir::FloatAttr::get(zero.getType(), 0.0));
     } else {
       // TODO: create ConstantAggregateZero for FIR aggregate/array types.
       return rewriter.notifyMatchFailure(
           zero,
           "conversion of fir.zero with aggregate type not implemented yet");
     }
-    return success();
+    return mlir::success();
   }
 };
 
 /// `fir.unreachable` --> `llvm.unreachable`
 struct UnreachableOpConversion : public FIROpConversion<fir::UnreachableOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::LogicalResult
   matchAndRewrite(fir::UnreachableOp unreach, OpAdaptor adaptor,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     rewriter.replaceOpWithNewOp<mlir::LLVM::UnreachableOp>(unreach);
-    return success();
+    return mlir::success();
   }
 };
 
 /// `fir.is_present` -->
 /// ```
 ///  %0 = llvm.mlir.constant(0 : i64)
 ///  %1 = llvm.ptrtoint %0
 ///  %2 = llvm.icmp "ne" %1, %0 : i64
if (isPresent.getVal().getType().isa<fir::BoxCharType>()) {
       ptr = rewriter.create<mlir::LLVM::ExtractValueOp>(loc, ty, ptr, c0);
     }
     mlir::LLVM::ConstantOp c0 =
         genConstantIndex(isPresent.getLoc(), idxTy, rewriter, 0);
     auto addr = rewriter.create<mlir::LLVM::PtrToIntOp>(loc, idxTy, ptr);
     rewriter.replaceOpWithNewOp<mlir::LLVM::ICmpOp>(
         isPresent, mlir::LLVM::ICmpPredicate::ne, addr, c0);
 
-    return success();
+    return mlir::success();
   }
 };
 
 /// Create value signaling an absent optional argument in a call, e.g.
 /// `fir.absent !fir.ref<i64>` -->  `llvm.mlir.null : !llvm.ptr<i64>`
 struct AbsentOpConversion : public FIROpConversion<fir::AbsentOp> {
   using FIROpConversion::FIROpConversion;
 
if (absent.getType().isa<fir::BoxCharType>()) {
           rewriter.create<mlir::LLVM::NullOp>(loc, structTy.getBody()[0]);
       mlir::MLIRContext *ctx = absent.getContext();
       auto c0 = mlir::ArrayAttr::get(ctx, rewriter.getI32IntegerAttr(0));
       rewriter.replaceOpWithNewOp<mlir::LLVM::InsertValueOp>(
           absent, ty, undefStruct, nullField, c0);
     } else {
       rewriter.replaceOpWithNewOp<mlir::LLVM::NullOp>(absent, ty);
     }
-    return success();
+    return mlir::success();
   }
 };
 
 //
 // Primitive operations on Complex types
 //
 
 /// Generate inline code for complex addition/subtraction
struct AddcOpConversion : public FIROpConversion<fir::AddcOp> {
   mlir::LogicalResult
   matchAndRewrite(fir::AddcOp addc, OpAdaptor adaptor,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     // given: (x + iy) + (x' + iy')
     // result: (x + x') + i(y + y')
     auto r = complexSum<mlir::LLVM::FAddOp>(addc, adaptor.getOperands(),
                                             rewriter, lowerTy());
     rewriter.replaceOp(addc, r.getResult());
-    return success();
+    return mlir::success();
   }
 };
 
 struct SubcOpConversion : public FIROpConversion<fir::SubcOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::LogicalResult
   matchAndRewrite(fir::SubcOp subc, OpAdaptor adaptor,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     // given: (x + iy) - (x' + iy')
     // result: (x - x') + i(y - y')
     auto r = complexSum<mlir::LLVM::FSubOp>(subc, adaptor.getOperands(),
                                             rewriter, lowerTy());
     rewriter.replaceOp(subc, r.getResult());
-    return success();
+    return mlir::success();
   }
 };
 
 /// Inlined complex multiply
 struct MulcOpConversion : public FIROpConversion<fir::MulcOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::LogicalResult
matchAndRewrite(fir::MulcOp mulc, OpAdaptor adaptor,
     auto xy = rewriter.create<mlir::LLVM::FMulOp>(loc, eleTy, x0, y1);
     auto ri = rewriter.create<mlir::LLVM::FAddOp>(loc, eleTy, xy, yx);
     auto yy = rewriter.create<mlir::LLVM::FMulOp>(loc, eleTy, y0, y1);
     auto rr = rewriter.create<mlir::LLVM::FSubOp>(loc, eleTy, xx, yy);
     auto ra = rewriter.create<mlir::LLVM::UndefOp>(loc, ty);
     auto r1 = rewriter.create<mlir::LLVM::InsertValueOp>(loc, ty, ra, rr, c0);
     auto r0 = rewriter.create<mlir::LLVM::InsertValueOp>(loc, ty, r1, ri, c1);
     rewriter.replaceOp(mulc, r0.getResult());
-    return success();
+    return mlir::success();
   }
 };
 
 /// Inlined complex division
 struct DivcOpConversion : public FIROpConversion<fir::DivcOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::LogicalResult
matchAndRewrite(fir::DivcOp divc, OpAdaptor adaptor,
     auto rrn = rewriter.create<mlir::LLVM::FAddOp>(loc, eleTy, xx, yy);
     auto rin = rewriter.create<mlir::LLVM::FSubOp>(loc, eleTy, yx, xy);
     auto rr = rewriter.create<mlir::LLVM::FDivOp>(loc, eleTy, rrn, d);
     auto ri = rewriter.create<mlir::LLVM::FDivOp>(loc, eleTy, rin, d);
     auto ra = rewriter.create<mlir::LLVM::UndefOp>(loc, ty);
     auto r1 = rewriter.create<mlir::LLVM::InsertValueOp>(loc, ty, ra, rr, c0);
     auto r0 = rewriter.create<mlir::LLVM::InsertValueOp>(loc, ty, r1, ri, c1);
     rewriter.replaceOp(divc, r0.getResult());
-    return success();
+    return mlir::success();
   }
 };
 
 /// Inlined complex negation
 struct NegcOpConversion : public FIROpConversion<fir::NegcOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::LogicalResult
matchAndRewrite(fir::NegcOp neg, OpAdaptor adaptor,
     auto c0 = mlir::ArrayAttr::get(ctxt, rewriter.getI32IntegerAttr(0));
     auto c1 = mlir::ArrayAttr::get(ctxt, rewriter.getI32IntegerAttr(1));
     auto rp = rewriter.create<mlir::LLVM::ExtractValueOp>(loc, eleTy, o0, c0);
     auto ip = rewriter.create<mlir::LLVM::ExtractValueOp>(loc, eleTy, o0, c1);
     auto nrp = rewriter.create<mlir::LLVM::FNegOp>(loc, eleTy, rp);
     auto nip = rewriter.create<mlir::LLVM::FNegOp>(loc, eleTy, ip);
     auto r = rewriter.create<mlir::LLVM::InsertValueOp>(loc, ty, o0, nrp, c0);
     rewriter.replaceOpWithNewOp<mlir::LLVM::InsertValueOp>(neg, ty, r, nip, c1);
-    return success();
+    return mlir::success();
   }
 };
 
 /// Conversion pattern for operation that must be dead. The information in these
 /// operations is used by other operation. At this point they should not have
 /// anymore uses.
 /// These operations are normally dead after the pre-codegen pass.
 template <typename FromOp>
 struct MustBeDeadConversion : public FIROpConversion<FromOp> {
   explicit MustBeDeadConversion(fir::LLVMTypeConverter &lowering,
                                 const fir::FIRToLLVMPassOptions &options)
       : FIROpConversion<FromOp>(lowering, options) {}
   using OpAdaptor = typename FromOp::Adaptor;
 
   mlir::LogicalResult
   matchAndRewrite(FromOp op, OpAdaptor adaptor,
                   mlir::ConversionPatternRewriter &rewriter) const final {
     if (!op->getUses().empty())
       return rewriter.notifyMatchFailure(op, "op must be dead");
     rewriter.eraseOp(op);
-    return success();
+    return mlir::success();
   }
 };
 
 struct ShapeOpConversion : public MustBeDeadConversion<fir::ShapeOp> {
   using MustBeDeadConversion::MustBeDeadConversion;
 };
 
 struct ShapeShiftOpConversion : public MustBeDeadConversion<fir::ShapeShiftOp> {

 class FIRToLLVMLowering : public fir::FIRToLLVMLoweringBase<FIRToLLVMLowering> {
 public:
   FIRToLLVMLowering() = default;
   FIRToLLVMLowering(fir::FIRToLLVMPassOptions options) : options{options} {}
   mlir::ModuleOp getModule() { return getOperation(); }
 
   void runOnOperation() override final {
     auto mod = getModule();
-    if (!forcedTargetTriple.empty()) {
+    if (!forcedTargetTriple.empty())
       fir::setTargetTriple(mod, forcedTargetTriple);
-    }
 
     auto *context = getModule().getContext();
     fir::LLVMTypeConverter typeConverter{getModule()};
     mlir::RewritePatternSet pattern(context);
     pattern.insert<
         AbsentOpConversion, AddcOpConversion, AddrOfOpConversion,
         AllocaOpConversion, AllocMemOpConversion, BoxAddrOpConversion,
         BoxCharLenOpConversion, BoxDimsOpConversion, BoxEleSizeOpConversion,

 };
 
 /// Lower from LLVM IR dialect to proper LLVM-IR and dump the module
 struct LLVMIRLoweringPass
     : public mlir::PassWrapper<LLVMIRLoweringPass,
                                mlir::OperationPass<mlir::ModuleOp>> {
   MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(LLVMIRLoweringPass)
 
-  using Printer = fir::LLVMIRLoweringPrinter;
-  LLVMIRLoweringPass(raw_ostream &output, Printer p)
+  LLVMIRLoweringPass(llvm::raw_ostream &output, fir::LLVMIRLoweringPrinter p)
       : output{output}, printer{p} {}
 
   mlir::ModuleOp getModule() { return getOperation(); }
 
   void runOnOperation() override final {
     auto *ctx = getModule().getContext();
     auto optName = getModule().getName();
     llvm::LLVMContext llvmCtx;
     if (auto llvmModule = mlir::translateModuleToLLVMIR(
             getModule(), llvmCtx, optName ? *optName : "FIRModule")) {
       printer(*llvmModule, output);
       return;
     }
 
     mlir::emitError(mlir::UnknownLoc::get(ctx), "could not emit LLVM-IR\n");
     signalPassFailure();
   }
 
 private:
-  raw_ostream &output;
-  Printer printer;
+  llvm::raw_ostream &output;
+  fir::LLVMIRLoweringPrinter printer;
 };
 
 } // namespace
 
 std::unique_ptr<mlir::Pass> fir::createFIRToLLVMPass() {
   return std::make_unique<FIRToLLVMLowering>();
 }
 
 std::unique_ptr<mlir::Pass>
-fir::createFIRToLLVMPass(FIRToLLVMPassOptions options) {
+fir::createFIRToLLVMPass(fir::FIRToLLVMPassOptions options) {
   return std::make_unique<FIRToLLVMLowering>(options);
 }
 
 std::unique_ptr<mlir::Pass>
-fir::createLLVMDialectToLLVMPass(raw_ostream &output,
+fir::createLLVMDialectToLLVMPass(llvm::raw_ostream &output,
                                  fir::LLVMIRLoweringPrinter printer) {
   return std::make_unique<LLVMIRLoweringPass>(output, printer);
 }

flang/lib/Optimizer/CodeGen/TargetRewrite.cpp

 #include "flang/Optimizer/Dialect/FIROpsSupport.h"
 #include "flang/Optimizer/Dialect/FIRType.h"
 #include "flang/Optimizer/Support/FIRContext.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/TypeSwitch.h"
 #include "llvm/Support/Debug.h"
 
-using namespace fir;
-using namespace mlir;
-
 #define DEBUG_TYPE "flang-target-rewrite"
 
 namespace {
 
 /// Fixups for updating a FuncOp's arguments and return values.
 struct FixupTy {
   enum class Codes {
     ArgumentAsLoad,
struct FixupTy {
   std::size_t second{};
   llvm::Optional<std::function<void(mlir::func::FuncOp)>> finalizer{};
 }; // namespace
 
 /// Target-specific rewriting of the FIR. This is a prerequisite pass to code
 /// generation that traverses the FIR and modifies types and operations to a
 /// form that is appropriate for the specific target. LLVM IR has specific
 /// idioms that are used for distinct target processor and ABI combinations.
-class TargetRewrite : public TargetRewriteBase<TargetRewrite> {
+class TargetRewrite : public fir::TargetRewriteBase<TargetRewrite> {
 public:
-  TargetRewrite(const TargetRewriteOptions &options) {
+  TargetRewrite(const fir::TargetRewriteOptions &options) {
     noCharacterConversion = options.noCharacterConversion;
     noComplexConversion = options.noComplexConversion;
   }
 
   void runOnOperation() override final {
     auto &context = getContext();
     mlir::OpBuilder rewriter(&context);
 
     auto mod = getModule();
     if (!forcedTargetTriple.empty())
-      setTargetTriple(mod, forcedTargetTriple);
+      fir::setTargetTriple(mod, forcedTargetTriple);
 
-    auto specifics = CodeGenSpecifics::get(
-        mod.getContext(), getTargetTriple(mod), getKindMapping(mod));
+    auto specifics = fir::CodeGenSpecifics::get(
+        mod.getContext(), fir::getTargetTriple(mod), fir::getKindMapping(mod));
     setMembers(specifics.get(), &rewriter);
 
     // Perform type conversion on signatures and call sites.
     if (mlir::failed(convertTypes(mod))) {
       mlir::emitError(mlir::UnknownLoc::get(&context),
                       "error in converting types to target abi");
       signalPassFailure();
     }
 
     // Convert ops in target-specific patterns.
     mod.walk([&](mlir::Operation *op) {
-      if (auto call = dyn_cast<fir::CallOp>(op)) {
+      if (auto call = mlir::dyn_cast<fir::CallOp>(op)) {
         if (!hasPortableSignature(call.getFunctionType()))
           convertCallOp(call);
-      } else if (auto dispatch = dyn_cast<DispatchOp>(op)) {
+      } else if (auto dispatch = mlir::dyn_cast<fir::DispatchOp>(op)) {
         if (!hasPortableSignature(dispatch.getFunctionType()))
           convertCallOp(dispatch);
-      } else if (auto addr = dyn_cast<AddrOfOp>(op)) {
+      } else if (auto addr = mlir::dyn_cast<fir::AddrOfOp>(op)) {
         if (addr.getType().isa<mlir::FunctionType>() &&
             !hasPortableSignature(addr.getType()))
           convertAddrOp(addr);
       }
     });
 
     clearMembers();
   }
 
   mlir::ModuleOp getModule() { return getOperation(); }
 
   template <typename A, typename B, typename C>
   std::function<mlir::Value(mlir::Operation *)>
   rewriteCallComplexResultType(A ty, B &newResTys, B &newInTys, C &newOpers) {
     auto m = specifics->complexReturnType(ty.getElementType());
     // Currently targets mandate COMPLEX is a single aggregate or packed
     // scalar, including the sret case.
     assert(m.size() == 1 && "target lowering of complex return not supported");
     auto resTy = std::get<mlir::Type>(m[0]);
-    auto attr = std::get<CodeGenSpecifics::Attributes>(m[0]);
+    auto attr = std::get<fir::CodeGenSpecifics::Attributes>(m[0]);
     auto loc = mlir::UnknownLoc::get(resTy.getContext());
     if (attr.isSRet()) {
-      assert(isa_ref_type(resTy));
+      assert(fir::isa_ref_type(resTy) && "must be a memory reference type");
       mlir::Value stack =
-          rewriter->create<fir::AllocaOp>(loc, dyn_cast_ptrEleTy(resTy));
+          rewriter->create<fir::AllocaOp>(loc, fir::dyn_cast_ptrEleTy(resTy));
       newInTys.push_back(resTy);
       newOpers.push_back(stack);
       return [=](mlir::Operation *) -> mlir::Value {
-        auto memTy = ReferenceType::get(ty);
-        auto cast = rewriter->create<ConvertOp>(loc, memTy, stack);
+        auto memTy = fir::ReferenceType::get(ty);
+        auto cast = rewriter->create<fir::ConvertOp>(loc, memTy, stack);
         return rewriter->create<fir::LoadOp>(loc, cast);
       };
     }
     newResTys.push_back(resTy);
     return [=](mlir::Operation *call) -> mlir::Value {
       auto mem = rewriter->create<fir::AllocaOp>(loc, resTy);
       rewriter->create<fir::StoreOp>(loc, call->getResult(0), mem);
-      auto memTy = ReferenceType::get(ty);
-      auto cast = rewriter->create<ConvertOp>(loc, memTy, mem);
+      auto memTy = fir::ReferenceType::get(ty);
+      auto cast = rewriter->create<fir::ConvertOp>(loc, memTy, mem);
       return rewriter->create<fir::LoadOp>(loc, cast);
     };
   }
 
   template <typename A, typename B, typename C>
   void rewriteCallComplexInputType(A ty, mlir::Value oper, B &newInTys,
                                    C &newOpers) {
     auto m = specifics->complexArgumentType(ty.getElementType());
     auto *ctx = ty.getContext();
     auto loc = mlir::UnknownLoc::get(ctx);
     if (m.size() == 1) {
       // COMPLEX is a single aggregate
       auto resTy = std::get<mlir::Type>(m[0]);
-      auto attr = std::get<CodeGenSpecifics::Attributes>(m[0]);
-      auto oldRefTy = ReferenceType::get(ty);
+      auto attr = std::get<fir::CodeGenSpecifics::Attributes>(m[0]);
+      auto oldRefTy = fir::ReferenceType::get(ty);
       if (attr.isByVal()) {
         auto mem = rewriter->create<fir::AllocaOp>(loc, ty);
         rewriter->create<fir::StoreOp>(loc, oper, mem);
-        newOpers.push_back(rewriter->create<ConvertOp>(loc, resTy, mem));
+        newOpers.push_back(rewriter->create<fir::ConvertOp>(loc, resTy, mem));
       } else {
         auto mem = rewriter->create<fir::AllocaOp>(loc, resTy);
-        auto cast = rewriter->create<ConvertOp>(loc, oldRefTy, mem);
+        auto cast = rewriter->create<fir::ConvertOp>(loc, oldRefTy, mem);
         rewriter->create<fir::StoreOp>(loc, oper, cast);
         newOpers.push_back(rewriter->create<fir::LoadOp>(loc, mem));
       }
       newInTys.push_back(resTy);
     } else {
       assert(m.size() == 2);
       // COMPLEX is split into 2 separate arguments
       auto iTy = rewriter->getIntegerType(32);
       for (auto e : llvm::enumerate(m)) {
         auto &tup = e.value();
         auto ty = std::get<mlir::Type>(tup);
         auto index = e.index();
         auto idx = rewriter->getIntegerAttr(iTy, index);
-        auto val = rewriter->create<ExtractValueOp>(
+        auto val = rewriter->create<fir::ExtractValueOp>(
             loc, ty, oper, rewriter->getArrayAttr(idx));
         newInTys.push_back(ty);
         newOpers.push_back(val);
       }
     }
   }
 
   // Convert fir.call and fir.dispatch Ops.
void convertCallOp(A callOp) {
     llvm::SmallVector<mlir::Value> trailingOpers;
     for (auto e : llvm::enumerate(
              llvm::zip(fnTy.getInputs().drop_front(dropFront),
                        callOp.getOperands().drop_front(dropFront)))) {
       mlir::Type ty = std::get<0>(e.value());
       mlir::Value oper = std::get<1>(e.value());
       unsigned index = e.index();
       llvm::TypeSwitch<mlir::Type>(ty)
-          .template Case<BoxCharType>([&](BoxCharType boxTy) {
+          .template Case<fir::BoxCharType>([&](fir::BoxCharType boxTy) {
             bool sret;
             if constexpr (std::is_same_v<std::decay_t<A>, fir::CallOp>) {
               sret = callOp.getCallee() &&
                      functionArgIsSRet(
                          index, getModule().lookupSymbol<mlir::func::FuncOp>(
                                     *callOp.getCallee()));
             } else {
               // TODO: dispatch case; how do we put arguments on a call?
               // We cannot put both an sret and the dispatch object first.
               sret = false;
               TODO(loc, "dispatch + sret not supported yet");
             }
             auto m = specifics->boxcharArgumentType(boxTy.getEleTy(), sret);
-            auto unbox =
-                rewriter->create<UnboxCharOp>(loc, std::get<mlir::Type>(m[0]),
-                                              std::get<mlir::Type>(m[1]), oper);
+            auto unbox = rewriter->create<fir::UnboxCharOp>(
+                loc, std::get<mlir::Type>(m[0]), std::get<mlir::Type>(m[1]),
+                oper);
             // unboxed CHARACTER arguments
             for (auto e : llvm::enumerate(m)) {
               unsigned idx = e.index();
-              auto attr = std::get<CodeGenSpecifics::Attributes>(e.value());
+              auto attr =
+                  std::get<fir::CodeGenSpecifics::Attributes>(e.value());
               auto argTy = std::get<mlir::Type>(e.value());
               if (attr.isAppend()) {
                 trailingInTys.push_back(argTy);
                 trailingOpers.push_back(unbox.getResult(idx));
               } else {
                 newInTys.push_back(argTy);
                 newOpers.push_back(unbox.getResult(idx));
               }
             }
           })
           .template Case<fir::ComplexType>([&](fir::ComplexType cmplx) {
             rewriteCallComplexInputType(cmplx, oper, newInTys, newOpers);
           })
           .template Case<mlir::ComplexType>([&](mlir::ComplexType cmplx) {
             rewriteCallComplexInputType(cmplx, oper, newInTys, newOpers);
           })
           .template Case<mlir::TupleType>([&](mlir::TupleType tuple) {
-            if (isCharacterProcedureTuple(tuple)) {
+            if (fir::isCharacterProcedureTuple(tuple)) {
               mlir::ModuleOp module = getModule();
               if constexpr (std::is_same_v<std::decay_t<A>, fir::CallOp>) {
                 if (callOp.getCallee()) {
                   llvm::StringRef charProcAttr =
-                      getCharacterProcedureDummyAttrName();
+                      fir::getCharacterProcedureDummyAttrName();
                   // The charProcAttr attribute is only used as a safety to
                   // confirm that this is a dummy procedure and should be split.
                   // It cannot be used to match because attributes are not
                   // available in case of indirect calls.
                   auto funcOp = module.lookupSymbol<mlir::func::FuncOp>(
                       *callOp.getCallee());
                   if (funcOp &&
                       !funcOp.template getArgAttrOfType<mlir::UnitAttr>(
                           index, charProcAttr))
                     mlir::emitError(loc, "tuple argument will be split even "
                                          "though it does not have the `" +
                                              charProcAttr + "` attribute");
                 }
               }
               mlir::Type funcPointerType = tuple.getType(0);
               mlir::Type lenType = tuple.getType(1);
-              FirOpBuilder builder(*rewriter, getKindMapping(module));
+              fir::FirOpBuilder builder(*rewriter, fir::getKindMapping(module));
               auto [funcPointer, len] =
-                  factory::extractCharacterProcedureTuple(builder, loc, oper);
+                  fir::factory::extractCharacterProcedureTuple(builder, loc,
+                                                               oper);
               newInTys.push_back(funcPointerType);
               newOpers.push_back(funcPointer);
               trailingInTys.push_back(lenType);
               trailingOpers.push_back(len);
             } else {
               newInTys.push_back(tuple);
               newOpers.push_back(oper);
             }
public:
   // Result type fixup for fir::ComplexType and mlir::ComplexType
   template <typename A, typename B>
   void lowerComplexSignatureRes(A cmplx, B &newResTys, B &newInTys) {
     if (noComplexConversion) {
       newResTys.push_back(cmplx);
     } else {
       for (auto &tup : specifics->complexReturnType(cmplx.getElementType())) {
         auto argTy = std::get<mlir::Type>(tup);
-        if (std::get<CodeGenSpecifics::Attributes>(tup).isSRet())
+        if (std::get<fir::CodeGenSpecifics::Attributes>(tup).isSRet())
           newInTys.push_back(argTy);
         else
           newResTys.push_back(argTy);
       }
     }
   }
 
   // Argument type fixup for fir::ComplexType and mlir::ComplexType
   template <typename A, typename B>
   void lowerComplexSignatureArg(A cmplx, B &newInTys) {
     if (noComplexConversion)
       newInTys.push_back(cmplx);
     else
       for (auto &tup : specifics->complexArgumentType(cmplx.getElementType()))
         newInTys.push_back(std::get<mlir::Type>(tup));
   }
 
   /// Taking the address of a function. Modify the signature as needed.
-  void convertAddrOp(AddrOfOp addrOp) {
+  void convertAddrOp(fir::AddrOfOp addrOp) {
     rewriter->setInsertionPoint(addrOp);
     auto addrTy = addrOp.getType().cast<mlir::FunctionType>();
     llvm::SmallVector<mlir::Type> newResTys;
     llvm::SmallVector<mlir::Type> newInTys;
     for (mlir::Type ty : addrTy.getResults()) {
       llvm::TypeSwitch<mlir::Type>(ty)
           .Case<fir::ComplexType>([&](fir::ComplexType ty) {
             lowerComplexSignatureRes(ty, newResTys, newInTys);
           })
           .Case<mlir::ComplexType>([&](mlir::ComplexType ty) {
             lowerComplexSignatureRes(ty, newResTys, newInTys);
           })
           .Default([&](mlir::Type ty) { newResTys.push_back(ty); });
     }
     llvm::SmallVector<mlir::Type> trailingInTys;
     for (mlir::Type ty : addrTy.getInputs()) {
       llvm::TypeSwitch<mlir::Type>(ty)
-          .Case<BoxCharType>([&](BoxCharType box) {
+          .Case<fir::BoxCharType>([&](auto box) {
             if (noCharacterConversion) {
               newInTys.push_back(box);
             } else {
               for (auto &tup : specifics->boxcharArgumentType(box.getEleTy())) {
-                auto attr = std::get<CodeGenSpecifics::Attributes>(tup);
+                auto attr = std::get<fir::CodeGenSpecifics::Attributes>(tup);
                 auto argTy = std::get<mlir::Type>(tup);
                 llvm::SmallVector<mlir::Type> &vec =
                     attr.isAppend() ? trailingInTys : newInTys;
                 vec.push_back(argTy);
               }
             }
           })
           .Case<fir::ComplexType>([&](fir::ComplexType ty) {
             lowerComplexSignatureArg(ty, newInTys);
           })
           .Case<mlir::ComplexType>([&](mlir::ComplexType ty) {
             lowerComplexSignatureArg(ty, newInTys);
           })
           .Case<mlir::TupleType>([&](mlir::TupleType tuple) {
-            if (isCharacterProcedureTuple(tuple)) {
+            if (fir::isCharacterProcedureTuple(tuple)) {
               newInTys.push_back(tuple.getType(0));
               trailingInTys.push_back(tuple.getType(1));
             } else {
               newInTys.push_back(ty);
             }
           })
           .Default([&](mlir::Type ty) { newInTys.push_back(ty); });
     }
     // append trailing input types
     newInTys.insert(newInTys.end(), trailingInTys.begin(), trailingInTys.end());
     // replace this op with a new one with the updated signature
     auto newTy = rewriter->getFunctionType(newInTys, newResTys);
-    auto newOp =
-        rewriter->create<AddrOfOp>(addrOp.getLoc(), newTy, addrOp.getSymbol());
+    auto newOp = rewriter->create<fir::AddrOfOp>(addrOp.getLoc(), newTy,
+                                                 addrOp.getSymbol());
     replaceOp(addrOp, newOp.getResult());
   }
 
   /// Convert the type signatures on all the functions present in the module.
   /// As the type signature is being changed, this must also update the
   /// function itself to use any new arguments, etc.
   mlir::LogicalResult convertTypes(mlir::ModuleOp mod) {
     for (auto fn : mod.getOps<mlir::func::FuncOp>())
       convertSignature(fn);
     return mlir::success();
   }
 
   /// If the signature does not need any special target-specific converions,
   /// then it is considered portable for any target, and this function will
   /// return `true`. Otherwise, the signature is not portable and `false` is
   /// returned.
   bool hasPortableSignature(mlir::Type signature) {
     assert(signature.isa<mlir::FunctionType>());
     auto func = signature.dyn_cast<mlir::FunctionType>();
     for (auto ty : func.getResults())
-      if ((ty.isa<BoxCharType>() && !noCharacterConversion) ||
-          (isa_complex(ty) && !noComplexConversion)) {
+      if ((ty.isa<fir::BoxCharType>() && !noCharacterConversion) ||
+          (fir::isa_complex(ty) && !noComplexConversion)) {
         LLVM_DEBUG(llvm::dbgs() << "rewrite " << signature << " for target\n");
         return false;
       }
     for (auto ty : func.getInputs())
-      if (((ty.isa<BoxCharType>() || isCharacterProcedureTuple(ty)) &&
+      if (((ty.isa<fir::BoxCharType>() || fir::isCharacterProcedureTuple(ty)) &&
            !noCharacterConversion) ||
-          (isa_complex(ty) && !noComplexConversion)) {
+          (fir::isa_complex(ty) && !noComplexConversion)) {
         LLVM_DEBUG(llvm::dbgs() << "rewrite " << signature << " for target\n");
         return false;
       }
     return true;
   }
 
   /// Determine if the signature has host associations. The host association
   /// argument may need special target specific rewriting.
   static bool hasHostAssociations(mlir::func::FuncOp func) {
     std::size_t end = func.getFunctionType().getInputs().size();
     for (std::size_t i = 0; i < end; ++i)
-      if (func.getArgAttrOfType<mlir::UnitAttr>(i, getHostAssocAttrName()))
+      if (func.getArgAttrOfType<mlir::UnitAttr>(i, fir::getHostAssocAttrName()))
         return true;
     return false;
   }
 
   /// Rewrite the signatures and body of the `FuncOp`s in the module for
   /// the immediately subsequent target code gen.
   void convertSignature(mlir::func::FuncOp func) {
     auto funcTy = func.getFunctionType().cast<mlir::FunctionType>();
for (auto ty : funcTy.getResults())
           .Default([&](mlir::Type ty) { newResTys.push_back(ty); });
 
     // Convert arguments
     llvm::SmallVector<mlir::Type> trailingTys;
     for (auto e : llvm::enumerate(funcTy.getInputs())) {
       auto ty = e.value();
       unsigned index = e.index();
       llvm::TypeSwitch<mlir::Type>(ty)
-          .Case<BoxCharType>([&](BoxCharType boxTy) {
+          .Case<fir::BoxCharType>([&](fir::BoxCharType boxTy) {
             if (noCharacterConversion) {
               newInTys.push_back(boxTy);
             } else {
               // Convert a CHARACTER argument type. This can involve separating
               // the pointer and the LEN into two arguments and moving the LEN
               // argument to the end of the arg list.
               bool sret = functionArgIsSRet(index, func);
               for (auto e : llvm::enumerate(specifics->boxcharArgumentType(
                        boxTy.getEleTy(), sret))) {
                 auto &tup = e.value();
                 auto index = e.index();
-                auto attr = std::get<CodeGenSpecifics::Attributes>(tup);
+                auto attr = std::get<fir::CodeGenSpecifics::Attributes>(tup);
                 auto argTy = std::get<mlir::Type>(tup);
                 if (attr.isAppend()) {
                   trailingTys.push_back(argTy);
                 } else {
                   if (sret) {
                     fixups.emplace_back(FixupTy::Codes::CharPair,
                                         newInTys.size(), index);
                   } else {
for (auto e : llvm::enumerate(funcTy.getInputs())) {
           })
           .Case<mlir::ComplexType>([&](mlir::ComplexType cmplx) {
             if (noComplexConversion)
               newInTys.push_back(cmplx);
             else
               doComplexArg(func, cmplx, newInTys, fixups);
           })
           .Case<mlir::TupleType>([&](mlir::TupleType tuple) {
-            if (isCharacterProcedureTuple(tuple)) {
+            if (fir::isCharacterProcedureTuple(tuple)) {
               fixups.emplace_back(FixupTy::Codes::TrailingCharProc,
                                   newInTys.size(), trailingTys.size());
               newInTys.push_back(tuple.getType(0));
               trailingTys.push_back(tuple.getType(1));
             } else {
               newInTys.push_back(ty);
             }
           })
           .Default([&](mlir::Type ty) { newInTys.push_back(ty); });
       if (func.getArgAttrOfType<mlir::UnitAttr>(index,
-                                                getHostAssocAttrName())) {
+                                                fir::getHostAssocAttrName())) {
         func.setArgAttr(index, "llvm.nest", rewriter->getUnitAttr());
       }
     }
 
     if (!func.empty()) {
       // If the function has a body, then apply the fixups to the arguments and
       // return ops as required. These fixups are done in place.
       auto loc = func.getLoc();
       const auto fixupSize = fixups.size();
       const auto oldArgTys = func.getFunctionType().getInputs();
       int offset = 0;
       for (std::remove_const_t<decltype(fixupSize)> i = 0; i < fixupSize; ++i) {
         const auto &fixup = fixups[i];
         switch (fixup.code) {
         case FixupTy::Codes::ArgumentAsLoad: {
           // Argument was pass-by-value, but is now pass-by-reference and
           // possibly with a different element type.
           auto newArg = func.front().insertArgument(fixup.index,
                                                     newInTys[fixup.index], loc);
           rewriter->setInsertionPointToStart(&func.front());
-          auto oldArgTy = ReferenceType::get(oldArgTys[fixup.index - offset]);
-          auto cast = rewriter->create<ConvertOp>(loc, oldArgTy, newArg);
+          auto oldArgTy =
+              fir::ReferenceType::get(oldArgTys[fixup.index - offset]);
+          auto cast = rewriter->create<fir::ConvertOp>(loc, oldArgTy, newArg);
           auto load = rewriter->create<fir::LoadOp>(loc, cast);
           func.getArgument(fixup.index + 1).replaceAllUsesWith(load);
           func.front().eraseArgument(fixup.index + 1);
         } break;
         case FixupTy::Codes::ArgumentType: {
           // Argument is pass-by-value, but its type has likely been modified to
           // suit the target ABI convention.
           auto newArg = func.front().insertArgument(fixup.index,
                                                     newInTys[fixup.index], loc);
           rewriter->setInsertionPointToStart(&func.front());
           auto mem =
               rewriter->create<fir::AllocaOp>(loc, newInTys[fixup.index]);
           rewriter->create<fir::StoreOp>(loc, newArg, mem);
-          auto oldArgTy = ReferenceType::get(oldArgTys[fixup.index - offset]);
-          auto cast = rewriter->create<ConvertOp>(loc, oldArgTy, mem);
+          auto oldArgTy =
+              fir::ReferenceType::get(oldArgTys[fixup.index - offset]);
+          auto cast = rewriter->create<fir::ConvertOp>(loc, oldArgTy, mem);
           mlir::Value load = rewriter->create<fir::LoadOp>(loc, cast);
           func.getArgument(fixup.index + 1).replaceAllUsesWith(load);
           func.front().eraseArgument(fixup.index + 1);
           LLVM_DEBUG(llvm::dbgs()
                      << "old argument: " << oldArgTy.getEleTy()
                      << ", repl: " << load << ", new argument: "
                      << func.getArgument(fixup.index).getType() << '\n');
         } break;
         case FixupTy::Codes::CharPair: {
           // The FIR boxchar argument has been split into a pair of distinct
           // arguments that are in juxtaposition to each other.
           auto newArg = func.front().insertArgument(fixup.index,
                                                     newInTys[fixup.index], loc);
           if (fixup.second == 1) {
             rewriter->setInsertionPointToStart(&func.front());
             auto boxTy = oldArgTys[fixup.index - offset - fixup.second];
-            auto box = rewriter->create<EmboxCharOp>(
+            auto box = rewriter->create<fir::EmboxCharOp>(
                 loc, boxTy, func.front().getArgument(fixup.index - 1), newArg);
             func.getArgument(fixup.index + 1).replaceAllUsesWith(box);
             func.front().eraseArgument(fixup.index + 1);
             offset++;
           }
         } break;
         case FixupTy::Codes::ReturnAsStore: {
           // The value being returned is now being returned in memory (callee
           // stack space) through a hidden reference argument.
           auto newArg = func.front().insertArgument(fixup.index,
                                                     newInTys[fixup.index], loc);
           offset++;
           func.walk([&](mlir::func::ReturnOp ret) {
             rewriter->setInsertionPoint(ret);
             auto oldOper = ret.getOperand(0);
-            auto oldOperTy = ReferenceType::get(oldOper.getType());
-            auto cast = rewriter->create<ConvertOp>(loc, oldOperTy, newArg);
+            auto oldOperTy = fir::ReferenceType::get(oldOper.getType());
+            auto cast =
+                rewriter->create<fir::ConvertOp>(loc, oldOperTy, newArg);
             rewriter->create<fir::StoreOp>(loc, oldOper, cast);
             rewriter->create<mlir::func::ReturnOp>(loc);
             ret.erase();
           });
         } break;
         case FixupTy::Codes::ReturnType: {
           // The function is still returning a value, but its type has likely
           // changed to suit the target ABI convention.
           func.walk([&](mlir::func::ReturnOp ret) {
             rewriter->setInsertionPoint(ret);
             auto oldOper = ret.getOperand(0);
-            auto oldOperTy = ReferenceType::get(oldOper.getType());
+            auto oldOperTy = fir::ReferenceType::get(oldOper.getType());
             auto mem =
                 rewriter->create<fir::AllocaOp>(loc, newResTys[fixup.index]);
-            auto cast = rewriter->create<ConvertOp>(loc, oldOperTy, mem);
+            auto cast = rewriter->create<fir::ConvertOp>(loc, oldOperTy, mem);
             rewriter->create<fir::StoreOp>(loc, oldOper, cast);
             mlir::Value load = rewriter->create<fir::LoadOp>(loc, mem);
             rewriter->create<mlir::func::ReturnOp>(loc, load);
             ret.erase();
           });
         } break;
         case FixupTy::Codes::Split: {
           // The FIR argument has been split into a pair of distinct arguments
           // that are in juxtaposition to each other. (For COMPLEX value.)
           auto newArg = func.front().insertArgument(fixup.index,
                                                     newInTys[fixup.index], loc);
           if (fixup.second == 1) {
             rewriter->setInsertionPointToStart(&func.front());
             auto cplxTy = oldArgTys[fixup.index - offset - fixup.second];
-            auto undef = rewriter->create<UndefOp>(loc, cplxTy);
+            auto undef = rewriter->create<fir::UndefOp>(loc, cplxTy);
             auto iTy = rewriter->getIntegerType(32);
             auto zero = rewriter->getIntegerAttr(iTy, 0);
             auto one = rewriter->getIntegerAttr(iTy, 1);
-            auto cplx1 = rewriter->create<InsertValueOp>(
+            auto cplx1 = rewriter->create<fir::InsertValueOp>(
                 loc, cplxTy, undef, func.front().getArgument(fixup.index - 1),
                 rewriter->getArrayAttr(zero));
-            auto cplx = rewriter->create<InsertValueOp>(
+            auto cplx = rewriter->create<fir::InsertValueOp>(
                 loc, cplxTy, cplx1, newArg, rewriter->getArrayAttr(one));
             func.getArgument(fixup.index + 1).replaceAllUsesWith(cplx);
             func.front().eraseArgument(fixup.index + 1);
             offset++;
           }
         } break;
         case FixupTy::Codes::Trailing: {
           // The FIR argument has been split into a pair of distinct arguments.
           // The first part of the pair appears in the original argument
           // position. The second part of the pair is appended after all the
           // original arguments. (Boxchar arguments.)
           auto newBufArg = func.front().insertArgument(
               fixup.index, newInTys[fixup.index], loc);
           auto newLenArg =
               func.front().addArgument(trailingTys[fixup.second], loc);
           auto boxTy = oldArgTys[fixup.index - offset];
           rewriter->setInsertionPointToStart(&func.front());
-          auto box =
-              rewriter->create<EmboxCharOp>(loc, boxTy, newBufArg, newLenArg);
+          auto box = rewriter->create<fir::EmboxCharOp>(loc, boxTy, newBufArg,
+                                                        newLenArg);
           func.getArgument(fixup.index + 1).replaceAllUsesWith(box);
           func.front().eraseArgument(fixup.index + 1);
         } break;
         case FixupTy::Codes::TrailingCharProc: {
           // The FIR character procedure argument tuple must be split into a
           // pair of distinct arguments. The first part of the pair appears in
           // the original argument position. The second part of the pair is
           // appended after all the original arguments.
           auto newProcPointerArg = func.front().insertArgument(
               fixup.index, newInTys[fixup.index], loc);
           auto newLenArg =
               func.front().addArgument(trailingTys[fixup.second], loc);
           auto tupleType = oldArgTys[fixup.index - offset];
           rewriter->setInsertionPointToStart(&func.front());
-          FirOpBuilder builder(*rewriter, getKindMapping(getModule()));
-          auto tuple = factory::createCharacterProcedureTuple(
+          fir::FirOpBuilder builder(*rewriter,
+                                    fir::getKindMapping(getModule()));
+          auto tuple = fir::factory::createCharacterProcedureTuple(
               builder, loc, tupleType, newProcPointerArg, newLenArg);
           func.getArgument(fixup.index + 1).replaceAllUsesWith(tuple);
           func.front().eraseArgument(fixup.index + 1);
         } break;
         }
       }
     }
 
void doComplexReturn(mlir::func::FuncOp func, A cmplx, B &newResTys,
                        B &newInTys, C &fixups) {
     if (noComplexConversion) {
       newResTys.push_back(cmplx);
       return;
     }
     auto m = specifics->complexReturnType(cmplx.getElementType());
     assert(m.size() == 1);
     auto &tup = m[0];
-    auto attr = std::get<CodeGenSpecifics::Attributes>(tup);
+    auto attr = std::get<fir::CodeGenSpecifics::Attributes>(tup);
     auto argTy = std::get<mlir::Type>(tup);
     if (attr.isSRet()) {
       unsigned argNo = newInTys.size();
       fixups.emplace_back(
           FixupTy::Codes::ReturnAsStore, argNo, [=](mlir::func::FuncOp func) {
             func.setArgAttr(argNo, "llvm.sret", rewriter->getUnitAttr());
           });
       newInTys.push_back(argTy);
if (noComplexConversion) {
       return;
     }
     auto m = specifics->complexArgumentType(cmplx.getElementType());
     const auto fixupCode =
         m.size() > 1 ? FixupTy::Codes::Split : FixupTy::Codes::ArgumentType;
     for (auto e : llvm::enumerate(m)) {
       auto &tup = e.value();
       auto index = e.index();
-      auto attr = std::get<CodeGenSpecifics::Attributes>(tup);
+      auto attr = std::get<fir::CodeGenSpecifics::Attributes>(tup);
       auto argTy = std::get<mlir::Type>(tup);
       auto argNo = newInTys.size();
       if (attr.isByVal()) {
         if (auto align = attr.getAlignment())
           fixups.emplace_back(
               FixupTy::Codes::ArgumentAsLoad, argNo,
               [=](mlir::func::FuncOp func) {
                 func.setArgAttr(argNo, "llvm.byval", rewriter->getUnitAttr());

 private:
   // Replace `op` and remove it.
   void replaceOp(mlir::Operation *op, mlir::ValueRange newValues) {
     op->replaceAllUsesWith(newValues);
     op->dropAllReferences();
     op->erase();
   }
 
-  inline void setMembers(CodeGenSpecifics *s, mlir::OpBuilder *r) {
+  inline void setMembers(fir::CodeGenSpecifics *s, mlir::OpBuilder *r) {
     specifics = s;
     rewriter = r;
   }
 
   inline void clearMembers() { setMembers(nullptr, nullptr); }
 
-  CodeGenSpecifics *specifics{};
-  mlir::OpBuilder *rewriter;
+  fir::CodeGenSpecifics *specifics = nullptr;
+  mlir::OpBuilder *rewriter = nullptr;
 }; // namespace
 } // namespace
 
 std::unique_ptr<mlir::OperationPass<mlir::ModuleOp>>
-fir::createFirTargetRewritePass(const TargetRewriteOptions &options) {
+fir::createFirTargetRewritePass(const fir::TargetRewriteOptions &options) {
   return std::make_unique<TargetRewrite>(options);
 }

flang/lib/Optimizer/CodeGen/TypeConverter.h

addConversion([&](fir::LogicalType boolTy) {
           &getContext(), kindMapping.getLogicalBitsize(boolTy.getFKind()));
     });
     addConversion([&](fir::LLVMPointerType pointer) {
       return convertPointerLike(pointer);
     });
     addConversion(
         [&](fir::PointerType pointer) { return convertPointerLike(pointer); });
     addConversion([&](fir::RecordType derived,
-                      SmallVectorImpl<mlir::Type> &results,
-                      ArrayRef<mlir::Type> callStack) {
+                      llvm::SmallVectorImpl<mlir::Type> &results,
+                      llvm::ArrayRef<mlir::Type> callStack) {
       return convertRecordType(derived, results, callStack);
     });
     addConversion(
         [&](fir::RealType real) { return convertRealType(real.getFKind()); });
     addConversion(
         [&](fir::ReferenceType ref) { return convertPointerLike(ref); });
     addConversion([&](fir::SequenceType sequence) {
       return convertSequenceType(sequence);
public:
   // i32 is used here because LLVM wants i32 constants when indexing into struct
   // types. Indexing into other aggregate types is more flexible.
   mlir::Type offsetType() { return mlir::IntegerType::get(&getContext(), 32); }
 
   // i64 can be used to index into aggregates like arrays
   mlir::Type indexType() { return mlir::IntegerType::get(&getContext(), 64); }
 
   // fir.type<name(p : TY'...){f : TY...}>  -->  llvm<"%name = { ty... }">
-  llvm::Optional<LogicalResult>
+  llvm::Optional<mlir::LogicalResult>
   convertRecordType(fir::RecordType derived,
-                    SmallVectorImpl<mlir::Type> &results,
-                    ArrayRef<mlir::Type> callStack) {
+                    llvm::SmallVectorImpl<mlir::Type> &results,
+                    llvm::ArrayRef<mlir::Type> callStack) {
     auto name = derived.getName();
     auto st = mlir::LLVM::LLVMStructType::getIdentified(&getContext(), name);
     if (llvm::count(callStack, derived) > 1) {
       results.push_back(st);
-      return success();
+      return mlir::success();
     }
     llvm::SmallVector<mlir::Type> members;
     for (auto mem : derived.getTypeList()) {
       // Prevent fir.box from degenerating to a pointer to a descriptor in the
       // context of a record type.
       if (auto box = mem.second.dyn_cast<fir::BoxType>())
         members.push_back(convertBoxTypeAsStruct(box));
       else
         members.push_back(convertType(mem.second).cast<mlir::Type>());
     }
     if (mlir::failed(st.setBody(members, /*isPacked=*/false)))
-      return failure();
+      return mlir::failure();
     results.push_back(st);
-    return success();
+    return mlir::success();
   }
 
   // Is an extended descriptor needed given the element type of a fir.box type ?
   // Extended descriptors are required for derived types.
   bool requiresExtendedDesc(mlir::Type boxElementType) {
     auto eleTy = fir::unwrapSequenceType(boxElementType);
     return eleTy.isa<fir::RecordType>();
   }

flang/test/Fir/addrof.fir

-// RUN: fir-opt %s | tco | FileCheck %s
+// RUN: tco %s | FileCheck %s
 
 // CHECK: @var_x = external global i32
 fir.global @var_x : !fir.int<4> {}
 
 // CHECK-LABEL: define i32* @getAddressOfX
 func @getAddressOfX() -> !fir.ref<!fir.int<4>> {
   %1 = fir.address_of(@var_x) : !fir.ref<!fir.int<4>>
   // CHECK: ret i32* @var_x
   return %1 : !fir.ref<!fir.int<4>>
 }

flang/test/Fir/embox.fir

-// RUN: fir-opt %s | tco | FileCheck %s
+// RUN: tco %s | FileCheck %s
 
 
 // CHECK-LABEL: define void @_QPtest_callee({ i32*, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }* %0)
 func @_QPtest_callee(%arg0: !fir.box<!fir.array<?xi32>>) {
   return
 }
 
 // CHECK-LABEL: define void @_QPtest_slice()

flang/test/Fir/rebox.fir

-// RUN: fir-opt %s | tco | FileCheck %s
+// RUN: tco %s | FileCheck %s
 
 // Test applying slice on fir.box
 //   subroutine foo(x)
 //     real :: x(3:, 4:)
 //     call bar(x(5, 6:80:3))
 //   end subroutine
 
 func private @bar1(!fir.box<!fir.array<?xf32>>)