[flang] Add lcobound and ucobound to the list of intrinsics

[ktras]

Summary

Add the coarray intrinsic functions, lcobound and ucobound, to the
list of intrinsics. For both of these functions, add a check to
ensure that if the optional dim argument is present and statically
checkable, its value is in the inclusive range of 1 and the corank
of the coarray argument. In the semantics tests for lcobound and
ucobound, remove the XFAIL directive, add the ERROR directives and
add additional standard-conforming and non-standard conforming
calls.

[craig.rasmussen]

flang/test/Semantics/lcobound.f90

10

How about testing for corank>1?

[ktras]

flang/test/Semantics/lcobound.f90

10

I have added some coarrays with a corank>1 to pass to the coarray argument now. In doing so, I discovered that the restriction I tried to add to the dim argument, requiring it to be within the range of the corank doesn't work when the corank is above 1. So I am going back to work on fixing that before I update the patch.

Thanks for the suggestion!

[ktras]

• Add ucobound to the list of intrinsics and update the semantics test with the ERROR directives and with more examples of valid and invalid code
• Add function to ensure that if the optional dim argument is present and statically checkable, its value is in the inclusive range of 1 and the corank of the coarray argument
• Add more examples of valid and invalid code to the semantics test for lcobound

[craig.rasmussen]

LGTM

[ktras]

@klausler, @jeanPerier, @PeteSteinfeld Would anyone else like to look this over before I push?

[klausler]

flang/lib/Evaluate/intrinsics.cpp

192

It took me several tries to understand the intent here, since the result doesn't depend on the value of the DIM= argument, only its presence, despite the name. Maybe something more self-evident could be used for the name, like "vectorIfNoDim" or "scalarIfDim".

[ktras]

Update name of new enumerator to make its purpose more clear.

[ktras]

flang/lib/Evaluate/intrinsics.cpp

192

Thanks @klausler for the feedback. I have updated the name to scalarIfDim to make its purpose more clear.

flang/docs/Intrinsics.md

 
 ### Semantic Analysis
 F18 semantic expression analysis phase detects intrinsic procedure references,
 validates the argument types and deduces the return types.
 This phase currently supports all the intrinsic procedures listed above but the ones in the table below.
 
 | Intrinsic Category | Intrinsic Procedures Lacking Support |
 | --- | --- |
-| Coarray intrinsic functions | LCOBOUND, UCOBOUND, IMAGE_INDEX, COSHAPE |
+| Coarray intrinsic functions | IMAGE_INDEX, COSHAPE |
 | Object characteristic inquiry functions | ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, IS_CONTIGUOUS, PRESENT, RANK, SAME_TYPE, STORAGE_SIZE |
 | Type inquiry intrinsic functions | BIT_SIZE, DIGITS, EPSILON, HUGE, KIND, MAXEXPONENT, MINEXPONENT, NEW_LINE, PRECISION, RADIX, RANGE, TINY|
 | Non-standard intrinsic functions | AND, OR, XOR, LSHIFT, RSHIFT, SHIFT, ZEXT, IZEXT, COSD, SIND, TAND, ACOSD, ASIND, ATAND, ATAN2D, COMPL, DCMPLX, EQV, NEQV, INT8, JINT, JNINT, KNINT, LOC, QCMPLX, DREAL, DFLOAT, QEXT, QFLOAT, QREAL, DNUM, NUM, JNUM, KNUM, QNUM, RNUM, RAN, RANF, ILEN, SIZEOF, MCLOCK, SECNDS, COTAN, IBCHNG, ISHA, ISHC, ISHL, IXOR, IARG, IARGC, NARGS, NUMARG, BADDRESS, IADDR, CACHESIZE, EOF, FP_CLASS, INT_PTR_KIND, ISNAN, MALLOC |
 | Intrinsic subroutines |MVBITS (elemental), CPU_TIME, DATE_AND_TIME, EVENT_QUERY, EXECUTE_COMMAND_LINE, GET_COMMAND, GET_COMMAND_ARGUMENT, GET_ENVIRONMENT_VARIABLE, MOVE_ALLOC, RANDOM_INIT, RANDOM_NUMBER, RANDOM_SEED, SYSTEM_CLOCK |
 | Atomic intrinsic subroutines | ATOMIC_ADD &al. |
 | Collective intrinsic subroutines | CO_BROADCAST &al. |
 
 

