[flang] Do not try to rebox for assumed type

[clementval]

Summary

Just use conversion from assuemd type to assumed type
because a rebox needs more information that are not available
with assumed type.

Also use isAssumedType instead of isBoxNone since assumed
type can have sequence information.

Depends on D146207

[clementval]

Add missing test

[PeteSteinfeld]

All builds and tests correctly and (aside from the clang-format diffs) looks good. Please run clang-format before merging.

flang/lib/Optimizer/Builder/FIRBuilder.cpp

363

I got clang-format errors here.

[clementval]

clang-format

flang/include/flang/Optimizer/Dialect/FIRType.h

 /// Return true iff `ty` is the type of an polymorphic entity or
 /// value.
 bool isPolymorphicType(mlir::Type ty);
 
 /// Return true iff `ty` is the type of an unlimited polymorphic entity or
 /// value.
 bool isUnlimitedPolymorphicType(mlir::Type ty);
 
+/// Return true iff `ty` is the type of an assumed type.
+bool isAssumedType(mlir::Type ty);
+
 /// Return true iff `boxTy` wraps a record type or an unlimited polymorphic
 /// entity. Polymorphic entities with intrinsic type spec do not have addendum
 inline bool boxHasAddendum(fir::BaseBoxType boxTy) {
   return static_cast<bool>(unwrapIfDerived(boxTy)) ||
          fir::isUnlimitedPolymorphicType(boxTy);
 }
 
 /// Return the inner type of the given type.

flang/lib/Lower/ConvertExpr.cpp

for (const Fortran::lower::CallInterface<
                     })
                     .getResults()[0];
           } else {
             // Make sure a variable address is only passed if the expression is
             // actually a variable.
             box = Fortran::evaluate::IsVariable(*expr)
                       ? builder.createBox(loc, genBoxArg(*expr),
                                           fir::isPolymorphicType(argTy),
-                                          fir::isBoxNone(argTy))
+                                          fir::isAssumedType(argTy))
                       : builder.createBox(getLoc(), genTempExtAddr(*expr),
                                           fir::isPolymorphicType(argTy),
-                                          fir::isBoxNone(argTy));
+                                          fir::isAssumedType(argTy));
             if (box.getType().isa<fir::BoxType>() &&
-                fir::isPolymorphicType(argTy) && !fir::isBoxNone(argTy)) {
+                fir::isPolymorphicType(argTy) && !fir::isAssumedType(argTy)) {
               mlir::Type actualTy = argTy;
               if (Fortran::lower::isParentComponent(*expr))
                 actualTy = fir::BoxType::get(converter.genType(*expr));
               // Rebox can only be performed on a present argument.
               if (arg.isOptional()) {
                 mlir::Value isPresent =
                     genActualIsPresentTest(builder, loc, box);
                 box = builder

flang/lib/Optimizer/Builder/FIRBuilder.cpp

fir::FirOpBuilder::convertWithSemantics(mlir::Location loc, mlir::Type toTy,
   if (fir::isa_ref_type(fromTy) && toTy.isa<fir::BoxProcType>()) {
     // Call is expecting a boxed procedure, not a reference to other data type.
     // Convert the reference to a procedure and embox it.
     mlir::Type procTy = toTy.cast<fir::BoxProcType>().getEleTy();
     mlir::Value proc = createConvert(loc, procTy, val);
     return create<fir::EmboxProcOp>(loc, toTy, proc);
   }
 
-  if ((fir::isPolymorphicType(fromTy) &&
+ if (((fir::isPolymorphicType(fromTy) &&
        (fir::isAllocatableType(fromTy) || fir::isPointerType(fromTy)) &&
        fir::isPolymorphicType(toTy)) ||
-      (fir::isPolymorphicType(fromTy) && toTy.isa<fir::BoxType>()))
+      (fir::isPolymorphicType(fromTy) && toTy.isa<fir::BoxType>())) &&
+      !(fir::isUnlimitedPolymorphicType(fromTy) && fir::isAssumedType(toTy)))
     return create<fir::ReboxOp>(loc, toTy, val, mlir::Value{},
                                 /*slice=*/mlir::Value{});
 
   return createConvert(loc, toTy, val);
 }
 
 mlir::Value fir::FirOpBuilder::createConvert(mlir::Location loc,
                                              mlir::Type toTy, mlir::Value val) {

flang/lib/Optimizer/Dialect/FIRType.cpp

if (auto boxTy = ty.dyn_cast<fir::BaseBoxType>()) {
     if (auto heapTy = boxTy.getEleTy().dyn_cast<fir::HeapType>())
       return heapTy.getEleTy().isa<fir::RecordType>();
     if (auto ptrTy = boxTy.getEleTy().dyn_cast<fir::PointerType>())
       return ptrTy.getEleTy().isa<fir::RecordType>();
   }
   return false;
 }
 
-static bool isAssumedType(mlir::Type ty) {
+bool isAssumedType(mlir::Type ty) {
   if (auto boxTy = ty.dyn_cast<fir::BoxType>()) {
     if (boxTy.getEleTy().isa<mlir::NoneType>())
       return true;
     if (auto seqTy = boxTy.getEleTy().dyn_cast<fir::SequenceType>())
       return seqTy.getEleTy().isa<mlir::NoneType>();
   }
   return false;
 }