[flang] Error message situation should be a warning

[klausler]

Summary

f18 emits an error message when the same name is used in a scope
for both a procedure and a generic interface, and the procedure is
not a specific procedure of the generic interface. It may be
questionable usage, and not portable, but it does not appear to
be non-conforming by a strict reading of the standard, and many
popular Fortran compilers accept it.

flang/docs/Extensions.md

 end subroutine
 ```
 
   Other Fortran compilers disagree with each other in their interpretations
   of this example.
   The precedent among the most commonly used compilers
   agrees with f18's interpretation: a `DATA` statement without any other
   specification of the name refers to the host-associated object.
+
+* Many Fortran compilers allow a non-generic procedure to be `USE`-associated
+  into a scope that also contains a generic interface of the same name
+  but does not have the `USE`-associated non-generic procedure as a
+  specific procedure.
+```
+module m1
+ contains
+  subroutine foo(n)
+    integer, intent(in) :: n
+  end subroutine
+end module
+
+module m2
+  use m1, only: foo
+  interface foo
+    module procedure noargs
+  end interface
+ contains
+  subroutine noargs
+  end subroutine
+end module
+```
+
+  This case elicits a warning from f18, as it should not be treated
+  any differently than the same case with the non-generic procedure of
+  the same name being defined in the same scope rather than being
+  `USE`-associated into it, which is explicitly non-conforming in the
+  standard and not allowed by most other compilers.
+  If the `USE`-associated entity of the same name is not a procedure,
+  most compilers disallow it as well.

flang/lib/Semantics/resolve-names.cpp

 // Check that the specific procedures are all functions or all subroutines.
 // If there is a derived type with the same name they must be functions.
 // Set the corresponding flag on generic.
 void InterfaceVisitor::CheckGenericProcedures(Symbol &generic) {
   ResolveSpecificsInGeneric(generic);
   auto &details{generic.get<GenericDetails>()};
   if (auto *proc{details.CheckSpecific()}) {
     auto msg{
-        "'%s' may not be the name of both a generic interface and a"
-        " procedure unless it is a specific procedure of the generic"_err_en_US};
+        "'%s' should not be the name of both a generic interface and a"
+        " procedure unless it is a specific procedure of the generic"_warn_en_US};
     if (proc->name().begin() > generic.name().begin()) {
       Say(proc->name(), std::move(msg));
     } else {
       Say(generic.name(), std::move(msg));
     }
   }
   auto &specifics{details.specificProcs()};
   if (specifics.empty()) {

flang/test/Semantics/resolve17.f90

 ! RUN: %python %S/test_errors.py %s %flang_fc1
 module m
   integer :: foo
   !Note: PGI, Intel, and GNU allow this; NAG and Sun do not
   !ERROR: 'foo' is already declared in this scoping unit
   interface foo
   end interface
 end module
 
 module m2
   interface s
   end interface
 contains
-  !ERROR: 's' may not be the name of both a generic interface and a procedure unless it is a specific procedure of the generic
+  !WARNING: 's' should not be the name of both a generic interface and a procedure unless it is a specific procedure of the generic
   subroutine s
   end subroutine
 end module
 
 module m3
   ! This is okay: s is generic and specific
   interface s
     procedure s2

flang/test/Semantics/resolve18.f90

 ! RUN: %python %S/test_errors.py %s %flang_fc1
 module m1
   implicit none
 contains
   subroutine foo(x)
     real :: x
   end subroutine
 end module
 
 !Note: PGI, Intel, GNU, and NAG allow this; Sun does not
 module m2
   use m1
   implicit none
-  !ERROR: 'foo' may not be the name of both a generic interface and a procedure unless it is a specific procedure of the generic
+  !WARNING: 'foo' should not be the name of both a generic interface and a procedure unless it is a specific procedure of the generic
   interface foo
     module procedure s
   end interface
 contains
   subroutine s(i)
     integer :: i
   end subroutine
 end module