flang/lib/Evaluate/intrinsics.cpp

ENUM_CLASS(Rank,
     array, // not scalar, rank is known and greater than zero
     coarray, // rank is known and can be scalar; has nonzero corank
     known, // rank is known and can be scalar
     anyOrAssumedRank, // rank can be unknown; assumed-type TYPE(*) allowed
     conformable, // scalar, or array of same rank & shape as "array" argument
     reduceOperation, // a pure function with constraints for REDUCE
     dimReduced, // scalar if no DIM= argument, else rank(array)-1
     dimRemovedOrScalar, // rank(array)-1 (less DIM) or scalar
+    scalarIfDim, // scalar if DIM= argument is present, else rank one array
     locReduced, // vector(1:rank) if no DIM= argument, else rank(array)-1
     rankPlus1, // rank(known)+1
     shaped, // rank is length of SHAPE vector
 )
 
 ENUM_CLASS(Optionality, required,
     optional, // unless DIM= for SIZE(assumedSize)
     missing, // for DIM= cases like FINDLOC
static const IntrinsicInterface genericIntrinsicFunction[]{
     {"kind", {{"x", AnyIntrinsic}}, DefaultInt, Rank::elemental,
         IntrinsicClass::inquiryFunction},
     {"lbound",
         {{"array", AnyData, Rank::anyOrAssumedRank}, RequiredDIM,
             SizeDefaultKIND},
         KINDInt, Rank::scalar, IntrinsicClass::inquiryFunction},
     {"lbound", {{"array", AnyData, Rank::anyOrAssumedRank}, SizeDefaultKIND},
         KINDInt, Rank::vector, IntrinsicClass::inquiryFunction},
+    {"lcobound",
+        {{"coarray", AnyData, Rank::coarray}, OptionalDIM, SizeDefaultKIND},
+        KINDInt, Rank::scalarIfDim, IntrinsicClass::inquiryFunction},
     {"leadz", {{"i", AnyInt}}, DefaultInt},
     {"len", {{"string", AnyChar, Rank::anyOrAssumedRank}, DefaultingKIND},
         KINDInt, Rank::scalar, IntrinsicClass::inquiryFunction},
     {"len_trim", {{"string", AnyChar}, DefaultingKIND}, KINDInt},
     {"lge", {{"string_a", SameChar}, {"string_b", SameChar}}, DefaultLogical},
     {"lgt", {{"string_a", SameChar}, {"string_b", SameChar}}, DefaultLogical},
     {"lle", {{"string_a", SameChar}, {"string_b", SameChar}}, DefaultLogical},
     {"llt", {{"string_a", SameChar}, {"string_b", SameChar}}, DefaultLogical},
static const IntrinsicInterface genericIntrinsicFunction[]{
     {"trim", {{"string", SameChar, Rank::scalar}}, SameChar, Rank::scalar,
         IntrinsicClass::transformationalFunction},
     {"ubound",
         {{"array", AnyData, Rank::anyOrAssumedRank}, RequiredDIM,
             SizeDefaultKIND},
         KINDInt, Rank::scalar, IntrinsicClass::inquiryFunction},
     {"ubound", {{"array", AnyData, Rank::anyOrAssumedRank}, SizeDefaultKIND},
         KINDInt, Rank::vector, IntrinsicClass::inquiryFunction},
+    {"ucobound",
+        {{"coarray", AnyData, Rank::coarray}, OptionalDIM, SizeDefaultKIND},
+        KINDInt, Rank::scalarIfDim, IntrinsicClass::inquiryFunction},
     {"unpack",
         {{"vector", SameType, Rank::vector}, {"mask", AnyLogical, Rank::array},
             {"field", SameType, Rank::conformable}},
         SameType, Rank::conformable, IntrinsicClass::transformationalFunction},
     {"verify",
         {{"string", SameChar}, {"set", SameChar},
             {"back", AnyLogical, Rank::elemental, Optionality::optional},
             DefaultingKIND},
// NULL() is a special case handled in Probe() below
         {{"x", AnyReal, Rank::elemental, Optionality::optional}},
         DefaultLogical},
     {"__builtin_ieee_support_underflow_control",
         {{"x", AnyReal, Rank::elemental, Optionality::optional}},
         DefaultLogical},
 };
 
 // TODO: Coarray intrinsic functions
-//   LCOBOUND, UCOBOUND, IMAGE_INDEX, COSHAPE
+//  IMAGE_INDEX, COSHAPE
 // TODO: Non-standard intrinsic functions
 //  LSHIFT, RSHIFT, SHIFT,
 //  COMPL, EQV, NEQV, INT8, JINT, JNINT, KNINT,
 //  QCMPLX, QEXT, QFLOAT, QREAL, DNUM,
 //  INUM, JNUM, KNUM, QNUM, RNUM, RAN, RANF, ILEN,
 //  MCLOCK, SECNDS, COTAN, IBCHNG, ISHA, ISHC, ISHL, IXOR
 //  IARG, IARGC, NARGS, NUMARG, BADDRESS, IADDR, CACHESIZE,
 //  EOF, FP_CLASS, INT_PTR_KIND, MALLOC
if (const ActualArgument * arg{actualForDummy[j]}) {
       case Rank::dimRemovedOrScalar:
         CHECK(arrayArg);
         argOk = rank == 0 || rank + 1 == arrayArg->Rank();
         break;
       case Rank::reduceOperation:
         // The reduction function is validated in ApplySpecificChecks().
         argOk = true;
         break;
+      case Rank::scalarIfDim:
       case Rank::locReduced:
       case Rank::rankPlus1:
       case Rank::shaped:
         common::die("INTERNAL: result-only rank code appears on argument '%s' "
                     "for intrinsic '%s'",
             d.keyword, name);
       }
       if (!argOk) {
std::optional<SpecificCall> IntrinsicInterface::Match(
   case Rank::rankPlus1:
     CHECK(knownArg);
     resultRank = knownArg->Rank() + 1;
     break;
   case Rank::shaped:
     CHECK(shapeArgSize);
     resultRank = *shapeArgSize;
     break;
+  case Rank::scalarIfDim:
+    resultRank = hasDimArg ? 0 : 1;
+    break;
   case Rank::elementalOrBOZ:
   case Rank::shape:
   case Rank::array:
   case Rank::coarray:
   case Rank::known:
   case Rank::anyOrAssumedRank:
   case Rank::reduceOperation:
   case Rank::dimRemovedOrScalar:
if (auto val{ToInt64(arg.UnwrapExpr())}) {
             "'%s=' argument for intrinsic '%s' must be a positive value, but is %jd"_err_en_US,
             argName, procName, static_cast<std::intmax_t>(*val));
       }
     }
   }
   return ok;
 }
 
