[flang][fir] Remove references to code to be removed.

[schweitz]

Summary

This removes references to archaic FIR artifacts that will be removed in subsequent commits.

[mehdi_amini]

flang/lib/Lower/CharacterExpr.cpp

358

I'm confused, isn't this code gonna crash now? iterWhile was referring to an op created but not you just have a null value.

[schweitz]

flang/lib/Lower/CharacterExpr.cpp

358

This is a prelude to D95399. They are mutually dependent patches.

(1) Don't want to expand the size of D95399.
(2) Want to make D95399 a buildable chunk on its own.

[mehdi_amini]

flang/lib/Lower/CharacterExpr.cpp

358

OK, but it is hard to make sense of a patch like this one which makes the code fundamentally wrong.
Also this patch does not even build right now according to the premerge testing:

/mnt/disks/ssd0/agent/llvm-project/flang/lib/Lower/ConvertType.cpp:167:12: error: no member named 'ComplexType' in namespace 'fir'; did you mean 'mlir::ComplexType'?
    return fir::ComplexType::get(context, KIND);
           ^~~~~~~~~~~~~~~~

flang/lib/Lower/CharacterExpr.cpp

mlir::Value Fortran::lower::CharacterExprHelper::createLenTrim(
   auto len = builder.createConvert(loc, indexType, str.getLen());
   auto one = builder.createIntegerConstant(loc, indexType, 1);
   auto minusOne = builder.createIntegerConstant(loc, indexType, -1);
   auto zero = builder.createIntegerConstant(loc, indexType, 0);
   auto trueVal = builder.createIntegerConstant(loc, builder.getI1Type(), 1);
   auto blank = createBlankConstantCode(getCharacterType(str));
   mlir::Value lastChar = builder.create<mlir::SubIOp>(loc, len, one);
 
-  auto iterWhile = builder.create<fir::IterWhileOp>(
-      loc, lastChar, zero, minusOne, trueVal, lastChar);
+  fir::IterWhileOp iterWhile;
   auto insPt = builder.saveInsertionPoint();
   builder.setInsertionPointToStart(iterWhile.getBody());
   auto index = iterWhile.getInductionVar();
   // Look for first non-blank from the right of the character.
   auto c = createLoadCharAt(str, index);
   c = builder.createConvert(loc, blank.getType(), c);
   auto isBlank =
       builder.create<mlir::CmpIOp>(loc, mlir::CmpIPredicate::eq, blank, c);
   llvm::SmallVector<mlir::Value, 2> results = {isBlank, index};
   builder.create<fir::ResultOp>(loc, results);
   builder.restoreInsertionPoint(insPt);

flang/lib/Lower/ComplexExpr.cpp

 #include "flang/Lower/ConvertType.h"
 
 //===----------------------------------------------------------------------===//
 // ComplexExprHelper implementation
 //===----------------------------------------------------------------------===//
 
 mlir::Type
 Fortran::lower::ComplexExprHelper::getComplexPartType(mlir::Type complexType) {
-  return Fortran::lower::convertReal(
-      builder.getContext(), complexType.cast<fir::CplxType>().getFKind());
+  return {};
 }
 
 mlir::Type
 Fortran::lower::ComplexExprHelper::getComplexPartType(mlir::Value cplx) {
   return getComplexPartType(cplx.getType());
 }
 
 mlir::Value Fortran::lower::ComplexExprHelper::createComplex(fir::KindTy kind,
                                                              mlir::Value real,
                                                              mlir::Value imag) {
-  auto complexTy = fir::CplxType::get(builder.getContext(), kind);
-  mlir::Value und = builder.create<fir::UndefOp>(loc, complexTy);
-  return insert<Part::Imag>(insert<Part::Real>(und, real), imag);
+  return {};
 }
 
 mlir::Value Fortran::lower::ComplexExprHelper::createComplex(mlir::Type cplxTy,
                                                              mlir::Value real,
                                                              mlir::Value imag) {
   mlir::Value und = builder.create<fir::UndefOp>(loc, cplxTy);
   return insert<Part::Imag>(insert<Part::Real>(und, real), imag);
 }

flang/lib/Lower/ConvertType.cpp

if (Fortran::evaluate::IsValidKindOfIntrinsicType(
     return fir::LogicalType::get(context, KIND);
   return {};
 }
 
 template <>
 mlir::Type
 genFIRType<Fortran::common::TypeCategory::Character>(mlir::MLIRContext *context,
                                                      int KIND) {
-  if (Fortran::evaluate::IsValidKindOfIntrinsicType(
-          Fortran::common::TypeCategory::Character, KIND))
-    return fir::CharacterType::get(context, KIND);
   return {};
 }
 
 template <>
 mlir::Type
 genFIRType<Fortran::common::TypeCategory::Complex>(mlir::MLIRContext *context,
                                                    int KIND) {
-  if (Fortran::evaluate::IsValidKindOfIntrinsicType(
-          Fortran::common::TypeCategory::Complex, KIND))
-    return fir::CplxType::get(context, KIND);
   return {};
 }
 
 namespace {
 
 /// Discover the type of an Fortran::evaluate::Expr<T> and convert it to an
 /// mlir::Type. The type returned may be an MLIR standard or FIR type.
 class TypeBuilder {

flang/lib/Lower/DoLoopHelper.cpp

 
 //===----------------------------------------------------------------------===//
 // DoLoopHelper implementation
 //===----------------------------------------------------------------------===//
 
 void Fortran::lower::DoLoopHelper::createLoop(
     mlir::Value lb, mlir::Value ub, mlir::Value step,
     const BodyGenerator &bodyGenerator) {
-  auto lbi = builder.convertToIndexType(loc, lb);
-  auto ubi = builder.convertToIndexType(loc, ub);
-  assert(step && "step must be an actual Value");
-  auto inc = builder.convertToIndexType(loc, step);
-  auto loop = builder.create<fir::LoopOp>(loc, lbi, ubi, inc);
-  auto insertPt = builder.saveInsertionPoint();
-  builder.setInsertionPointToStart(loop.getBody());
-  auto index = loop.getInductionVar();
-  bodyGenerator(builder, index);
-  builder.restoreInsertionPoint(insertPt);
 }
 
 void Fortran::lower::DoLoopHelper::createLoop(
     mlir::Value lb, mlir::Value ub, const BodyGenerator &bodyGenerator) {
   createLoop(lb, ub,
              builder.createIntegerConstant(loc, builder.getIndexType(), 1),
              bodyGenerator);
 }

flang/lib/Lower/FIRBuilder.cpp

mlir::Value Fortran::lower::FirOpBuilder::convertWithSemantics(
   auto fromTy = val.getType();
   if (fromTy == toTy)
     return val;
   // FIXME: add a fir::is_integer() test
   ComplexExprHelper helper{*this, loc};
   if ((fir::isa_real(fromTy) || fromTy.isSignlessInteger()) &&
       fir::isa_complex(toTy)) {
     // imaginary part is zero
-    auto eleTy = helper.getComplexPartType(toTy);
-    auto cast = createConvert(loc, eleTy, val);
-    llvm::APFloat zero{
-        kindMap.getFloatSemantics(toTy.cast<fir::CplxType>().getFKind()), 0};
-    auto imag = createRealConstant(loc, eleTy, zero);
-    return helper.createComplex(toTy, cast, imag);
   }
   // FIXME: add a fir::is_integer() test
   if (fir::isa_complex(fromTy) &&
       (toTy.isSignlessInteger() || fir::isa_real(toTy))) {
     // drop the imaginary part
     auto rp = helper.extractComplexPart(val, /*isImagPart=*/false);
     return createConvert(loc, toTy, rp);
   }

flang/lib/Lower/IO.cpp

static void makeNextConditionalOn(Fortran::lower::FirOpBuilder &builder,
                                   bool inIterWhileLoop = false) {
   if (!checkResult || !ok)
     // Either I/O calls do not need to be checked, or the next I/O call is the
     // first potentially fallable call.
     return;
   // A previous I/O call for a statement returned the bool `ok`.  If this call
   // is in a fir.iterate_while loop, the result must be propagated up to the
   // loop scope.  That is done in genIoLoop, but it is enabled here.
-  auto whereOp =
-      inIterWhileLoop
-          ? builder.create<fir::WhereOp>(loc, builder.getI1Type(), ok, true)
-          : builder.create<fir::WhereOp>(loc, ok, /*withOtherwise=*/false);
-  if (!insertPt.isSet())
-    insertPt = builder.saveInsertionPoint();
-  builder.setInsertionPointToStart(&whereOp.whereRegion().front());
 }
 
 template <typename D>
 static void genIoLoop(Fortran::lower::AbstractConverter &converter,
                       mlir::Value cookie, const D &ioImpliedDo,
                       bool checkResult, mlir::Value &ok, bool inIterWhileLoop);
 
 /// Get the OutputXyz routine to output a value of the given type.
 static mlir::FuncOp getOutputFunc(mlir::Location loc,
                                   Fortran::lower::FirOpBuilder &builder,
                                   mlir::Type type) {
   if (auto ty = type.dyn_cast<mlir::IntegerType>())
     return ty.getWidth() == 1
                ? getIORuntimeFunc<mkIOKey(OutputLogical)>(loc, builder)
                : getIORuntimeFunc<mkIOKey(OutputInteger64)>(loc, builder);
   if (auto ty = type.dyn_cast<mlir::FloatType>())
     return ty.getWidth() <= 32
                ? getIORuntimeFunc<mkIOKey(OutputReal32)>(loc, builder)
                : getIORuntimeFunc<mkIOKey(OutputReal64)>(loc, builder);
-  if (auto ty = type.dyn_cast<fir::CplxType>())
-    return ty.getFKind() <= 4
-               ? getIORuntimeFunc<mkIOKey(OutputComplex32)>(loc, builder)
-               : getIORuntimeFunc<mkIOKey(OutputComplex64)>(loc, builder);
   if (type.isa<fir::LogicalType>())
     return getIORuntimeFunc<mkIOKey(OutputLogical)>(loc, builder);
   if (type.isa<fir::BoxType>())
     return getIORuntimeFunc<mkIOKey(OutputDescriptor)>(loc, builder);
   if (Fortran::lower::CharacterExprHelper::isCharacter(type))
     return getIORuntimeFunc<mkIOKey(OutputAscii)>(loc, builder);
   // TODO: handle arrays
   mlir::emitError(loc, "output for entity type ") << type << " not implemented";
static mlir::FuncOp getInputFunc(mlir::Location loc,
   if (auto ty = type.dyn_cast<mlir::IntegerType>())
     return ty.getWidth() == 1
                ? getIORuntimeFunc<mkIOKey(InputLogical)>(loc, builder)
                : getIORuntimeFunc<mkIOKey(InputInteger)>(loc, builder);
   if (auto ty = type.dyn_cast<mlir::FloatType>())
     return ty.getWidth() <= 32
                ? getIORuntimeFunc<mkIOKey(InputReal32)>(loc, builder)
                : getIORuntimeFunc<mkIOKey(InputReal64)>(loc, builder);
-  if (auto ty = type.dyn_cast<fir::CplxType>())
-    return ty.getFKind() <= 4
-               ? getIORuntimeFunc<mkIOKey(InputReal32)>(loc, builder)
-               : getIORuntimeFunc<mkIOKey(InputReal64)>(loc, builder);
   if (type.isa<fir::LogicalType>())
     return getIORuntimeFunc<mkIOKey(InputLogical)>(loc, builder);
   if (type.isa<fir::BoxType>())
     return getIORuntimeFunc<mkIOKey(InputDescriptor)>(loc, builder);
   if (Fortran::lower::CharacterExprHelper::isCharacter(type))
     return getIORuntimeFunc<mkIOKey(InputAscii)>(loc, builder);
   // TODO: handle arrays
   mlir::emitError(loc, "input for entity type ") << type << " not implemented";
makeNextConditionalOn(builder, loc, insertPt, checkResult, ok,
                           inIterWhileLoop);
     auto itemAddr =
         converter.genExprAddr(Fortran::semantics::GetExpr(pVar), loc);
     auto itemType = itemAddr.getType().cast<fir::ReferenceType>().getEleTy();
     auto inputFunc = getInputFunc(loc, builder, itemType);
     auto argType = inputFunc.getType().getInput(1);
     auto originalItemAddr = itemAddr;
     mlir::Type complexPartType;
-    if (itemType.isa<fir::CplxType>())
-      complexPartType = builder.getRefType(
-          Fortran::lower::ComplexExprHelper{builder, loc}.getComplexPartType(
-              itemType));
     auto complexPartAddr = [&](int index) {
       return builder.create<fir::CoordinateOp>(
           loc, complexPartType, originalItemAddr,
           llvm::SmallVector<mlir::Value, 1>{builder.create<mlir::ConstantOp>(
               loc, builder.getI32IntegerAttr(index))});
     };
     if (complexPartType)
       itemAddr = complexPartAddr(0); // real part
if constexpr (std::is_same_v<D, Fortran::parser::InputImpliedDo>)
       genInputItemList(converter, cookie, itemList, insertPt, checkResult, ok,
                        true);
     else
       genOutputItemList(converter, cookie, itemList, insertPt, checkResult, ok,
                         true);
   };
   if (!checkResult) {
     // No I/O call result checks - the loop is a fir.do_loop op.
-    auto loopOp =
-        builder.create<fir::LoopOp>(loc, lowerValue, upperValue, stepValue);
-    builder.setInsertionPointToStart(loopOp.getBody());
-    auto lcv = builder.createConvert(loc, converter.genType(loopSym),
-                                     loopOp.getInductionVar());
-    builder.create<fir::StoreOp>(loc, lcv, loopVar);
-    insertPt = builder.saveInsertionPoint();
-    genItemList(ioImpliedDo, false);
-    builder.restoreInsertionPoint(parentInsertPt);
     return;
   }
   // Check I/O call results - the loop is a fir.iterate_while op.
   if (!ok)
     ok = builder.createIntegerConstant(loc, builder.getI1Type(), 1);
   fir::IterWhileOp iterWhileOp = builder.create<fir::IterWhileOp>(
       loc, lowerValue, upperValue, stepValue, ok);
   builder.setInsertionPointToStart(iterWhileOp.getBody());
   auto lcv = builder.createConvert(loc, converter.genType(loopSym),
                                    iterWhileOp.getInductionVar());
   builder.create<fir::StoreOp>(loc, lcv, loopVar);
   insertPt = builder.saveInsertionPoint();
   ok = iterWhileOp.getIterateVar();
   auto falseValue = builder.createIntegerConstant(loc, builder.getI1Type(), 0);
   genItemList(ioImpliedDo, true);
   // Unwind nested I/O call scopes, filling in true and false ResultOp's.
-  for (auto *op = builder.getBlock()->getParentOp(); isa<fir::WhereOp>(op);
-       op = op->getBlock()->getParentOp()) {
-    auto whereOp = dyn_cast<fir::WhereOp>(op);
-    auto *lastOp = &whereOp.whereRegion().front().back();
-    builder.setInsertionPointAfter(lastOp);
-    builder.create<fir::ResultOp>(loc, lastOp->getResult(0)); // runtime result
-    builder.setInsertionPointToStart(&whereOp.otherRegion().front());
-    builder.create<fir::ResultOp>(loc, falseValue); // known false result
-  }
   builder.restoreInsertionPoint(insertPt);
   builder.create<fir::ResultOp>(loc, builder.getBlock()->back().getResult(0));
   ok = iterWhileOp.getResult(0);
   builder.restoreInsertionPoint(parentInsertPt);
 }
 
 //===----------------------------------------------------------------------===//
 // Default argument generation.

 /// this information to lowering.
 static std::tuple<mlir::Value, mlir::Value, mlir::Value>
 lowerSourceTextAsStringLit(Fortran::lower::AbstractConverter &converter,
                            mlir::Location loc, llvm::StringRef text,
                            mlir::Type strTy, mlir::Type lenTy) {
   text = text.drop_front(text.find('('));
   text = text.take_front(text.rfind(')') + 1);
   auto &builder = converter.getFirOpBuilder();
-  auto lit = builder.createStringLit(
-      loc, /*FIXME*/ fir::CharacterType::get(builder.getContext(), 1), text);
+  mlir::Value lit;
   auto data =
       Fortran::lower::CharacterExprHelper{builder, loc}.materializeCharacter(
           lit);
   auto buff = builder.createConvert(loc, strTy, data.first);
   auto len = builder.createConvert(loc, lenTy, data.second);
   return {buff, len, mlir::Value{}};
 }
 

flang/lib/Lower/IntrinsicCall.cpp

private:
   static unsigned getFloatingPointWidth(mlir::Type t) {
     if (auto f{t.dyn_cast<mlir::FloatType>()})
       return f.getWidth();
     // FIXME: Get width another way for fir.real/complex
     // - use fir/KindMapping.h and llvm::Type
     // - or use evaluate/type.h
     if (auto r{t.dyn_cast<fir::RealType>()})
       return r.getFKind() * 4;
-    if (auto cplx{t.dyn_cast<fir::CplxType>()})
-      return cplx.getFKind() * 4;
     llvm_unreachable("not a floating-point type");
   }
 
   static Conversion conversionBetweenTypes(mlir::Type from, mlir::Type to) {
     if (from == to) {
       return Conversion::None;
     }
     if (auto fromIntTy{from.dyn_cast<mlir::IntegerType>()}) {
       if (auto toIntTy{to.dyn_cast<mlir::IntegerType>()}) {
         return fromIntTy.getWidth() > toIntTy.getWidth() ? Conversion::Narrow
                                                          : Conversion::Extend;
       }
     }
     if (fir::isa_real(from) && fir::isa_real(to)) {
       return getFloatingPointWidth(from) > getFloatingPointWidth(to)
                  ? Conversion::Narrow
                  : Conversion::Extend;
     }
-    if (auto fromCplxTy{from.dyn_cast<fir::CplxType>()}) {
-      if (auto toCplxTy{to.dyn_cast<fir::CplxType>()}) {
-        return getFloatingPointWidth(fromCplxTy) >
-                       getFloatingPointWidth(toCplxTy)
-                   ? Conversion::Narrow
-                   : Conversion::Extend;
-      }
-    }
     // Notes:
     // - No conversion between character types, specialization of runtime
     // functions should be made instead.
     // - It is not clear there is a use case for automatic conversions
     // around Logical and it may damage hidden information in the physical
     // storage so do not do it.
     return Conversion::Forbidden;
   }

 mlir::Value IntrinsicLibrary::genIchar(mlir::Type resultType,
                                        llvm::ArrayRef<mlir::Value> args) {
   // There can be an optional kind in second argument.
   assert(args.size() >= 1);
 
   auto arg = args[0];
   Fortran::lower::CharacterExprHelper helper{builder, loc};
   auto dataAndLen = helper.createUnboxChar(arg);
-  auto charType = fir::CharacterType::get(
-      builder.getContext(), helper.getCharacterKind(arg.getType()));
+  fir::CharacterType charType;
   auto refType = builder.getRefType(charType);
   auto charAddr = builder.createConvert(loc, refType, dataAndLen.first);
   auto charVal = builder.create<fir::LoadOp>(loc, charType, charAddr);
   return builder.createConvert(loc, resultType, charVal);
 }
 
 // IEOR
 mlir::Value IntrinsicLibrary::genIEOr(mlir::Type resultType,

flang/lib/Lower/Mangler.cpp

 /// Note: mlir has Type::dump(ostream) methods but it may add "!" that is not
 /// suitable for function names.
 static std::string typeToString(mlir::Type t) {
   if (auto refT{t.dyn_cast<fir::ReferenceType>()})
     return "ref_" + typeToString(refT.getEleTy());
   if (auto i{t.dyn_cast<mlir::IntegerType>()}) {
     return "i" + std::to_string(i.getWidth());
   }
-  if (auto cplx{t.dyn_cast<fir::CplxType>()}) {
-    return "z" + std::to_string(cplx.getFKind());
-  }
   if (auto real{t.dyn_cast<fir::RealType>()}) {
     return "r" + std::to_string(real.getFKind());
   }
   if (auto f{t.dyn_cast<mlir::FloatType>()}) {
     return "f" + std::to_string(f.getWidth());
   }
   if (auto logical{t.dyn_cast<fir::LogicalType>()}) {
     return "l" + std::to_string(logical.getFKind());