[flang] Add type conversion for !fir.box<none>

[clementval]

Summary

none is used in fir.box type to specify a polymorphic type.
This patch add the conversion from !fir.box<none> to LLVM.

This patch is part of the upstreaming effort from fir-dev branch.

Co-authored-by: Eric Schweitz <[e-mail]>
Co-authored-by: Jean Perier <[e-mail]>

[ftynse]

mlir/test/Conversion/StandardToLLVM/convert-types.mlir

35

Spurious change.

[awarzynski]

flang/test/Fir/types-to-llvm.fir

428

[clementval]

flang/test/Fir/types-to-llvm.fir

428

Good catch!

mlir/test/Conversion/StandardToLLVM/convert-types.mlir

35

My bad. Sorry for the noise.

[clementval]

Address comments

[awarzynski]

LGTM, thanks!

flang/test/Fir/types-to-llvm.fir

424

Incomplete comment :)

flang/lib/Optimizer/CodeGen/TypeConverter.h

addConversion([&](mlir::TupleType tuple) {
         if (auto box = mem.dyn_cast<fir::BoxType>())
           members.push_back(convertBoxTypeAsStruct(box));
         else
           members.push_back(convertType(mem).cast<mlir::Type>());
       }
       return mlir::LLVM::LLVMStructType::getLiteral(&getContext(), members,
                                                     /*isPacked=*/false);
     });
+    addConversion([&](mlir::NoneType none) {
+      return mlir::LLVM::LLVMStructType::getLiteral(
+          none.getContext(), llvm::None, /*isPacked=*/false);
+    });
   }
 
   // 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); }

flang/test/Fir/types-to-llvm.fir

 // Test that fir.box inside tuple and derived type are lowered to struct type.
 func private @foo0(%arg0: tuple<i64, !fir.box<i32>>)
 // CHECK-LABEL: foo0
 // CHECK-SAME: !llvm.struct<(i64, struct<(ptr<i32>, i{{.*}})>)>
 
 func private @foo1(%arg0: !fir.type<derived8{a:i64,b:!fir.box<i32>}>)
 // CHECK-LABEL: foo1
 // CHECK-SAME: !llvm.struct<"derived8", (i64, struct<(ptr<i32>, i{{.*}})>)>
+
+// -----
+
+// Test that fir.box<none>
+// `none` is used for polymorphic type.
+func private @foo0(%arg0: !fir.box<none>)
+// CHECK-LABEL: foo0
+// CHECK-SAMEL !llvm.ptr<struct<(ptr<struct<()>>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>>)

mlir/test/Conversion/StandardToLLVM/convert-types.mlir

 // CHECK-LABEL: @func()
 // CHECK: !llvm.ptr<func<i42 (i42)>>
 func private @func() -> !llvm.ptr<!llvm.func<!test.smpla (!test.smpla)>>
 
 // TODO: support conversion of recursive types in the conversion infra.
 // CHECK-LABEL: @named_recursive()
 // CHECK: !llvm.struct<"_Converted_recursive", (ptr<i42>, ptr<struct<"_Converted_recursive">>)>
 func private @named_recursive() -> !llvm.struct<"recursive", (ptr<!test.smpla>, ptr<struct<"recursive">>)>
-