+static bool CheckDimAgainstCorank(SpecificCall &call, FoldingContext &context) {
+  bool ok{true};
+  if (const auto &coarrayArg{call.arguments[0]}) {
+    if (const auto &dimArg{call.arguments[1]}) {
+      if (const auto *symbol{
+              UnwrapWholeSymbolDataRef(coarrayArg->UnwrapExpr())}) {
+        const auto corank = symbol->Corank();
+        if (const auto dimNum{ToInt64(dimArg->UnwrapExpr())}) {
+          if (dimNum < 1 || dimNum > corank) {
+            ok = false;
+            context.messages().Say(dimArg->sourceLocation(),
+                "DIM=%jd dimension is out of range for coarray with corank %d"_err_en_US,
+                static_cast<std::intmax_t>(*dimNum), corank);
+          }
+        }
+      }
+    }
+  }
+  return ok;
+}
+
 // Applies any semantic checks peculiar to an intrinsic.
 static bool ApplySpecificChecks(SpecificCall &call, FoldingContext &context) {
   bool ok{true};
   const std::string &name{call.specificIntrinsic.name};
   if (name == "allocated") {
     const auto &arg{call.arguments[0]};
     if (arg) {
       if (const auto *expr{arg->UnwrapExpr()}) {
if (const auto &sizeArg{call.arguments[2]}) {
                     "The absolute value of the 'shift=' argument for intrinsic '%s' must be less than or equal to the 'size=' argument"_err_en_US,
                     name);
               }
             }
           }
         }
       }
     }
