[flang] Disallow intrinsics and statement functions from generics

[klausler]

Summary

Generic interfaces are not permitted to have intrinsic procedures or
statement functions as specific procedures.

[PeteSteinfeld]

All builds and tests correctly and looks good.

flang/lib/Semantics/check-declarations.cpp

private:
   bool CheckDefinedOperator(
       SourceName, GenericKind, const Symbol &, const Procedure &);
   std::optional<parser::MessageFixedText> CheckNumberOfArgs(
       const GenericKind &, std::size_t);
   bool CheckDefinedOperatorArg(
       const SourceName &, const Symbol &, const Procedure &, std::size_t);
   bool CheckDefinedAssignment(const Symbol &, const Procedure &);
   bool CheckDefinedAssignmentArg(const Symbol &, const DummyArgument &, int);
-  void CheckSpecificsAreDistinguishable(const Symbol &, const GenericDetails &);
+  void CheckSpecifics(const Symbol &, const GenericDetails &);
   void CheckEquivalenceSet(const EquivalenceSet &);
   void CheckBlockData(const Scope &);
   void CheckGenericOps(const Scope &);
   bool CheckConflicting(const Symbol &, Attr, Attr);
   void WarnMissingFinal(const Symbol &);
   void CheckSymbolType(const Symbol &); // C702
   bool InPure() const {
     return innermostSymbol_ && IsPureProcedure(*innermostSymbol_);
if (details.implicitOrSpecExprError) {
       messages_.Say(
           "No explicit type declared for '%s'"_err_en_US, symbol.name());
     }
   }
 }
 
 void CheckHelper::CheckGeneric(
     const Symbol &symbol, const GenericDetails &details) {
-  CheckSpecificsAreDistinguishable(symbol, details);
+  CheckSpecifics(symbol, details);
   common::visit(common::visitors{
                     [&](const GenericKind::DefinedIo &io) {
                       CheckDefinedIoProc(symbol, details, io);
                     },
                     [&](const GenericKind::OtherKind &other) {
                       if (other == GenericKind::OtherKind::Name) {
                         CheckGenericVsIntrinsic(symbol, details);
                       }
                     },
                     [](const auto &) {},
                 },
       details.kind().u);
   // Ensure that shadowed symbols are checked
   if (details.specific()) {
     Check(*details.specific());
   }
   if (details.derivedType()) {
     Check(*details.derivedType());
   }
 }
 
 // Check that the specifics of this generic are distinguishable from each other
-void CheckHelper::CheckSpecificsAreDistinguishable(
+void CheckHelper::CheckSpecifics(
     const Symbol &generic, const GenericDetails &details) {
   GenericKind kind{details.kind()};
   DistinguishabilityHelper helper{context_};
   for (const Symbol &specific : details.specificProcs()) {
     if (specific.attrs().test(Attr::ABSTRACT)) {
       if (auto *msg{messages_.Say(generic.name(),
               "Generic interface '%s' must not use abstract interface '%s' as a specific procedure"_err_en_US,
               generic.name(), specific.name())}) {
         msg->Attach(
             specific.name(), "Definition of '%s'"_en_US, specific.name());
       }
+      continue;
+    }
+    if (specific.attrs().test(Attr::INTRINSIC)) {
+      if (auto *msg{messages_.Say(specific.name(),
+              "Specific procedure '%s' of generic interface '%s' may not be INTRINSIC"_err_en_US,
+              specific.name(), generic.name())}) {
+        msg->Attach(generic.name(), "Definition of '%s'"_en_US, generic.name());
+      }
+      continue;
+    }
+    if (IsStmtFunction(specific)) {
+      if (auto *msg{messages_.Say(specific.name(),
+              "Specific procedure '%s' of generic interface '%s' may not be a statement function"_err_en_US,
+              specific.name(), generic.name())}) {
+        msg->Attach(generic.name(), "Definition of '%s'"_en_US, generic.name());
+      }
+      continue;
     }
     if (const Procedure *procedure{Characterize(specific)}) {
       if (procedure->HasExplicitInterface()) {
         helper.Add(generic, kind, specific, *procedure);
       } else {
         if (auto *msg{messages_.Say(specific.name(),
                 "Specific procedure '%s' of generic interface '%s' must have an explicit interface"_err_en_US,
                 specific.name(), generic.name())}) {

flang/test/Semantics/generic06.f90

+! RUN: %python %S/test_errors.py %s %flang_fc1
+module m
+  !ERROR: Specific procedure 'sin' of generic interface 'yintercept' may not be INTRINSIC
+  intrinsic sin
+  interface yIntercept
+    procedure sin
+  end interface
+  !ERROR: Specific procedure 'cos' of generic interface 'xintercept' may not be INTRINSIC
+  intrinsic cos
+  generic :: xIntercept => cos
+end module
+
+subroutine foo
+  interface slope
+    procedure tan
+  end interface
+  !ERROR: Specific procedure 'tan' of generic interface 'slope' may not be a statement function
+  tan(x) = sin(x) / cos(x)
+end subroutine
+