[flang] Warn about violations of an obscure requirement (15.6.4 p2)

[klausler]

Summary

The Fortran 2018 standard, perhaps as an attempt to prevent ambiguity
in older compilers, requires that a statement function appear in an
explicit type declaration statement if its name is also accessible
from a host scope. F18 processes the specification parts of inner
procedures first, so we don't need this requirement to prevent
ambiguity, and can only really check it retrospectively after name
resolution. Emit a portability warning when appropriate.

[PeteSteinfeld]

Aside from the typo in the document, all builds and tests correctly and looks good.

flang/docs/Extensions.md

90

"witha" should be "with a"

[klausler]

Fix a typo.

flang/docs/Extensions.md

* `-2147483648_4` is, strictly speaking, a non-conforming literal
   kind 4, because the grammar of Fortran expressions parses it as a
   negation of a literal constant, not a negative literal constant.
   This compiler accepts it with a portability warning.
 * Construct names like `loop` in `loop: do j=1,n` are defined to
   be "local identifiers" and should be distinct in the "inclusive
   scope" -- i.e., not scoped by `BLOCK` constructs.
   As most (but not all) compilers implement `BLOCK` scoping of construct
   names, so does f18, with a portability warning.
+* 15.6.4 paragraph 2 prohibits an implicitly typed statement function
+  from sharing the same name as a symbol in its scope's host, if it
+  has one.
+  We accept this usage with a portability warning.
 
 ## Extensions, deletions, and legacy features supported by default
 
 * Tabs in source
 * `<>` as synonym for `.NE.` and `/=`
 * `$` and `@` as legal characters in names
 * Initialization in type declaration statements using `/values/`
 * Kind specification with `*`, e.g. `REAL*4`

flang/lib/Semantics/check-declarations.cpp

if (error) {
         }
       }
     }
   }
   if (const MaybeExpr & stmtFunction{details.stmtFunction()}) {
     if (auto msg{evaluate::CheckStatementFunction(
             symbol, *stmtFunction, context_.foldingContext())}) {
       SayWithDeclaration(symbol, std::move(*msg));
+    } else if (details.result().flags().test(Symbol::Flag::Implicit)) {
+      // 15.6.4 p2 weird requirement
+      if (const Symbol *
+          host{symbol.owner().parent().FindSymbol(symbol.name())}) {
+        evaluate::AttachDeclaration(
+            messages_.Say(symbol.name(),
+                "An implicitly typed statement function should not appear when the same symbol is available in its host scope"_port_en_US),
+            *host);
+      }
     }
   }
   if (IsElementalProcedure(symbol)) {
     // See comment on the similar check in CheckProcEntity()
     if (details.isDummy()) {
       messages_.Say("A dummy procedure may not be ELEMENTAL"_err_en_US);
     } else {
       for (const Symbol *dummy : details.dummyArgs()) {

flang/test/Semantics/stmt-func01.f90

program main
   sf7(n) = explicit(n)
   real :: a(3) = [1., 2., 3.]
   !PORTABILITY: Statement function 'sf8' should not pass an array argument that is not a whole array
   sf8(n) = sum(a(1:2))
   sf8a(n) = sum(a) ! ok
   integer :: sf9
   !ERROR: Defining expression of statement function 'sf9' cannot be converted to its result type INTEGER(4)
   sf9(n) = "bad"
+  sf10 = 1.
  contains
   real function explicit(x,y)
     integer, intent(in) :: x
     integer, intent(in), optional :: y
     explicit = x
   end function
   pure function arr()
     real :: arr(2)
     arr = [1., 2.]
   end function
+  subroutine foo
+    !PORTABILITY: An implicitly typed statement function should not appear when the same symbol is available in its host scope
+    sf10(x) = 2.*x
+  end subroutine
 end