[flang] Don't resolve names in derived type definitions to generics

[klausler]

Summary

There's code in name resolution that handles resolution of references
that appear in the definitions of derived types -- it checks for
existing components in the type being defined, as well as for
non-parent components in its ancestors. Special case code prevents
resolution of a name to the symbol of a procedure binding. This
code needs to be extended so that names of generic procedures
are similarly prevented from shadowing symbols in the scope around
the type.

[vzakhari]

@klausler is it possible to write a LIT test for this? Can you please add one?

[klausler]

In D134398#3807420, @vzakhari wrote:

@klausler is it possible to write a LIT test for this? Can you please add one?

I didn't think that this case merited one, but I'll extract one for you.

[klausler]

Add test.

[vzakhari]

Thank you for the test! If I understand it correctly, this allows resolving foo inside ext to the module's subroutine foo rather than to the generic identifier foo inside base.
LGTM

flang/lib/Semantics/resolve-names.cpp

 
 Symbol *ScopeHandler::FindSymbol(const parser::Name &name) {
   return FindSymbol(currScope(), name);
 }
 Symbol *ScopeHandler::FindSymbol(const Scope &scope, const parser::Name &name) {
   if (scope.IsDerivedType()) {
     if (Symbol * symbol{scope.FindComponent(name.source)}) {
       if (!symbol->has<ProcBindingDetails>() &&
+          !symbol->has<GenericDetails>() &&
           !symbol->test(Symbol::Flag::ParentComp)) {
         return Resolve(name, symbol);
       }
     }
     return FindSymbol(scope.parent(), name);
   } else {
     // In EQUIVALENCE statements only resolve names in the local scope, see
     // 19.5.1.4, paragraph 2, item (10)

flang/test/Semantics/symbol23.f90

+! RUN: %python %S/test_symbols.py %s %flang_fc1
+! Regression test of name resolution bug
+!DEF: /m Module
+module m
+ !DEF: /m/base ABSTRACT, PUBLIC DerivedType
+ type, abstract :: base
+ contains
+  !DEF: /m/base/foo Generic
+  !DEF: /m/base/spec DEFERRED ProcBinding
+  generic :: foo => spec
+  !DEF: /m/iface ABSTRACT, PUBLIC (Subroutine) Subprogram
+  !REF: /m/base/spec
+  procedure(iface), deferred :: spec
+ end type
+ abstract interface
+  !REF: /m/iface
+  !DEF: /m/iface/this ObjectEntity CLASS(base)
+  subroutine iface (this)
+   !REF: /m/base
+   import :: base
+   !REF: /m/base
+   !REF: /m/iface/this
+   class(base) :: this
+  end subroutine
+ end interface
+ !REF: /m/base
+ !DEF: /m/ext PUBLIC DerivedType
+ type, extends(base) :: ext
+ contains
+  !DEF: /m/ext/spec ProcBinding
+  !DEF: /m/foo PUBLIC (Subroutine) Subprogram
+  procedure :: spec => foo
+ end type
+contains
+ !REF: /m/foo
+ !DEF: /m/foo/this ObjectEntity CLASS(ext)
+ subroutine foo (this)
+  !REF: /m/ext
+  !REF: /m/foo/this
+  class(ext) :: this
+ end subroutine
+end module