[flang] Use CFI_TYPE_LAST instead of CFI_type_struct

[rovka]

Summary

It looks like CFI_type_struct was once used as the last valid CFI_type
value, but in the meantime CFI_type_char16_t and CFI_type_char32_t were
added, making that assumption no longer true. Luckily, in the meantime
we also got a define for CFI_TYPE_LAST, which we can now use to allow
CFI_establish and CFI_allocate to work with descriptors of
CFI_type_char16_t, CFI_type_char32_t and any other future types.

flang/runtime/ISO_Fortran_binding.cpp

int CFI_allocate(CFI_cdesc_t *descriptor, const CFI_index_t lower_bounds[],
   if (descriptor->attribute == CFI_attribute_allocatable &&
       descriptor->base_addr) {
     return CFI_ERROR_BASE_ADDR_NOT_NULL;
   }
   if (descriptor->rank > CFI_MAX_RANK) {
     return CFI_INVALID_RANK;
   }
   if (descriptor->type < CFI_type_signed_char ||
-      descriptor->type > CFI_type_struct) {
+      descriptor->type > CFI_TYPE_LAST) {
     return CFI_INVALID_TYPE;
   }
   if (!IsCharacterType(descriptor->type)) {
     elem_len = descriptor->elem_len;
     if (elem_len <= 0) {
       return CFI_INVALID_ELEM_LEN;
     }
   }
if (rank > CFI_MAX_RANK) {
     return CFI_INVALID_RANK;
   }
   if (base_addr && attribute == CFI_attribute_allocatable) {
     return CFI_ERROR_BASE_ADDR_NOT_NULL;
   }
   if (rank > 0 && base_addr && !extents) {
     return CFI_INVALID_EXTENT;
   }
-  if (type < CFI_type_signed_char || type > CFI_type_struct) {
+  if (type < CFI_type_signed_char || type > CFI_TYPE_LAST) {
     return CFI_INVALID_TYPE;
   }
   if (!descriptor) {
     return CFI_INVALID_DESCRIPTOR;
   }
   std::size_t minElemLen{MinElemLen(type)};
   if (minElemLen > 0) {
     elem_len = minElemLen;

flang/unittests/Evaluate/ISO-Fortran-binding.cpp

#endif
   if (base_addr != nullptr && attribute == CFI_attribute_allocatable) {
     ++numErr;
     expectedRetCode = CFI_ERROR_BASE_ADDR_NOT_NULL;
   }
   if (rank > CFI_MAX_RANK) {
     ++numErr;
     expectedRetCode = CFI_INVALID_RANK;
   }
-  if (type < 0 || type > CFI_type_struct) {
+  if (type < 0 || type > CFI_TYPE_LAST) {
     ++numErr;
     expectedRetCode = CFI_INVALID_TYPE;
   }
 
   if ((type == CFI_type_struct || type == CFI_type_char ||
           type == CFI_type_other) &&
       elem_len <= 0) {
     ++numErr;
static void run_CFI_establish_tests() {
   CFI_CDESC_T(CFI_MAX_RANK) dv_storage;
   CFI_cdesc_t *dv{&dv_storage};
   char base;
   void *dummyAddr{&base};
   // Define test space
   CFI_attribute_t attrCases[]{
       CFI_attribute_pointer, CFI_attribute_allocatable, CFI_attribute_other};
   CFI_type_t typeCases[]{CFI_type_int, CFI_type_struct, CFI_type_double,
-      CFI_type_char, CFI_type_other, CFI_type_struct + 1};
+      CFI_type_char, CFI_type_other, CFI_TYPE_LAST + 1};
   CFI_index_t *extentCases[]{extents, nullptr};
   void *baseAddrCases[]{dummyAddr, nullptr};
   CFI_rank_t rankCases[]{0, 1, CFI_MAX_RANK, CFI_MAX_RANK + 1};
   std::size_t lenCases[]{0, 42};
 
   for (CFI_attribute_t attribute : attrCases) {
     for (void *base_addr : baseAddrCases) {
       for (CFI_index_t *extent : extentCases) {
#endif
 
   // Success/failure according to standard
   int numErr{0};
   int expectedRetCode{CFI_SUCCESS};
   if (rank > CFI_MAX_RANK) {
     ++numErr;
     expectedRetCode = CFI_INVALID_RANK;
   }
-  if (type < 0 || type > CFI_type_struct) {
+  if (type < 0 || type > CFI_TYPE_LAST) {
     ++numErr;
     expectedRetCode = CFI_INVALID_TYPE;
   }
   if (base_addr != nullptr && attribute == CFI_attribute_allocatable) {
     // This is less restrictive than 18.5.5.3 arg req for which pointers arg
     // shall be unassociated. However, this match ALLOCATE behavior
     // (9.7.3/9.7.4)
     ++numErr;
static void run_CFI_allocate_tests() {
   // create test world
   CFI_CDESC_T(CFI_MAX_RANK) dv_storage;
   CFI_cdesc_t *dv{&dv_storage};
   char base;
   void *dummyAddr{&base};
   CFI_attribute_t attrCases[]{
       CFI_attribute_pointer, CFI_attribute_allocatable, CFI_attribute_other};
   CFI_type_t typeCases[]{CFI_type_int, CFI_type_struct, CFI_type_double,
-      CFI_type_char, CFI_type_other, CFI_type_struct + 1};
+      CFI_type_char, CFI_type_other, CFI_TYPE_LAST + 1};
   void *baseAddrCases[]{dummyAddr, nullptr};
   CFI_rank_t rankCases[]{0, 1, CFI_MAX_RANK, CFI_MAX_RANK + 1};
   std::size_t lenCases[]{0, 42};
   CFI_index_t lb1[CFI_MAX_RANK];
   CFI_index_t ub1[CFI_MAX_RANK];
   for (int i{0}; i < CFI_MAX_RANK; ++i) {
     lb1[i] = -1;
     ub1[i] = 0;