+  } else if (name == "lcobound") {
+    return CheckDimAgainstCorank(call, context);
   } else if (name == "loc") {
     const auto &arg{call.arguments[0]};
     ok =
         arg && (arg->GetAssumedTypeDummy() || GetLastSymbol(arg->UnwrapExpr()));
     if (!ok) {
       context.messages().Say(
           arg ? arg->sourceLocation() : context.messages().at(),
           "Argument of LOC() must be an object or procedure"_err_en_US);
if (!arrayType || !procChars) {
                       characteristics::DummyDataObject::Attr::Target)) {
             ok = false;
             context.messages().Say(at,
                 "If either argument of the OPERATION= procedure of REDUCE() has the ASYNCHRONOUS, VOLATILE, or TARGET attribute, both must have that attribute"_err_en_US);
           }
         }
       }
     }
+  } else if (name == "ucobound") {
+    return CheckDimAgainstCorank(call, context);
   }
   return ok;
 }
 
 static DynamicType GetReturnType(const SpecificIntrinsicInterface &interface,
     const common::IntrinsicTypeDefaultKinds &defaults) {
   TypeCategory category{TypeCategory::Integer};
   switch (interface.result.kindCode) {

flang/test/Semantics/lcobound.f90

 ! RUN: %python %S/test_errors.py %s %flang_fc1
-! XFAIL: *
 ! Check for semantic errors in lcobound() function references
 
 program lcobound_tests
-  use iso_c_binding, only : c_int32_t
+  use iso_c_binding, only : c_int32_t, c_int64_t
   implicit none
 
   integer n, i, array(1), non_coarray(1), scalar_coarray[*], array_coarray(1)[*], non_constant, scalar
-  logical non_integer
+  integer, parameter :: const_out_of_range_dim = 5, const_in_range_dim = 1
+  real, allocatable :: coarray_corank3[:,:,:]
+  logical non_integer, logical_coarray[3,*]
+  logical, parameter :: const_non_integer = .true.
   integer, allocatable :: lcobounds(:)
 
   !___ standard-conforming statement with no optional arguments present ___
   lcobounds = lcobound(scalar_coarray)
   lcobounds = lcobound(array_coarray)
+  lcobounds = lcobound(coarray_corank3)
+  lcobounds = lcobound(logical_coarray)
   lcobounds = lcobound(coarray=scalar_coarray)
 
   !___ standard-conforming statements with optional dim argument present ___
   n = lcobound(scalar_coarray, 1)
+  n = lcobound(coarray_corank3, 1)
+  n = lcobound(coarray_corank3, 3)
+  n = lcobound(scalar_coarray, const_in_range_dim)
+  n = lcobound(logical_coarray, const_in_range_dim)
   n = lcobound(scalar_coarray, dim=1)
   n = lcobound(coarray=scalar_coarray, dim=1)
   n = lcobound( dim=1, coarray=scalar_coarray)
 
   !___ standard-conforming statements with optional kind argument present ___
   n = lcobound(scalar_coarray, 1, c_int32_t)
 
   n = lcobound(scalar_coarray, 1, kind=c_int32_t)
 
   n = lcobound(scalar_coarray, dim=1, kind=c_int32_t)
   n = lcobound(scalar_coarray, kind=c_int32_t, dim=1)
 
   lcobounds = lcobound(scalar_coarray, kind=c_int32_t)
 
   lcobounds = lcobound(coarray=scalar_coarray, kind=c_int32_t)
   lcobounds = lcobound(kind=c_int32_t, coarray=scalar_coarray)
 
   n = lcobound(coarray=scalar_coarray, dim=1, kind=c_int32_t)
   n = lcobound(dim=1, coarray=scalar_coarray, kind=c_int32_t)
   n = lcobound(kind=c_int32_t, coarray=scalar_coarray, dim=1)
   n = lcobound(dim=1, kind=c_int32_t, coarray=scalar_coarray)
   n = lcobound(kind=c_int32_t, dim=1, coarray=scalar_coarray)
 
   !___ non-conforming statements ___
-  n = lcobound(scalar_coarray, dim=1)
+
+  !ERROR: DIM=0 dimension is out of range for coarray with corank 1
+  n = lcobound(scalar_coarray, dim=0)
+
+  !ERROR: DIM=0 dimension is out of range for coarray with corank 3
+  n = lcobound(coarray_corank3, dim=0)
+
+  !ERROR: DIM=-1 dimension is out of range for coarray with corank 1
+  n = lcobound(scalar_coarray, dim=-1)
+
+  !ERROR: DIM=2 dimension is out of range for coarray with corank 1
   n = lcobound(array_coarray, dim=2)
+
+  !ERROR: DIM=2 dimension is out of range for coarray with corank 1
+  n = lcobound(array_coarray, 2)
+
+  !ERROR: DIM=4 dimension is out of range for coarray with corank 3
+  n = lcobound(coarray_corank3, dim=4)
+
+  !ERROR: DIM=4 dimension is out of range for coarray with corank 3
+  n = lcobound(dim=4, coarray=coarray_corank3)
+
+  !ERROR: DIM=5 dimension is out of range for coarray with corank 3
+  n = lcobound(coarray_corank3, const_out_of_range_dim)
+
+  !ERROR: No intrinsic or user-defined ASSIGNMENT(=) matches scalar INTEGER(4) and rank 1 array of INTEGER(4)
   scalar = lcobound(scalar_coarray)
 
+  !ERROR: missing mandatory 'coarray=' argument
   n = lcobound(dim=i)
 
+  !ERROR: Actual argument for 'dim=' has bad type 'LOGICAL(4)'
   n = lcobound(scalar_coarray, non_integer)
 
+  !ERROR: Actual argument for 'dim=' has bad type 'LOGICAL(4)'
   n = lcobound(scalar_coarray, dim=non_integer)
 
-  lcobounds = lcobound(scalar_coarray, kind=non_integer)
+  !ERROR: Actual argument for 'kind=' has bad type 'LOGICAL(4)'
+  lcobounds = lcobound(scalar_coarray, kind=const_non_integer)
+
+  !ERROR: Actual argument for 'kind=' has bad type 'LOGICAL(4)'
+  n = lcobound(scalar_coarray, 1, const_non_integer)
+
+  !ERROR: 'kind=' argument must be a constant scalar integer whose value is a supported kind for the intrinsic result type
   lcobounds = lcobound(scalar_coarray, kind=non_constant)
 
+  !ERROR: 'kind=' argument must be a constant scalar integer whose value is a supported kind for the intrinsic result type
+  n = lcobound(scalar_coarray, dim=1, kind=non_constant)
+
+  !ERROR: 'kind=' argument must be a constant scalar integer whose value is a supported kind for the intrinsic result type
+  n = lcobound(scalar_coarray, 1, non_constant)
+
+  !ERROR: missing mandatory 'coarray=' argument
   n = lcobound(dim=i, kind=c_int32_t)
 
   n = lcobound(coarray=scalar_coarray, i)
 
+  !ERROR: missing mandatory 'coarray=' argument
+  lcobounds = lcobound()
+
+  !ERROR: 'coarray=' argument must have corank > 0 for intrinsic 'lcobound'
   lcobounds = lcobound(3.4)
 
+  !ERROR: keyword argument to intrinsic 'lcobound' was supplied positionally by an earlier actual argument
+  n = lcobound(scalar_coarray, 1, coarray=scalar_coarray)
+
+  !ERROR: too many actual arguments for intrinsic 'lcobound'
   n = lcobound(scalar_coarray, i, c_int32_t, 0)
 
+  !ERROR: 'coarray=' argument must have corank > 0 for intrinsic 'lcobound'
   lcobounds = lcobound(coarray=non_coarray)
 
-  n = lcobound(scalar_coarray, i, kind=non_integer)
+  !ERROR: 'coarray=' argument must have corank > 0 for intrinsic 'lcobound'
+  n = lcobound(coarray=non_coarray, dim=1)
 
+  !ERROR: 'dim=' argument has unacceptable rank 1
   n = lcobound(scalar_coarray, array )
 
+  !ERROR: unknown keyword argument to intrinsic 'lcobound'
   lcobounds = lcobound(c=scalar_coarray)
 
+  !ERROR: unknown keyword argument to intrinsic 'lcobound'
   n = lcobound(scalar_coarray, dims=i)
 
+  !ERROR: unknown keyword argument to intrinsic 'lcobound'
   n = lcobound(scalar_coarray, i, kinds=c_int32_t)
 
+  !ERROR: repeated keyword argument to intrinsic 'lcobound'
+  n = lcobound(scalar_coarray, dim=1, dim=2)
+
+  !ERROR: repeated keyword argument to intrinsic 'lcobound'
+  lcobounds = lcobound(coarray=scalar_coarray, coarray=array_coarray)
+
+  !ERROR: repeated keyword argument to intrinsic 'lcobound'
+  lcobounds = lcobound(scalar_coarray, kind=c_int32_t, kind=c_int64_t)
+
 end program lcobound_tests

flang/test/Semantics/ucobound.f90

 ! RUN: %python %S/test_errors.py %s %flang_fc1
-! XFAIL: *
 ! Check for semantic errors in ucobound() function references
 
 program ucobound_tests
-  use iso_c_binding, only : c_int32_t
+  use iso_c_binding, only : c_int32_t, c_int64_t
   implicit none
 
   integer n, i, array(1), non_coarray(1), scalar_coarray[*], array_coarray(1)[*], non_constant, scalar
-  logical non_integer
+  integer, parameter :: const_out_of_range_dim = 5, const_in_range_dim = 1
+  real, allocatable :: coarray_corank3[:,:,:]
+  logical non_integer, logical_coarray[3,*]
+  logical, parameter :: const_non_integer = .true.
   integer, allocatable :: ucobounds(:)
-  integer, parameter :: non_existent=2
 
   !___ standard-conforming statement with no optional arguments present ___
   ucobounds = ucobound(scalar_coarray)
   ucobounds = ucobound(array_coarray)
+  ucobounds = ucobound(coarray_corank3)
+  ucobounds = ucobound(logical_coarray)
   ucobounds = ucobound(coarray=scalar_coarray)
 
   !___ standard-conforming statements with optional dim argument present ___
   n = ucobound(scalar_coarray, 1)
+  n = ucobound(coarray_corank3, 1)
+  n = ucobound(coarray_corank3, 3)
+  n = ucobound(scalar_coarray, const_in_range_dim)
+  n = ucobound(logical_coarray, const_in_range_dim)
   n = ucobound(scalar_coarray, dim=1)
   n = ucobound(coarray=scalar_coarray, dim=1)
   n = ucobound( dim=1, coarray=scalar_coarray)
 
   !___ standard-conforming statements with optional kind argument present ___
   n = ucobound(scalar_coarray, 1, c_int32_t)
 
   n = ucobound(scalar_coarray, 1, kind=c_int32_t)
 
   n = ucobound(scalar_coarray, dim=1, kind=c_int32_t)
   n = ucobound(scalar_coarray, kind=c_int32_t, dim=1)
 
   ucobounds = ucobound(scalar_coarray, kind=c_int32_t)
 
   ucobounds = ucobound(coarray=scalar_coarray, kind=c_int32_t)
   ucobounds = ucobound(kind=c_int32_t, coarray=scalar_coarray)
 
   n = ucobound(coarray=scalar_coarray, dim=1, kind=c_int32_t)
   n = ucobound(dim=1, coarray=scalar_coarray, kind=c_int32_t)
   n = ucobound(kind=c_int32_t, coarray=scalar_coarray, dim=1)
   n = ucobound(dim=1, kind=c_int32_t, coarray=scalar_coarray)
   n = ucobound(kind=c_int32_t, dim=1, coarray=scalar_coarray)
 
   !___ non-conforming statements ___
-  n = ucobound(scalar_coarray, dim=1)
-  n = ucobound(array_coarray, dim=non_existent)
+
+  !ERROR: DIM=0 dimension is out of range for coarray with corank 1
+  n = ucobound(scalar_coarray, dim=0)
+
+  !ERROR: DIM=0 dimension is out of range for coarray with corank 3
+  n = ucobound(coarray_corank3, dim=0)
+
+  !ERROR: DIM=-1 dimension is out of range for coarray with corank 1
+  n = ucobound(scalar_coarray, dim=-1)
+
+  !ERROR: DIM=2 dimension is out of range for coarray with corank 1
+  n = ucobound(array_coarray, dim=2)
+
+  !ERROR: DIM=2 dimension is out of range for coarray with corank 1
+  n = ucobound(array_coarray, 2)
+
+  !ERROR: DIM=4 dimension is out of range for coarray with corank 3
+  n = ucobound(coarray_corank3, dim=4)
+
+  !ERROR: DIM=4 dimension is out of range for coarray with corank 3
+  n = ucobound(dim=4, coarray=coarray_corank3)
+
+  !ERROR: DIM=5 dimension is out of range for coarray with corank 3
+  n = ucobound(coarray_corank3, const_out_of_range_dim)
+
+  !ERROR: No intrinsic or user-defined ASSIGNMENT(=) matches scalar INTEGER(4) and rank 1 array of INTEGER(4)
   scalar = ucobound(scalar_coarray)
 
+  !ERROR: missing mandatory 'coarray=' argument
   n = ucobound(dim=i)
 
+  !ERROR: Actual argument for 'dim=' has bad type 'LOGICAL(4)'
   n = ucobound(scalar_coarray, non_integer)
 
+  !ERROR: Actual argument for 'dim=' has bad type 'LOGICAL(4)'
   n = ucobound(scalar_coarray, dim=non_integer)
 
-  ucobounds = ucobound(scalar_coarray, kind=non_integer)
+  !ERROR: Actual argument for 'kind=' has bad type 'LOGICAL(4)'
+  ucobounds = ucobound(scalar_coarray, kind=const_non_integer)
+
+  !ERROR: Actual argument for 'kind=' has bad type 'LOGICAL(4)'
+  n = ucobound(scalar_coarray, 1, const_non_integer)
+
+  !ERROR: 'kind=' argument must be a constant scalar integer whose value is a supported kind for the intrinsic result type
   ucobounds = ucobound(scalar_coarray, kind=non_constant)
 
+  !ERROR: 'kind=' argument must be a constant scalar integer whose value is a supported kind for the intrinsic result type
+  n = ucobound(scalar_coarray, dim=1, kind=non_constant)
+
+  !ERROR: 'kind=' argument must be a constant scalar integer whose value is a supported kind for the intrinsic result type
+  n = ucobound(scalar_coarray, 1, non_constant)
+
+  !ERROR: missing mandatory 'coarray=' argument
   n = ucobound(dim=i, kind=c_int32_t)
 
   n = ucobound(coarray=scalar_coarray, i)
 
+  !ERROR: missing mandatory 'coarray=' argument
+  ucobounds = ucobound()
+
+  !ERROR: 'coarray=' argument must have corank > 0 for intrinsic 'ucobound'
   ucobounds = ucobound(3.4)
 
+  !ERROR: keyword argument to intrinsic 'ucobound' was supplied positionally by an earlier actual argument
+  n = ucobound(scalar_coarray, 1, coarray=scalar_coarray)
+
+  !ERROR: too many actual arguments for intrinsic 'ucobound'
   n = ucobound(scalar_coarray, i, c_int32_t, 0)
 
+  !ERROR: 'coarray=' argument must have corank > 0 for intrinsic 'ucobound'
   ucobounds = ucobound(coarray=non_coarray)
 
-  n = ucobound(scalar_coarray, i, kind=non_integer)
+  !ERROR: 'coarray=' argument must have corank > 0 for intrinsic 'ucobound'
+  n = ucobound(coarray=non_coarray, dim=1)
 
+  !ERROR: 'dim=' argument has unacceptable rank 1
   n = ucobound(scalar_coarray, array )
 
+  !ERROR: unknown keyword argument to intrinsic 'ucobound'
   ucobounds = ucobound(c=scalar_coarray)
 
+  !ERROR: unknown keyword argument to intrinsic 'ucobound'
   n = ucobound(scalar_coarray, dims=i)
 
+  !ERROR: unknown keyword argument to intrinsic 'ucobound'
   n = ucobound(scalar_coarray, i, kinds=c_int32_t)
 
+  !ERROR: repeated keyword argument to intrinsic 'ucobound'
+  n = ucobound(scalar_coarray, dim=1, dim=2)
+
+  !ERROR: repeated keyword argument to intrinsic 'ucobound'
+  ucobounds = ucobound(coarray=scalar_coarray, coarray=array_coarray)
+
+  !ERROR: repeated keyword argument to intrinsic 'ucobound'
+  ucobounds = ucobound(scalar_coarray, kind=c_int32_t, kind=c_int64_t)
+
 end program ucobound_tests