[flang] Extend characterization & checking for procedure bindings

[klausler]

Summary

Procedure bindings with explicit interfaces don't work when the
interface is shadowed by a generic interface of the same name,
and can produce spurious semantic error messages. Extend the
characterization and checking code for such things, and the utility
functionns on which they depend, to dig through generics when they
occlude interface-defining subprograms. This is done on demand in
checking code, not once during name resolution, because the
procedures in question may also be forward-referenced.

[klausler]

Use updated clang-format.

[jeanPerier]

Clang Format is still unhappy after your formatting change:

changed files:
    flang/lib/Evaluate/characteristics.cpp
    flang/lib/Semantics/check-declarations.cpp
    flang/lib/Semantics/tools.cpp
ERROR   git-clang-format returned an non-zero exit code 1

Otherwise, the change looks good to me

[klausler]

Continue negotiations with clang-format.

flang/include/flang/Semantics/symbol.h

return common::visit(common::visitors{
                                return x.symbol().HasExplicitInterface();
                              },
                              [](const UseDetails &x) {
                                return x.symbol().HasExplicitInterface();
                              },
                              [](const HostAssocDetails &x) {
                                return x.symbol().HasExplicitInterface();
                              },
+                             [](const GenericDetails &x) {
+                               return x.specific() &&
+                                   x.specific()->HasExplicitInterface();
+                             },
                              [](const auto &) { return false; },
                          },
         details_);
   }
 
   bool operator==(const Symbol &that) const { return this == &that; }
   bool operator!=(const Symbol &that) const { return !(*this == that); }
 

flang/lib/Evaluate/characteristics.cpp

return common::visit(
               // declaration checking in Semantics.
               auto intrinsic{context.intrinsics().IsSpecificIntrinsicFunction(
                   symbol.name().ToString())};
               if (intrinsic && intrinsic->isRestrictedSpecific) {
                 intrinsic.reset(); // Exclude intrinsics from table 16.3.
               }
               return intrinsic;
             }
