[flang] Fix calls to interfaces with logical literal arguments

[DavidTruby]

Summary

Fixes: 64698

[PeteSteinfeld]

Thanks for the quick fix!

I've verified that this builds and tests correctly for me and that it fixes the problem that @sscalpone complained about.

flang/lib/Semantics/check-call.cpp

bool typesCompatibleWithIgnoreTKR{
           (dummy.type.type().category() == TypeCategory::Derived ||
               actualType.type().category() == TypeCategory::Derived ||
               dummy.type.type().category() != actualType.type().category())) ||
       (dummy.ignoreTKR.test(common::IgnoreTKR::Kind) &&
           dummy.type.type().category() == actualType.type().category())};
   allowActualArgumentConversions &= !typesCompatibleWithIgnoreTKR;
   if (allowActualArgumentConversions) {
     ConvertIntegerActual(actual, dummy.type, actualType, messages);
-  }
     ConvertLogicalActual(actual, dummy.type, actualType);
+  }
   bool typesCompatible{typesCompatibleWithIgnoreTKR ||
       dummy.type.type().IsTkCompatibleWith(actualType.type())};
   int dummyRank{dummy.type.Rank()};
   if (!typesCompatible && dummyRank == 0 && allowActualArgumentConversions) {
     // Extension: pass Hollerith literal to scalar as if it had been BOZ
     if (auto converted{evaluate::HollerithToBOZ(
             foldingContext, actual, dummy.type.type())}) {
       messages.Say(

flang/test/Evaluate/logical-args.f90

 ! Test that actual logical arguments convert to the right kind when it is non-default
 ! RUN: %flang_fc1 -fdebug-unparse %s 2>&1 | FileCheck %s
 ! RUN: %flang_fc1 -fdebug-unparse -fdefault-integer-8 %s 2>&1 | FileCheck %s --check-prefixes CHECK-8
 
+module m
+  interface foog
+     subroutine foo4(l)
+       logical(kind=4), intent(in) :: l
+     end subroutine foo4
+
+     subroutine foo8(l)
+       logical(kind=8), intent(in) :: l
+     end subroutine foo8
+  end interface foog
+end module m
+
 program main
+  use m
   integer :: x(10), y
   ! CHECK: CALL foo(.true._4)
   ! CHECK-8: CALL foo(logical(.true._4,kind=8))
   call foo(1 < 2)
   ! CHECK: CALL fooa(x>y)
   ! CHECK-8: CALL fooa(logical(x>y,kind=8))
   call fooa(x > y)
 
+  ! Ensure that calls to interfaces call the correct subroutine
+  ! CHECK: CALL foo4(.true._4)
+  ! CHECK-8: CALL foo8(.true._8)
+  call foog(.true.)
+
   contains
     subroutine foo(l)
       logical :: l
     end subroutine foo
 
     subroutine fooa(l)
       logical :: l(10)
     end subroutine fooa
+
 end program main