[flang] Lower TYPE(*) as fir.box<none>

[clementval]

Summary

This patch lowers TYPE(*) correctly to fir.box<none>.

[clementval]

Remove obsolete comment

[jeanPerier]

Looking at the design doc, I do not remember if you have considered using fir.box<None> for TYPE(*). Since Type(*) usage is quite limited unlike class(), I do not know if it is really worth encoding it as a special class.
In fact, we are sort of already using fir.box<none> as a TYPE(*) equivalent around the runtime interface. So unless you see specific reasons to use and extend fir.class here, maybe using fir.box would be enough ?

[clementval]

In D135141#3833206, @jeanPerier wrote:

Looking at the design doc, I do not remember if you have considered using fir.box<None> for TYPE(*). Since Type(*) usage is quite limited unlike class(), I do not know if it is really worth encoding it as a special class.
In fact, we are sort of already using fir.box<none> as a TYPE(*) equivalent around the runtime interface. So unless you see specific reasons to use and extend fir.class here, maybe using fir.box would be enough ?

Yes we can also use fir.type<none> for TYPE(*). At the moment, I do not see any specific reasons we need to distinguish between the current usage of fir.box<none> and TYPE(*) but of course we can always change that in case a reason arise. The motivation here was to keep all polymorphic entities represented as fir.class and since TYPE(*) is unlimited polymorphic then it would have fall in that representation as well. I'm fine with going with fir.box<none>. It would also remove the need of a custom assembly format.

[jeanPerier]

In D135141#3833230, @clementval wrote:

In D135141#3833206, @jeanPerier wrote:

Looking at the design doc, I do not remember if you have considered using fir.box<None> for TYPE(*). Since Type(*) usage is quite limited unlike class(), I do not know if it is really worth encoding it as a special class.
In fact, we are sort of already using fir.box<none> as a TYPE(*) equivalent around the runtime interface. So unless you see specific reasons to use and extend fir.class here, maybe using fir.box would be enough ?

Yes we can also use fir.type<none> for TYPE(*). At the moment, I do not see any specific reasons we need to distinguish between the current usage of fir.box<none> and TYPE(*) but of course we can always change that in case a reason arise. The motivation here was to keep all polymorphic entities represented as fir.class and since TYPE(*) is unlimited polymorphic then it would have fall in that representation as well. I'm fine with going with fir.box<none>. It would also remove the need of a custom assembly format.

OK, then I vote for making TYPE(*) be fir.box<none>. Given C709 restrictions about assumed types, I think it makes more sense to keep them separate from CLASS entities and reserve fir.class for CLASS.

[clementval]

In D135141#3833290, @jeanPerier wrote:

In D135141#3833230, @clementval wrote:

In D135141#3833206, @jeanPerier wrote:

Looking at the design doc, I do not remember if you have considered using fir.box<None> for TYPE(*). Since Type(*) usage is quite limited unlike class(), I do not know if it is really worth encoding it as a special class.
In fact, we are sort of already using fir.box<none> as a TYPE(*) equivalent around the runtime interface. So unless you see specific reasons to use and extend fir.class here, maybe using fir.box would be enough ?

Yes we can also use fir.type<none> for TYPE(*). At the moment, I do not see any specific reasons we need to distinguish between the current usage of fir.box<none> and TYPE(*) but of course we can always change that in case a reason arise. The motivation here was to keep all polymorphic entities represented as fir.class and since TYPE(*) is unlimited polymorphic then it would have fall in that representation as well. I'm fine with going with fir.box<none>. It would also remove the need of a custom assembly format.

OK, then I vote for making TYPE(*) be fir.box<none>. Given C709 restrictions about assumed types, I think it makes more sense to keep them separate from CLASS entities and reserve fir.class for CLASS.

Ok fine for me. I'll update the patch and the other one today.

[clementval]

Switch to fir.box<none> representation

[jeanPerier]

LGTM, thanks

[jeanPerier]

flang/lib/Lower/CallInterface.cpp

863

Beware builbot clang-format is complaining for this file.

[clementval]

clang-format

[clementval]

flang/lib/Lower/CallInterface.cpp

863

Thanks. I had a bad clang-format config in arcanist for a while.

