Revert "[flang] Improve constant folding for type parameter inquiries"

This reverts commit 8c7bf2f.

Author: kiranchandramohan

flang/lib/Evaluate/fold-integer.cpp

@@ -658,43 +658,24 @@ Expr<Type<TypeCategory::Integer, KIND>> FoldIntrinsicFunction(
 // Substitute a bare type parameter reference with its value if it has one now
 Expr<TypeParamInquiry::Result> FoldOperation(
     FoldingContext &context, TypeParamInquiry &&inquiry) {
-  std::optional<NamedEntity> base{inquiry.base()};
-  parser::CharBlock parameterName{inquiry.parameter().name()};
-  if (base) {
-    // Handling "designator%typeParam".  Get the value of the type parameter
-    // from the instantiation of the base
-    if (const semantics::DeclTypeSpec *
-        declType{base->GetLastSymbol().GetType()}) {
-      const semantics::DerivedTypeSpec dType{declType->derivedTypeSpec()};
-      if (const semantics::ParamValue *
-          paramValue{dType.FindParameter(parameterName)}) {
-        const semantics::MaybeIntExpr &paramExpr{paramValue->GetExplicit()};
-        if (paramExpr && IsConstantExpr(*paramExpr)) {
-          Expr<SomeInteger> intExpr{*paramExpr};
-          return Fold(context,
-              ConvertToType<TypeParamInquiry::Result>(std::move(intExpr)));
-        }
-      }
-    }
-  } else {
+  if (!inquiry.base()) {
     // A "bare" type parameter: replace with its value, if that's now known.
     if (const auto *pdt{context.pdtInstance()}) {
       if (const semantics::Scope * scope{context.pdtInstance()->scope()}) {
-        auto iter{scope->find(parameterName)};
+        auto iter{scope->find(inquiry.parameter().name())};
         if (iter != scope->end()) {
           const Symbol &symbol{*iter->second};
           const auto *details{symbol.detailsIf<semantics::TypeParamDetails>()};
-          if (details) {
-            const semantics::MaybeIntExpr &initExpr{details->init()};
-            if (initExpr && IsConstantExpr(*initExpr)) {
-              Expr<SomeInteger> expr{*initExpr};
-              return Fold(context,
-                  ConvertToType<TypeParamInquiry::Result>(std::move(expr)));
-            }
+          if (details && details->init() &&
+              (details->attr() == common::TypeParamAttr::Kind ||
+                  IsConstantExpr(*details->init()))) {
+            Expr<SomeInteger> expr{*details->init()};
+            return Fold(context,
+                ConvertToType<TypeParamInquiry::Result>(std::move(expr)));
           }
         }
       }
-      if (const auto *value{pdt->FindParameter(parameterName)}) {
+      if (const auto *value{pdt->FindParameter(inquiry.parameter().name())}) {
         if (value->isExplicit()) {
           return Fold(context,
               AsExpr(ConvertToType<TypeParamInquiry::Result>(

flang/lib/Evaluate/formatting.cpp

@@ -614,7 +614,7 @@ llvm::raw_ostream &BaseObject::AsFortran(llvm::raw_ostream &o) const {
 
 llvm::raw_ostream &TypeParamInquiry::AsFortran(llvm::raw_ostream &o) const {
   if (base_) {
-    base_.value().AsFortran(o) << '%';
+    return base_->AsFortran(o) << '%';
   }
   return EmitVar(o, parameter_);
 }

flang/lib/Semantics/type.cpp

@@ -205,8 +205,7 @@ class InstantiateHelper {
   }
   void InstantiateComponent(const Symbol &);
   const DeclTypeSpec *InstantiateType(const Symbol &);
-  const DeclTypeSpec &InstantiateIntrinsicType(
-      SourceName, const DeclTypeSpec &);
+  const DeclTypeSpec &InstantiateIntrinsicType(const DeclTypeSpec &);
   DerivedTypeSpec CreateDerivedTypeSpec(const DerivedTypeSpec &, bool);
 
   SemanticsContext &context_;
@@ -365,7 +364,7 @@ const DeclTypeSpec *InstantiateHelper::InstantiateType(const Symbol &symbol) {
         CreateDerivedTypeSpec(*spec, symbol.test(Symbol::Flag::ParentComp)),
         context_, type->category());
   } else if (type->AsIntrinsic()) {
-    return &InstantiateIntrinsicType(symbol.name(), *type);
+    return &InstantiateIntrinsicType(*type);
   } else if (type->category() == DeclTypeSpec::ClassStar) {
     return type;
   } else {
@@ -375,7 +374,7 @@ const DeclTypeSpec *InstantiateHelper::InstantiateType(const Symbol &symbol) {
 
 // Apply type parameter values to an intrinsic type spec.
 const DeclTypeSpec &InstantiateHelper::InstantiateIntrinsicType(
-    SourceName symbolName, const DeclTypeSpec &spec) {
+    const DeclTypeSpec &spec) {
   const IntrinsicTypeSpec &intrinsic{DEREF(spec.AsIntrinsic())};
   if (evaluate::ToInt64(intrinsic.kind())) {
     return spec; // KIND is already a known constant
@@ -388,7 +387,7 @@ const DeclTypeSpec &InstantiateHelper::InstantiateIntrinsicType(
     if (evaluate::IsValidKindOfIntrinsicType(intrinsic.category(), *value)) {
       kind = *value;
     } else {
-      foldingContext().messages().Say(symbolName,
+      foldingContext().messages().Say(
           "KIND parameter value (%jd) of intrinsic type %s "
           "did not resolve to a supported value"_err_en_US,
           *value,

flang/test/Semantics/assign04.f90

@@ -8,7 +8,7 @@ subroutine s1
   type(t(1, 2)) :: x
   !ERROR: Assignment to constant 'x%k' is not allowed
   x%k = 4
-  !ERROR: Assignment to constant 'x%l' is not allowed
+  !ERROR: Left-hand side of assignment is not modifiable
   x%l = 3
 end
 

flang/test/Semantics/resolve104.f90

@@ -107,7 +107,7 @@ subroutine inner (derivedArg)
       type localDerivedType
         ! OK because the specification inquiry is a constant
         integer, dimension(localDerived%kindParam) :: goodField
-        ! OK because the value of lenParam is constant in this context
+        !ERROR: Invalid specification expression: non-constant reference to a type parameter inquiry not allowed for derived type components or type parameter values
         integer, dimension(derivedArg%lenParam) :: badField
       end type localDerivedType