-            const semantics::ProcInterface &interface { proc.interface() };
+            const semantics::ProcInterface &interface {
+              proc.interface()
+            };
             if (const semantics::Symbol * interfaceSymbol{interface.symbol()}) {
               auto interface {
                 CharacterizeProcedure(*interfaceSymbol, context, seenProcs)
               };
               if (interface && IsPointer(symbol)) {
                 interface->attrs.reset(Procedure::Attr::Elemental);
               }
               return interface;
return common::visit(
           [](const semantics::UseErrorDetails &) {
             // Ambiguous use-association will be handled later during symbol
             // checks, ignore UseErrorDetails here without actual symbol usage.
             return std::optional<Procedure>{};
           },
           [&](const semantics::HostAssocDetails &assoc) {
             return CharacterizeProcedure(assoc.symbol(), context, seenProcs);
           },
+          [&](const semantics::GenericDetails &generic) {
+            if (const semantics::Symbol * specific{generic.specific()}) {
+              return CharacterizeProcedure(*specific, context, seenProcs);
+            } else {
+              return std::optional<Procedure>{};
+            }
+          },
           [&](const semantics::EntityDetails &) {
             context.messages().Say(
                 "Procedure '%s' is referenced before being sufficiently defined in a context where it must be so"_err_en_US,
                 symbol.name());
             return std::optional<Procedure>{};
           },
           [&](const semantics::SubprogramNameDetails &) {
             context.messages().Say(

flang/lib/Semantics/check-declarations.cpp

messages_.Say(
         "'%s' may not have the POINTER attribute because it is a coarray"_err_en_US,
         symbol.name());
   }
 }
 
 // C760 constraints on the passed-object dummy argument
 // C757 constraints on procedure pointer components
 void CheckHelper::CheckPassArg(
-    const Symbol &proc, const Symbol *interface, const WithPassArg &details) {
+    const Symbol &proc, const Symbol *interface0, const WithPassArg &details) {
   if (proc.attrs().test(Attr::NOPASS)) {
     return;
   }
   const auto &name{proc.name()};
+  const Symbol *interface {
+    interface0 ? FindInterface(*interface0) : nullptr
+  };
   if (!interface) {
     messages_.Say(name,
         "Procedure component '%s' must have NOPASS attribute or explicit interface"_err_en_US,
         name);
     return;
   }
   const auto *subprogram{interface->detailsIf<SubprogramDetails>()};
   if (!subprogram) {

flang/lib/Semantics/resolve-names.cpp

void DeclarationVisitor::Post(
   for (auto &declaration : x.declarations) {
     auto &bindingName{std::get<parser::Name>(declaration.t)};
     auto &optName{std::get<std::optional<parser::Name>>(declaration.t)};
     const parser::Name &procedureName{optName ? *optName : bindingName};
     Symbol *procedure{FindSymbol(procedureName)};
     if (!procedure) {
       procedure = NoteInterfaceName(procedureName);
     }
-    if (auto *s{MakeTypeSymbol(bindingName, ProcBindingDetails{*procedure})}) {
+    if (procedure) {
+      if (auto *s{
+              MakeTypeSymbol(bindingName, ProcBindingDetails{*procedure})}) {
         SetPassNameOn(*s);
         if (GetAttrs().test(Attr::DEFERRED)) {
           context().SetError(*s);
         }
       }
     }
   }
+}
 
 void DeclarationVisitor::CheckBindings(
     const parser::TypeBoundProcedureStmt::WithoutInterface &tbps) {
   CHECK(currScope().IsDerivedType());
   for (auto &declaration : tbps.declarations) {
     auto &bindingName{std::get<parser::Name>(declaration.t)};
     if (Symbol * binding{FindInScope(bindingName)}) {
       if (auto *details{binding->detailsIf<ProcBindingDetails>()}) {

flang/lib/Semantics/tools.cpp

const evaluate::Assignment *GetAssignment(
   return x.typedAssignment ? common::GetPtrFromOptional(x.typedAssignment->v)
                            : nullptr;
 }
 
 const Symbol *FindInterface(const Symbol &symbol) {
   return common::visit(
       common::visitors{
           [](const ProcEntityDetails &details) {
-            return details.interface().symbol();
+            const Symbol *interface {
+              details.interface().symbol()
+            };
+            return interface ? FindInterface(*interface) : nullptr;
+          },
+          [](const ProcBindingDetails &details) {
+            return FindInterface(details.symbol());
+          },
+          [&](const SubprogramDetails &) { return &symbol; },
+          [](const UseDetails &details) {
+            return FindInterface(details.symbol());
+          },
+          [](const HostAssocDetails &details) {
+            return FindInterface(details.symbol());
+          },
+          [](const GenericDetails &details) {
+            return details.specific() ? FindInterface(*details.specific())
+                                      : nullptr;
           },
-          [](const ProcBindingDetails &details) { return &details.symbol(); },
           [](const auto &) -> const Symbol * { return nullptr; },
       },
       symbol.details());
 }
 
 const Symbol *FindSubprogram(const Symbol &symbol) {
   return common::visit(
       common::visitors{
return common::visit(
           },
           [&](const SubprogramDetails &) { return &symbol; },
           [](const UseDetails &details) {
             return FindSubprogram(details.symbol());
           },
           [](const HostAssocDetails &details) {
             return FindSubprogram(details.symbol());
           },
+          [](const GenericDetails &details) {
+            return details.specific() ? FindSubprogram(*details.specific())
+                                      : nullptr;
+          },
           [](const auto &) -> const Symbol * { return nullptr; },
       },
       symbol.details());
 }
 
 const Symbol *FindOverriddenBinding(const Symbol &symbol) {
   if (symbol.has<ProcBindingDetails>()) {
     if (const DeclTypeSpec * parentType{FindParentTypeSpec(symbol.owner())}) {

flang/test/Semantics/resolve20.f90

module m
   parameter(foo=2)
   !ERROR: PARAMETER attribute not allowed on 'bar'
   parameter(bar=2)
 
   type, abstract :: t1
     integer :: i
   contains
     !ERROR: 'proc' must be an abstract interface or a procedure with an explicit interface
-    !ERROR: Procedure component 'p1' has invalid interface 'proc'
+    !ERROR: Procedure component 'p1' must have NOPASS attribute or explicit interface
     procedure(proc), deferred :: p1
   end type t1
 
   abstract interface
     function f()
     end function
   end interface