flang/docs/PolymorphicEntities.md

 func.func @bar(%x : !fir.class<none>)
 ```
 
 ### Assumed-type `TYPE(*)`
 
 Assumed type is added in Fortran 2018 and it is available only for dummy
 arguments. It's mainly used for interfaces to non-Fortran code and is similar
 to C's `void`.
+An entity that is declared using the `TYPE(*)` type specifier is assumed-type
+and is an unlimited polymorphic entity. It is not declared to have a type, and
+is not considered to have the same declared type as any other entity,
+including another unlimited polymorphic entity. Its dynamic type and type
+parameters are assumed from its effective argument (7.3.2.2 - 3).
 
-Assumed-type is represented as `!fir.type<*>`.
+Assumed-type is represented in FIR as `!fir.box<none>`.
 
 ### SELECT TYPE construct
 
 The `SELECT TYPE` construct select for execution at most one of its constituent
 block. The selection is based on the dynamic type of the selector.
 
 **Fortran**
 ```fortran

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

 /// Convert llvm::Type::TypeID to mlir::Type
 mlir::Type fromRealTypeID(mlir::MLIRContext *context, llvm::Type::TypeID typeID,
                           fir::KindTy kind);
 
 inline bool BaseBoxType::classof(mlir::Type type) {
   return type.isa<fir::BoxType, fir::ClassType>();
 }
 
-/// Return a fir.box<T> or fir.class<T> if the type is polymorphic.
+/// Return true iff `ty` is none or fir.array<none>.
+inline bool isNoneOrSeqNone(mlir::Type type) {
+  if (auto seqTy = type.dyn_cast<fir::SequenceType>())
+    return seqTy.getEleTy().isa<mlir::NoneType>();
+  return type.isa<mlir::NoneType>();
+}
+
+/// Return a fir.box<T> or fir.class<T> if the type is polymorphic. If the type
+/// is polymorphic and assumed shape return fir.box<T>.
 inline mlir::Type wrapInClassOrBoxType(mlir::Type eleTy,
-                                       bool isPolymorphic = false) {
-  if (isPolymorphic)
+                                       bool isPolymorphic = false,
+                                       bool isAssumedType = false) {
+  if (isPolymorphic && !isAssumedType)
     return fir::ClassType::get(eleTy);
   return fir::BoxType::get(eleTy);
 }
 
 } // namespace fir
 
 #endif // FORTRAN_OPTIMIZER_DIALECT_FIRTYPE_H

flang/include/flang/Semantics/tools.h

 bool IsExternal(const Symbol &);
 bool IsModuleProcedure(const Symbol &);
 // Is the symbol modifiable in this scope
 std::optional<parser::Message> WhyNotModifiable(const Symbol &, const Scope &);
 std::optional<parser::Message> WhyNotModifiable(SourceName, const SomeExpr &,
     const Scope &, bool vectorSubscriptIsOk = false);
 const Symbol *IsExternalInPureContext(const Symbol &, const Scope &);
 bool HasCoarray(const parser::Expr &);
+bool IsAssumedType(const Symbol &);
 bool IsPolymorphic(const Symbol &);
 bool IsPolymorphicAllocatable(const Symbol &);
 // Return an error if component symbol is not accessible from scope (7.5.4.8(2))
 std::optional<parser::MessageFormattedText> CheckAccessibleComponent(
     const semantics::Scope &, const Symbol &);
 
 // Analysis of image control statements
 bool IsImageControlStmt(const parser::ExecutableConstruct &);

flang/lib/Lower/CallInterface.cpp

