[flang] Accept non-interoperable LOGICAL scalar dummy arguments

[klausler]

Summary

Some Fortran compilers allow kinds of LOGICAL other than C_BOOL
for the types of dummy arguments to interoperable (BIND(C))
procedures. As any kind of LOGICAL can be converted to any
other without loss of information, this seems to be a useful
unambiguous extension that is attested in real codes; accept it
for scalars with a portability warning.

[clementval]

LGTM

flang/docs/Extensions.md

* A type-bound procedure binding can be passed as an actual
   the target of a procedure pointer assignment statement.
 * An explicit `INTERFACE` can declare the interface of a
   procedure pointer even if it is not a dummy argument.
 * A `NOPASS` type-bound procedure binding is required by C1529
   to apply only to a scalar data-ref, but most compilers don't
   enforce it and the constraint is not necessary for a correct
   implementation.
 * A label may follow a semicolon in fixed form source.
+* A scalar logical dummy argument to a `BIND(C)` procedure does
+  not have to have `KIND=C_BOOL` since it can be converted to/from
+  `_Bool` without loss of information.
 
 ### Extensions supported when enabled by options
 
 * C-style backslash escape sequences in quoted CHARACTER literals
   (but not Hollerith) [-fbackslash]
 * Logical abbreviations `.T.`, `.F.`, `.N.`, `.A.`, `.O.`, and `.X.`
   [-flogical-abbreviations]
 * `.XOR.` as a synonym for `.NEQV.` [-fxor-operator]

flang/lib/Semantics/check-declarations.cpp

if (symbol.GetIsExplicitBindName()) { // BIND(C,NAME=...); C1552, C1529
     }
   }
   if (const auto *object{symbol.detailsIf<ObjectEntityDetails>()}) {
     if (isExplicitBindC && !symbol.owner().IsModule()) {
       messages_.Say(symbol.name(),
           "A variable with BIND(C) attribute may only appear in the specification part of a module"_err_en_US);
       context_.SetError(symbol);
     }
-    if (auto shape{evaluate::GetShape(foldingContext_, symbol)}) {
+    auto shape{evaluate::GetShape(foldingContext_, symbol)};
+    if (shape) {
       if (evaluate::GetRank(*shape) == 0) { // 18.3.4
         if (isExplicitBindC && IsAllocatableOrPointer(symbol)) {
           messages_.Say(symbol.name(),
               "A scalar interoperable variable may not be ALLOCATABLE or POINTER"_err_en_US);
           context_.SetError(symbol);
         }
       } else { // 18.3.5
         if (auto extents{
if (const auto *type{symbol.GetType()}) {
       if (type->IsAssumedType() || IsAssumedLengthCharacter(symbol)) {
         // ok
       } else if (IsAllocatableOrPointer(symbol) &&
           type->category() == DeclTypeSpec::Character &&
           type->characterTypeSpec().length().isDeferred()) {
         // ok; F'2018 18.3.6 p2(6)
       } else if (derived || IsInteroperableIntrinsicType(*type)) {
         // F'2018 18.3.6 p2(4,5)
+      } else if (type->category() == DeclTypeSpec::Logical && IsDummy(symbol) &&
+          evaluate::GetRank(*shape) == 0) {
+        // Special exception: LOGICAL scalar dummy arguments can be converted
+        // before a call -- & after if not INTENT(IN) -- without loss of
+        // information, and are accepted by some older compilers.
+        messages_.Say(symbol.name(),
+            "A BIND(C) LOGICAL dummy argument should have the interoperable KIND=C_BOOL"_port_en_US);
       } else if (symbol.attrs().test(Attr::VALUE)) {
         messages_.Say(symbol.name(),
             "A BIND(C) VALUE dummy argument must have an interoperable type"_err_en_US);
         context_.SetError(symbol);
       } else {
         messages_.Say(symbol.name(),
             "A BIND(C) object must have an interoperable type"_err_en_US);
         context_.SetError(symbol);

flang/test/Semantics/bind-c11.f90

 ! RUN: %python %S/test_errors.py %s %flang_fc1
 module m
   !ERROR: A scalar interoperable variable may not be ALLOCATABLE or POINTER
   real, allocatable, bind(c) :: x1
   !ERROR: A scalar interoperable variable may not be ALLOCATABLE or POINTER
   real, pointer, bind(c) :: x2
   !ERROR: BIND(C) array must have explicit shape or be assumed-size unless a dummy argument without the VALUE attribute
   real, allocatable, bind(c) :: x3(:)
  contains
   subroutine s1(x) bind(c)
-    !ERROR: A BIND(C) VALUE dummy argument must have an interoperable type
+    !PORTABILITY: A BIND(C) LOGICAL dummy argument should have the interoperable KIND=C_BOOL
     logical(2), intent(in), value :: x
   end
   subroutine s2(x) bind(c)
     !PORTABILITY: An interoperable procedure with an OPTIONAL dummy argument might not be portable
     integer, intent(in), optional :: x
   end
   !ERROR: A subprogram interface with the BIND attribute may not have an alternate return argument
   subroutine s3(*) bind(c)
   end
 end