[flang] Avoid infinite recursion in common block check

[luporl]

Summary

Don't call CheckCommonBlockDerivedType() recursively if the
derived type symbol is the same symbol that is already being
processed. This can happen when a component is a pointer of the
same type as its parent component, for instance.

Fixes #60230

[klausler]

Looks great to me; thanks for digging into this bug and coming up with a good fix. If you're feeling really ambitious, consider moving this whole common block checking task out of name resolution and into declaration checking (Semantics/check-declarations.cpp) which would be a more natural home for this code.

flang/lib/Semantics/resolve-names.cpp

5771–5778

Please always use braced initializers in semantics.

5772

s/method/member function/

[luporl]

Thanks for the quick review.

It seems that moving the common block checking task out of name resolution would require quite some work.
It's also unclear to me how to move this code out of DeclarationVisitor, that also has some functions related to name resolving.
And CheckCommonBlocks() is called by ResolveNamesVisitor::FinishSpecificationPart().
Maybe as a helper class, that would have to be exported by Semantics/check-declarations.h?

Anyway, I guess it's better to leave that for a future patch.

[luporl]

Address reviewer's comments.

flang/lib/Semantics/resolve-names.cpp

for (const auto &pair : *scope) {
         Say2(name,
             "Derived type variable '%s' may not appear in a COMMON block due to component with default initialization"_err_en_US,
             component.name(), "Component with default initialization"_en_US);
         return;
       }
       if (details) {
         if (const auto *type{details->type()}) {
           if (const auto *derived{type->AsDerived()}) {
-            CheckCommonBlockDerivedType(name, derived->typeSymbol());
+            const Symbol &derivedTypeSymbol{derived->typeSymbol()};
+            // Don't call this member function recursively if the derived type
+            // symbol is the same symbol that is already being processed.
+            // This can happen when a component is a pointer of the same type
+            // as its parent component, for instance.
+            if (derivedTypeSymbol != typeSymbol) {
+              CheckCommonBlockDerivedType(name, derivedTypeSymbol);
+            }
           }
         }
       }
     }
   }
 }
 
 bool DeclarationVisitor::HandleUnrestrictedSpecificIntrinsicFunction(