void handleExplicitDummy(
     fir::SequenceType::Shape bounds = getBounds(obj.type.shape());
     if (!bounds.empty())
       type = fir::SequenceType::get(bounds, type);
     if (obj.attrs.test(Attrs::Allocatable))
       type = fir::HeapType::get(type);
     if (obj.attrs.test(Attrs::Pointer))
       type = fir::PointerType::get(type);
     mlir::Type boxType =
-        fir::wrapInClassOrBoxType(type, obj.type.type().IsPolymorphic());
+        fir::wrapInClassOrBoxType(type, obj.type.type().IsPolymorphic(), obj.type.type().IsAssumedType());
 
     if (obj.attrs.test(Attrs::Allocatable) || obj.attrs.test(Attrs::Pointer)) {
       // Pass as fir.ref<fir.box> or fir.ref<fir.class>
       mlir::Type boxRefType = fir::ReferenceType::get(boxType);
       addFirOperand(boxRefType, nextPassedArgPosition(), Property::MutableBox,
                     attrs);
       addPassedArg(PassEntityBy::MutableBox, entity, characteristics);
     } else if (dummyRequiresBox(obj)) {
void handleExplicitResult(
     const Fortran::evaluate::characteristics::TypeAndShape *typeAndShape =
         result.GetTypeAndShape();
     assert(typeAndShape && "expect type for non proc pointer result");
     mlir::Type mlirType = translateDynamicType(typeAndShape->type());
     fir::SequenceType::Shape bounds = getBounds(typeAndShape->shape());
     const auto *resTypeAndShape{result.GetTypeAndShape()};
     bool resIsPolymorphic =
         resTypeAndShape && resTypeAndShape->type().IsPolymorphic();
+    bool resIsAssumedType =
+        resTypeAndShape && resTypeAndShape->type().IsAssumedType();
     if (!bounds.empty())
       mlirType = fir::SequenceType::get(bounds, mlirType);
     if (result.attrs.test(Attr::Allocatable))
       mlirType = fir::wrapInClassOrBoxType(fir::HeapType::get(mlirType),
-                                           resIsPolymorphic);
+                                           resIsPolymorphic, resIsAssumedType);
     if (result.attrs.test(Attr::Pointer))
       mlirType = fir::wrapInClassOrBoxType(fir::PointerType::get(mlirType),
-                                           resIsPolymorphic);
+                                           resIsPolymorphic, resIsAssumedType);
 
     if (fir::isa_char(mlirType)) {
       // Character scalar results must be passed as arguments in lowering so
       // that an assumed length character function callee can access the result
       // length. A function with a result requiring an explicit interface does
       // not have to be compatible with assumed length function, but most
       // compilers supports it.
       handleImplicitCharacterResult(typeAndShape->type());

flang/lib/Semantics/tools.cpp

for (const Symbol &symbol : evaluate::CollectSymbols(*expr)) {
       if (evaluate::IsCoarray(symbol)) {
         return true;
       }
     }
   }
   return false;
 }
 
+bool IsAssumedType(const Symbol &symbol) {
+  if (const DeclTypeSpec * type{symbol.GetType()}) {
+    return type->IsAssumedType();
+  }
+  return false;
+}
+
 bool IsPolymorphic(const Symbol &symbol) {
   if (const DeclTypeSpec * type{symbol.GetType()}) {
     return type->IsPolymorphic();
   }
   return false;
 }
 
 bool IsPolymorphicAllocatable(const Symbol &symbol) {

flang/test/Lower/polymorphic-types.f90

 ! CHECK: fir.store %[[BOX]] to %[[MEM]] : !fir.ref<!fir.class<!fir.ptr<none>>>
 ! CHECK: %[[LOAD:.*]] = fir.load %[[MEM]] : !fir.ref<!fir.class<!fir.ptr<none>>>
 ! CHECK: return %[[LOAD]] : !fir.class<!fir.ptr<none>>
 
 ! ------------------------------------------------------------------------------
 ! Test assumed type argument types
 ! ------------------------------------------------------------------------------
 
-  ! Follow up patch will add a `fir.assumed_type` attribute to the types in the
-  ! two tests below.
   subroutine assumed_type_dummy(a) bind(c)
     type(*) :: a
   end subroutine assumed_type_dummy
 
   ! CHECK-LABEL: func.func @assumed_type_dummy(
-  ! CHECK-SAME: %{{.*}}: !fir.class<none>
+  ! CHECK-SAME: %{{.*}}: !fir.box<none>
 
   subroutine assumed_type_dummy_array(a) bind(c)
     type(*) :: a(:)
   end subroutine assumed_type_dummy_array
 
   ! CHECK-LABEL: func.func @assumed_type_dummy_array(
-  ! CHECK-SAME: %{{.*}}: !fir.class<!fir.array<?xnone>>
+  ! CHECK-SAME: %{{.*}}: !fir.box<!fir.array<?xnone>>
 end module