[flang] Ignore errors on declarations in interfaces that "have no effect"

[klausler]

Summary

Fortran strangely allows declarations to appear in procedure interface
definitions when those declarations do not contribute anything to the
characteristics of the procedure; in particular, one may declare local
variables that are neither dummy variables nor function results.
Such declarations "have no effect" on the semantics of the program,
and that should include semantic error checking for things like
special restrictions on PURE procedures.

[PeteSteinfeld]

Weird! All builds and tests correctly and looks good.

flang/lib/Semantics/check-declarations.cpp

bool InPure() const {
     return innermostSymbol_ && IsPureProcedure(*innermostSymbol_);
   }
   bool InElemental() const {
     return innermostSymbol_ && IsElementalProcedure(*innermostSymbol_);
   }
   bool InFunction() const {
     return innermostSymbol_ && IsFunction(*innermostSymbol_);
   }
+  bool InInterface() const {
+    const SubprogramDetails *subp{innermostSymbol_
+            ? innermostSymbol_->detailsIf<SubprogramDetails>()
+            : nullptr};
+    return subp && subp->isInterface();
+  }
   template <typename... A>
   void SayWithDeclaration(const Symbol &symbol, A &&...x) {
     if (parser::Message * msg{messages_.Say(std::forward<A>(x)...)}) {
       if (messages_.at().begin() != symbol.name().begin()) {
         evaluate::AttachDeclaration(*msg, symbol);
       }
     }
   }
void CheckHelper::Check(const Symbol &symbol) {
   CheckBindC(symbol);
   if (isDone) {
     return; // following checks do not apply
   }
   if (IsPointer(symbol)) {
     CheckPointer(symbol);
   }
   if (InPure()) {
+    if (InInterface()) {
+      // Declarations in interface definitions "have no effect" if they
+      // are not pertinent to the characteristics of the procedure.
+      // Restrictions on entities in pure procedure interfaces don't need
+      // enforcement.
+    } else {
       if (IsSaved(symbol)) {
         if (IsInitialized(symbol)) {
           messages_.Say(
               "A pure subprogram may not initialize a variable"_err_en_US);
         } else {
           messages_.Say(
               "A pure subprogram may not have a variable with the SAVE attribute"_err_en_US);
         }
       }
-    if (symbol.attrs().test(Attr::VOLATILE)) {
-      messages_.Say(
-          "A pure subprogram may not have a variable with the VOLATILE attribute"_err_en_US);
-    }
-    if (IsProcedure(symbol) && !IsPureProcedure(symbol) && IsDummy(symbol)) {
-      messages_.Say(
-          "A dummy procedure of a pure subprogram must be pure"_err_en_US);
-    }
       if (!IsDummy(symbol) && !IsFunctionResult(symbol)) {
         if (IsPolymorphicAllocatable(symbol)) {
           SayWithDeclaration(symbol,
               "Deallocation of polymorphic object '%s' is not permitted in a pure subprogram"_err_en_US,
               symbol.name());
         } else if (derived) {
           if (auto bad{FindPolymorphicAllocatableUltimateComponent(*derived)}) {
             SayWithDeclaration(*bad,
                 "Deallocation of polymorphic object '%s%s' is not permitted in a pure subprogram"_err_en_US,
                 symbol.name(), bad.BuildResultDesignatorName());
           }
         }
       }
     }
+    if (symbol.attrs().test(Attr::VOLATILE) &&
+        (IsDummy(symbol) || !InInterface())) {
+      messages_.Say(
+          "A pure subprogram may not have a variable with the VOLATILE attribute"_err_en_US);
+    }
+    if (IsProcedure(symbol) && !IsPureProcedure(symbol) && IsDummy(symbol)) {
+      messages_.Say(
+          "A dummy procedure of a pure subprogram must be pure"_err_en_US);
+    }
+  }
   if (type) { // Section 7.2, paragraph 7
     bool canHaveAssumedParameter{IsNamedConstant(symbol) ||
         (IsAssumedLengthCharacter(symbol) && // C722
             IsExternal(symbol)) ||
         symbol.test(Symbol::Flag::ParentComp)};
     if (!IsStmtFunctionDummy(symbol)) { // C726
       if (const auto *object{symbol.detailsIf<ObjectEntityDetails>()}) {
         canHaveAssumedParameter |= object->isDummy() ||

flang/test/Semantics/call10.f90

module m
   type :: t
   end type
   type :: polyAlloc
     class(t), allocatable :: a
   end type
 
   real, volatile, target :: volatile
 
+  interface
+    ! Ensure no errors for "ignored" declarations in a pure interface.
+    ! These declarations do not contribute to the characteristics of
+    ! the procedure and must not elicit spurious errors about being used
+    ! in a pure procedure.
+    pure subroutine s05a
+      import polyAlloc
+      real, save :: v1
+      real :: v2 = 0.
+      real :: v3
+      data v3/0./
+      real :: v4
+      common /blk/ v4
+      save /blk/
+      type(polyAlloc) :: v5
+      real, volatile :: v6
+    end subroutine
+  end interface
+
  contains
 
   subroutine impure(x)
     type(impureFinal) :: x
   end subroutine
   integer impure function notpure(n)
     integer, value :: n
     notpure = n