[flang] Warn about local names that are the same as their enclosing program unit

[klausler]

Summary

Modules, submodules, main programs, and BLOCK DATA subprograms have names
that cannot be used within their scope, so we allow those names to be
used for other entities in the scope. This might not be entirely
conformant with the language standard, so warn about it.

flang/docs/Extensions.md

* Fortran 2018 19.3.4p1: "A component name has the scope of its derived-type
   name is in its scope, and at least shadows any entity of the same name
   in the enclosing scope and might be read, thanks to the "also", to mean
   that a "bare" reference to the name could be used in a specification inquiry.
   However, most other compilers do not allow a component to shadow exterior
   symbols, much less appear in specification inquiries, and there are
   application codes that expect exterior symbols whose names match
   components to be visible in a derived-type definition's default initialization
   expressions, and so f18 follows that precedent.
+
+* 19.3.1p1 "Within its scope, a local identifier of an entity of class (1)
+  or class (4) shall not be the same as a global identifier used in that scope..."
+  is read so as to allow the name of a module, submodule, main program,
+  or `BLOCK DATA` subprogram to also be the name of an local entity in its
+  scope, with a portability warning, since that global name is not actually
+  capable of being "used" in its scope.

flang/lib/Semantics/check-declarations.cpp

for (const Scope &child : scope.children()) {
           messages_.Say(child.sourceRange(),
               "A source file cannot contain more than one main program"_err_en_US);
         }
       }
     }
     if (scope.kind() == Scope::Kind::BlockData) {
       CheckBlockData(scope);
     }
+    if (auto name{scope.GetName()}) {
+      auto iter{scope.find(*name)};
+      if (iter != scope.end()) {
+        const char *kind{nullptr};
+        switch (scope.kind()) {
+        case Scope::Kind::Module:
+          kind = scope.symbol()->get<ModuleDetails>().isSubmodule()
+              ? "submodule"
+              : "module";
+          break;
+        case Scope::Kind::MainProgram:
+          kind = "main program";
+          break;
+        case Scope::Kind::BlockData:
+          kind = "BLOCK DATA subprogram";
+          break;
+        default:;
+        }
+        if (kind) {
+          messages_.Say(iter->second->name(),
+              "Name '%s' declared in a %s should not have the same name as the %s"_port_en_US,
+              *name, kind, kind);
+        }
+      }
+    }
     CheckGenericOps(scope);
   }
 }
 
 void CheckHelper::CheckEquivalenceSet(const EquivalenceSet &set) {
   auto iter{
       std::find_if(set.begin(), set.end(), [](const EquivalenceObject &object) {
         return FindCommonBlockContaining(object.symbol) != nullptr;

flang/test/Semantics/OpenMP/omp-declare-target03.f90

 ! RUN: %python %S/../test_errors.py %s %flang_fc1 -fopenmp
 ! OpenMP Version 5.1
 ! Check OpenMP construct validity for the following directives:
 ! 2.14.7 Declare Target Directive
 
 module mod1
 end
 
 program main
   use mod1
 
   !ERROR: The module name or main program name cannot be in a DECLARE TARGET directive
   !$omp declare target (mod1)
 
+  !PORTABILITY: Name 'main' declared in a main program should not have the same name as the main program
   !ERROR: The module name or main program name cannot be in a DECLARE TARGET directive
   !$omp declare target (main)
 end

flang/test/Semantics/OpenMP/omp-threadprivate03.f90

 ! RUN: %python %S/../test_errors.py %s %flang_fc1 -fopenmp
 ! OpenMP Version 5.1
 ! Check OpenMP construct validity for the following directives:
 ! 2.21.2 Threadprivate Directive
 
 module mod1
 end
 
 program main
   use mod1
   integer, parameter :: i = 1
 
   !ERROR: The module name or main program name cannot be in a THREADPRIVATE directive
   !$omp threadprivate(mod1)
 
+  !PORTABILITY: Name 'main' declared in a main program should not have the same name as the main program
   !ERROR: The module name or main program name cannot be in a THREADPRIVATE directive
   !$omp threadprivate(main)
 
   !ERROR: The entity with PARAMETER attribute cannot be in a THREADPRIVATE directive
   !$omp threadprivate(i)
 
 contains
   subroutine sub()
     !ERROR: The procedure name cannot be in a THREADPRIVATE directive
     !$omp threadprivate(sub)
   end
 end

flang/test/Semantics/bind-c02.f90

module m
   !ERROR: Only variable and named common block can be in BIND statement
   bind(c) :: proc
   !ERROR: Only variable and named common block can be in BIND statement
   bind(c) :: pc1
 
   !ERROR: Only variable and named common block can be in BIND statement
   bind(c) :: sub
 
+  !PORTABILITY: Name 'm' declared in a module should not have the same name as the module
   bind(c) :: m ! no error for implicit type variable
 
   type my_type
     integer :: i
   end type
   !ERROR: Only variable and named common block can be in BIND statement
   bind(c) :: my_type
 

flang/test/Semantics/resolve05.f90

 ! RUN: %python %S/test_errors.py %s %flang_fc1
 program p
-  integer :: p ! this is ok
+  !PORTABILITY: Name 'p' declared in a main program should not have the same name as the main program
+  integer :: p
 end
 module m
-  integer :: m ! this is ok
+  !PORTABILITY: Name 'm' declared in a module should not have the same name as the module
+  integer :: m
 end
 submodule(m) sm
-  integer :: sm ! this is ok
+  !PORTABILITY: Name 'sm' declared in a submodule should not have the same name as the submodule
+  integer :: sm
+end
+block data bd
+  !PORTABILITY: Name 'bd' declared in a BLOCK DATA subprogram should not have the same name as the BLOCK DATA subprogram
+  type bd
+  end type
 end
 module m2
   type :: t
   end type
   interface
     subroutine s
       !ERROR: Module 'm2' cannot USE itself
       use m2, only: t

flang/test/Semantics/resolve20.f90

abstract interface
     end subroutine
   end interface
 
   real :: bad1(1)
   real :: bad2
   type :: bad3
   end type
 
-  type :: m ! the name of a module can be used as a local identifier
+  !PORTABILITY: Name 'm' declared in a module should not have the same name as the module
+  type :: m
   end type m
 
   !ERROR: EXTERNAL attribute was already specified on 'a'
   !ERROR: EXTERNAL attribute was already specified on 'b'
   !ERROR: EXTERNAL attribute was already specified on 'c'
   !ERROR: EXTERNAL attribute was already specified on 'd'
   external :: a, b, c, d
   !ERROR: EXTERNAL attribute not allowed on 'm'