[flang] Keep current polymorphic implementation under a flag

[clementval]

Summary

It is useful for couple of test suite like NAG to keep failing
with a TODO until the polymorphic entities is implemented all the
way done to codegen.

This pass adds a flag to LoweringOptions for experimental development.
This flag is off by default and can be enable in bbc with -polymorphic-type.
Options can be added in the driver and tco when needed.

[PeteSteinfeld]

This generally functions well. But I'd rather have a name that's specific to the new implementation of polymorphic types rather than "experimental". Something like "PolyTypeImpl".

[tschuett]

libc++ went the other direction. -fexperimental-library , see https://releases.llvm.org/15.0.0/projects/libcxx/docs/ReleaseNotes.html. It enables all features, TSs that are under development.

[clementval]

Change flang name

[clementval]

In D135283#3837690, @tschuett wrote:

libc++ went the other direction. -fexperimental-library , see https://releases.llvm.org/15.0.0/projects/libcxx/docs/ReleaseNotes.html. It enables all features, TSs that are under development.

Since we are gradually implementing this feature and it is supposed to be removed once done, a dedicated option fits better here. I'm pretty sure we will have something like experimental in the future.

[clementval]

clang-format

[PeteSteinfeld]

All builds and tests correctly and looks good.

Thanks for the fast action!

flang/include/flang/Lower/LoweringOptions.h

 #define FLANG_LOWER_LOWERINGOPTIONS_H
 
 namespace Fortran::lower {
 
 class LoweringOptions {
   /// If true, lower transpose without a runtime call.
   unsigned optimizeTranspose : 1;
 
+  /// If true, enable polymorphic type lowering feature. Off by default.
+  unsigned polymorphicTypeImpl : 1;
+
 public:
-  LoweringOptions() : optimizeTranspose(true) {}
+  LoweringOptions() : optimizeTranspose(true), polymorphicTypeImpl(false) {}
 
   bool getOptimizeTranspose() const { return optimizeTranspose; }
   LoweringOptions &setOptimizeTranspose(bool v) {
     optimizeTranspose = v;
     return *this;
   }
+
+  bool isPolymorphicTypeImplEnabled() const { return polymorphicTypeImpl; }
+  LoweringOptions &setPolymorphicTypeImpl(bool v) {
+    polymorphicTypeImpl = v;
+    return *this;
+  }
 };
 
 } // namespace Fortran::lower
 
 #endif // FLANG_LOWER_LOWERINGOPTIONS_H

flang/lib/Lower/CallInterface.cpp

bool dummyRequiresBox(
     return false;
   }
 
   mlir::Type
   translateDynamicType(const Fortran::evaluate::DynamicType &dynamicType) {
     Fortran::common::TypeCategory cat = dynamicType.category();
     // DERIVED
     if (cat == Fortran::common::TypeCategory::Derived) {
+      // TODO is kept under experimental flag until feature is complete.
+      if (dynamicType.IsPolymorphic() &&
+          !getConverter().getLoweringOptions().isPolymorphicTypeImplEnabled())
+        TODO(interface.converter.getCurrentLocation(),
+             "support for polymorphic types");
+
       if (dynamicType.IsUnlimitedPolymorphic())
         return mlir::NoneType::get(&mlirContext);
       return getConverter().genType(dynamicType.GetDerivedTypeSpec());
     }
     // CHARACTER with compile time constant length.
     if (cat == Fortran::common::TypeCategory::Character)
       if (std::optional<std::int64_t> constantLen =
               toInt64(dynamicType.GetCharLength()))

flang/lib/Lower/ConvertType.cpp

if (Fortran::semantics::IsProcedurePointer(ultimate))
       TODO(loc, "procedure pointers");
     if (const Fortran::semantics::DeclTypeSpec *type = ultimate.GetType()) {
       if (const Fortran::semantics::IntrinsicTypeSpec *tySpec =
               type->AsIntrinsic()) {
         int kind = toInt64(Fortran::common::Clone(tySpec->kind())).value();
         llvm::SmallVector<Fortran::lower::LenParameterTy> params;
         translateLenParameters(params, tySpec->category(), ultimate);
         ty = genFIRType(context, tySpec->category(), kind, params);
+      } else if (type->IsPolymorphic() &&
+                 !converter.getLoweringOptions()
+                      .isPolymorphicTypeImplEnabled()) {
+        // TODO is kept under experimental flag until feature is complete.
+        TODO(loc, "support for polymorphic types");
       } else if (type->IsUnlimitedPolymorphic()) {
         ty = mlir::NoneType::get(context);
       } else if (const Fortran::semantics::DerivedTypeSpec *tySpec =
                      type->AsDerived()) {
         ty = genDerivedType(*tySpec);
       } else {
         fir::emitFatalError(loc, "symbol's type must have a type spec");
       }

flang/test/Lower/polymorphic-types.f90

-! RUN: bbc -emit-fir %s -o - | FileCheck %s
+! RUN: bbc -polymorphic-type -emit-fir %s -o - | FileCheck %s
 
 ! Tests the different possible type involving polymorphic entities. 
 
 module polymorphic_types
   type p1
     integer :: a
     integer :: b
   contains

flang/tools/bbc/bbc.cpp

 static llvm::cl::opt<bool> enableOpenMP("fopenmp",
                                         llvm::cl::desc("enable openmp"),
                                         llvm::cl::init(false));
 
 static llvm::cl::opt<bool> enableOpenACC("fopenacc",
                                          llvm::cl::desc("enable openacc"),
                                          llvm::cl::init(false));
 
+static llvm::cl::opt<bool> enablePolymorphic(
+    "polymorphic-type",
+    llvm::cl::desc("enable polymorphic type lowering (experimental)"),
+    llvm::cl::init(false));
+
 #define FLANG_EXCLUDE_CODEGEN
 #include "flang/Tools/CLOptions.inc"
 
 //===----------------------------------------------------------------------===//
 
 using ProgramName = std::string;
 
 // Print the module without the "module { ... }" wrapper.
static mlir::LogicalResult convertFortranSourceToMLIR(
   fir::support::registerNonCodegenDialects(registry);
   mlir::MLIRContext ctx(registry);
   fir::support::loadNonCodegenDialects(ctx);
   auto &defKinds = semanticsContext.defaultKinds();
   fir::KindMapping kindMap(
       &ctx, llvm::ArrayRef<fir::KindTy>{fir::fromDefaultKinds(defKinds)});
   // Use default lowering options for bbc.
   Fortran::lower::LoweringOptions loweringOptions{};
+  loweringOptions.setPolymorphicTypeImpl(enablePolymorphic);
   auto burnside = Fortran::lower::LoweringBridge::create(
       ctx, semanticsContext, defKinds, semanticsContext.intrinsics(),
       semanticsContext.targetCharacteristics(), parsing.allCooked(), "",
       kindMap, loweringOptions);
   burnside.lower(parseTree, semanticsContext);
   mlir::ModuleOp mlirModule = burnside.getModule();
   std::error_code ec;
   std::string outputName = outputFilename;