[flang] Respect !DIR$ IGNORE_TKR in generic matching

[klausler]

Summary

Generic matching needs to relax argument compatibility checks when
dummy arguments have !DIR$ IGNORE_TKR directives.

[DanielCChen]

LGTM. Thanks!

flang/lib/Evaluate/characteristics.cpp

llvm::raw_ostream &DummyDataObject::Dump(llvm::raw_ostream &o) const {
   type.Dump(o);
   if (!coshape.empty()) {
     char sep{'['};
     for (const auto &expr : coshape) {
       expr.AsFortran(o << sep);
       sep = ',';
     }
   }
+  if (!ignoreTKR.empty()) {
+    ignoreTKR.Dump(o << ' ', common::EnumToString);
+  }
   return o;
 }
 
 DummyProcedure::DummyProcedure(Procedure &&p)
     : procedure{new Procedure{std::move(p)}} {}
 
 bool DummyProcedure::operator==(const DummyProcedure &that) const {
   return attrs == that.attrs && intent == that.intent &&

flang/lib/Semantics/expression.cpp

return common::visit(
           [&](const characteristics::DummyDataObject &x) {
             if (x.attrs.test(characteristics::DummyDataObject::Attr::Pointer) &&
                 IsBareNullPointer(expr)) {
               // NULL() without MOLD= is compatible with any dummy data pointer
               // but cannot be allowed to lead to ambiguity.
               return true;
             } else if (!isElemental && actual.Rank() != x.type.Rank() &&
                 !x.type.attrs().test(
-                    characteristics::TypeAndShape::Attr::AssumedRank)) {
+                    characteristics::TypeAndShape::Attr::AssumedRank) &&
+                !x.ignoreTKR.test(common::IgnoreTKR::Rank)) {
               return false;
             } else if (auto actualType{actual.GetType()}) {
-              return x.type.type().IsTkCompatibleWith(*actualType);
+              return x.type.type().IsTkCompatibleWith(*actualType, x.ignoreTKR);
             }
             return false;
           },
           [&](const characteristics::DummyProcedure &) {
             return expr && IsProcedurePointerTarget(*expr);
           },
           [&](const characteristics::AlternateReturn &) {
             return actual.isAlternateReturn();

flang/lib/Semantics/symbol.cpp

llvm::raw_ostream &operator<<(
   os << *static_cast<const EntityDetails *>(&x);
   DumpList(os, "shape", x.shape());
   DumpList(os, "coshape", x.coshape());
   DumpExpr(os, "init", x.init_);
   if (x.unanalyzedPDTComponentInit()) {
     os << " (has unanalyzedPDTComponentInit)";
   }
   if (!x.ignoreTKR_.empty()) {
-    os << ' ';
-    x.ignoreTKR_.Dump(os, common::EnumToString);
+    x.ignoreTKR_.Dump(os << ' ', common::EnumToString);
   }
   return os;
 }
 
 llvm::raw_ostream &operator<<(
     llvm::raw_ostream &os, const AssocEntityDetails &x) {
   os << *static_cast<const EntityDetails *>(&x);
   if (auto assocRank{x.rank()}) {

flang/test/Semantics/ignore_tkr02.f90

+! RUN: %flang_fc1 -fdebug-unparse %s 2>&1 | FileCheck %s
+program main
+  interface generic
+    subroutine sub1(j, k)
+      integer(1) j
+      integer k
+      !dir$ ignore_tkr(kr) k
+    end
+    subroutine sub2(j, k)
+      integer(2) j
+      integer k
+      !dir$ ignore_tkr(kr) k
+    end
+    subroutine sub4(j, k)
+      integer(4) j
+      integer k
+      !dir$ ignore_tkr(kr) k
+    end
+  end interface
+!CHECK: CALL sub1(1_1,int(1_1,kind=4))
+  call generic(1_1,1_1)
+!CHECK: CALL sub1(1_1,int(1_2,kind=4))
+  call generic(1_1,1_2)
+!CHECK: CALL sub1(1_1,[INTEGER(1)::1_1])
+  call generic(1_1,[1_1])
+!CHECK: CALL sub2(1_2,int(1_1,kind=4))
+  call generic(1_2,1_1)
+!CHECK: CALL sub2(1_2,int(1_2,kind=4))
+  call generic(1_2,1_2)
+!CHECK: CALL sub2(1_2,[INTEGER(1)::1_1])
+  call generic(1_2,[1_1])
+!CHECK: CALL sub4(1_4,int(1_1,kind=4))
+  call generic(1_4,1_1)
+!CHECK: CALL sub4(1_4,int(1_2,kind=4))
+  call generic(1_4,1_2)
+!CHECK: CALL sub4(1_4,[INTEGER(1)::1_1])
+  call generic(1_4,[1_1])
+end