[flang] Fix looping on LEN type parameter usage

[klausler]

Summary

When a LEN type parameter of one PDT is being used as the value
of a LEN type parameter in another PDT, expression rewriting can
loop infinitely due to an incorrect assumption that the same PDT's
parameters are being referenced.

Fixes LLVM bug https://github.com/llvm/llvm-project/issues/63198

[PeteSteinfeld]

All builds and tests correctly and looks good.

flang/include/flang/Evaluate/common.h

public:
   std::map<parser::CharBlock, ConstantSubscript> &impliedDos() {
     return impliedDos_;
   }
 
   common::Restorer<const semantics::DerivedTypeSpec *> WithPDTInstance(
       const semantics::DerivedTypeSpec &spec) {
     return common::ScopedSet(pdtInstance_, &spec);
   }
+  common::Restorer<const semantics::DerivedTypeSpec *> WithoutPDTInstance() {
+    return common::ScopedSet(pdtInstance_, nullptr);
+  }
 
 private:
   parser::ContextualMessages messages_;
   const common::IntrinsicTypeDefaultKinds &defaults_;
   const IntrinsicProcTable &intrinsics_;
   const TargetCharacteristics &targetCharacteristics_;
   const semantics::DerivedTypeSpec *pdtInstance_{nullptr};
   bool inModuleFile_{false};
   std::map<parser::CharBlock, ConstantSubscript> impliedDos_;
 };
 
 void RealFlagWarnings(FoldingContext &, const RealFlags &, const char *op);
 } // namespace Fortran::evaluate
 #endif // FORTRAN_EVALUATE_COMMON_H_

flang/lib/Evaluate/fold-integer.cpp

if (const semantics::DeclTypeSpec *
           Expr<SomeInteger> intExpr{*paramExpr};
           return Fold(context,
               ConvertToType<TypeParamInquiry::Result>(std::move(intExpr)));
         }
       }
     }
   } else {
     // A "bare" type parameter: replace with its value, if that's now known
-    // in a current derived type instantiation, for KIND type parameters.
+    // in a current derived type instantiation.
     if (const auto *pdt{context.pdtInstance()}) {
+      auto restorer{context.WithoutPDTInstance()}; // don't loop
       bool isLen{false};
-      if (const semantics::Scope * scope{context.pdtInstance()->scope()}) {
+      if (const semantics::Scope * scope{pdt->scope()}) {
         auto iter{scope->find(parameterName)};
         if (iter != scope->end()) {
           const Symbol &symbol{*iter->second};
           const auto *details{symbol.detailsIf<semantics::TypeParamDetails>()};
           if (details) {
             isLen = details->attr() == common::TypeParamAttr::Len;
             const semantics::MaybeIntExpr &initExpr{details->init()};
             if (initExpr && IsConstantExpr(*initExpr) &&

flang/test/Semantics/pdt01.f90

+! RUN: %python %S/test_errors.py %s %flang_fc1
+! Catch error instead of crashing with infinite recursion
+! when a LEN PDT from one type is being used to define a
+! LEN PDT in another type's instantiation.
+program main
+  type t1(lp)
+    integer, len :: lp
+  end type
+  type t2(lp)
+    integer, len :: lp
+    type(t1(lp)) :: c
+  end type
+  integer local
+  !ERROR: Invalid specification expression: reference to local entity 'local'
+  type(t2(local)) :: x
+end