[flang] Make `TypeParamInquiry` monomorphic

[klausler]

Summary

Change the expression representation TypeParamInquiry from being
a class that's templatized on the integer KIND of its result into
a monomorphic representation that results in a SubscriptInteger
that can then be converted.

This is a minor simplification, but it's worth doing because
it is believed to also be a work-around for bugs in the MSVC
compiler with overload resolution that affect the expression
traversal framework.

[klausler]

ping

[Meinersbur]

As much as I can say without having a lot of experience with the flang codebase, this looks good to me.

Thanks for the effort!

flang/include/flang/Evaluate/expression.h

 private:
   using Conversions = std::tuple<Convert<Result, TypeCategory::Integer>,
       Convert<Result, TypeCategory::Real>>;
   using Operations = std::tuple<Parentheses<Result>, Negate<Result>,
       Add<Result>, Subtract<Result>, Multiply<Result>, Divide<Result>,
       Power<Result>, Extremum<Result>>;
   using Indices = std::conditional_t<KIND == ImpliedDoIndex::Result::kind,
       std::tuple<ImpliedDoIndex>, std::tuple<>>;
+  using TypeParamInquiries =
+      std::conditional_t<KIND == TypeParamInquiry::Result::kind,
+          std::tuple<TypeParamInquiry>, std::tuple<>>;
   using DescriptorInquiries =
       std::conditional_t<KIND == DescriptorInquiry::Result::kind,
           std::tuple<DescriptorInquiry>, std::tuple<>>;
   using Others = std::tuple<Constant<Result>, ArrayConstructor<Result>,
-      TypeParamInquiry<KIND>, Designator<Result>, FunctionRef<Result>>;
+      Designator<Result>, FunctionRef<Result>>;
 
 public:
   common::TupleToVariant<common::CombineTuples<Operations, Conversions, Indices,
-      DescriptorInquiries, Others>>
+      TypeParamInquiries, DescriptorInquiries, Others>>
       u;
 };
 
 template <int KIND>
 class Expr<Type<TypeCategory::Real, KIND>>
     : public ExpressionBase<Type<TypeCategory::Real, KIND>> {
 public:
   using Result = Type<TypeCategory::Real, KIND>;

flang/include/flang/Evaluate/shape.h

 public:
   using Result = std::optional<Shape>;
   using Base = AnyTraverse<GetShapeHelper, Result>;
   using Base::operator();
   explicit GetShapeHelper(FoldingContext &c) : Base{*this}, context_{c} {}
 
   Result operator()(const ImpliedDoIndex &) const { return Scalar(); }
   Result operator()(const DescriptorInquiry &) const { return Scalar(); }
-  template <int KIND> Result operator()(const TypeParamInquiry<KIND> &) const {
-    return Scalar();
-  }
+  Result operator()(const TypeParamInquiry &) const { return Scalar(); }
   Result operator()(const BOZLiteralConstant &) const { return Scalar(); }
   Result operator()(const StaticDataObject::Pointer &) const {
     return Scalar();
   }
   Result operator()(const StructureConstructor &) const { return Scalar(); }
 
   template <typename T> Result operator()(const Constant<T> &c) const {
     return AsShape(c.SHAPE());

flang/include/flang/Evaluate/traverse.h

public:
   }
   Result operator()(const NamedEntity &x) const {
     if (const Component * component{x.UnwrapComponent()}) {
       return visitor_(*component);
     } else {
       return visitor_(x.GetFirstSymbol());
     }
   }
-  template <int KIND> Result operator()(const TypeParamInquiry<KIND> &x) const {
+  Result operator()(const TypeParamInquiry &x) const {
     return visitor_(x.base());
   }
   Result operator()(const Triplet &x) const {
     return Combine(x.lower(), x.upper(), x.stride());
   }
   Result operator()(const Subscript &x) const { return visitor_(x.u); }
   Result operator()(const ArrayRef &x) const {
     return Combine(x.base(), x.subscript());

flang/include/flang/Evaluate/variable.h

 // N.B. x%LEN for CHARACTER is rewritten in semantics to LEN(x), which is
 // then handled via LEN() member functions in the various classes;
 // it becomes a DescriptorInquiry with Field::Len for assumed-length
 // CHARACTER objects.
 // x%KIND for intrinsic types is similarly rewritten in semantics to
 // KIND(x), which is then folded to a constant value.
 // "Bare" type parameter references within a derived type definition do
 // not have base objects.
-template <int KIND> class TypeParamInquiry {
+class TypeParamInquiry {
 public:
-  using Result = Type<TypeCategory::Integer, KIND>;
+  using Result = SubscriptInteger;
   CLASS_BOILERPLATE(TypeParamInquiry)
   TypeParamInquiry(NamedEntity &&x, const Symbol &param)
       : base_{std::move(x)}, parameter_{param} {}
   TypeParamInquiry(std::optional<NamedEntity> &&x, const Symbol &param)
       : base_{std::move(x)}, parameter_{param} {}
 
   const std::optional<NamedEntity> &base() const { return base_; }
   std::optional<NamedEntity> &base() { return base_; }
   const Symbol &parameter() const { return parameter_; }
 
   static constexpr int Rank() { return 0; } // always scalar
   bool operator==(const TypeParamInquiry &) const;
   llvm::raw_ostream &AsFortran(llvm::raw_ostream &) const;
 
 private:
   std::optional<NamedEntity> base_;
   SymbolRef parameter_;
 };
 
-EXPAND_FOR_EACH_INTEGER_KIND(
-    TEMPLATE_INSTANTIATION, extern template class TypeParamInquiry, )
-
 // R921 subscript-triplet
 class Triplet {
 public:
   Triplet();
   DEFAULT_CONSTRUCTORS_AND_ASSIGNMENTS(Triplet)
   Triplet(std::optional<Expr<SubscriptInteger>> &&,
       std::optional<Expr<SubscriptInteger>> &&,
       std::optional<Expr<SubscriptInteger>> &&);

 
 private:
   NamedEntity base_;
   Field field_;
   int dimension_{0}; // zero-based
 };
 
 #define INSTANTIATE_VARIABLE_TEMPLATES \
-  EXPAND_FOR_EACH_INTEGER_KIND( \
-      TEMPLATE_INSTANTIATION, template class TypeParamInquiry, ) \
   FOR_EACH_SPECIFIC_TYPE(template class Designator, )
 } // namespace Fortran::evaluate
 #endif // FORTRAN_EVALUATE_VARIABLE_H_

flang/lib/Evaluate/check-expression.cpp

 // the expression may reference derived type kind parameters whose values
 // are not yet known.
 class IsConstantExprHelper : public AllTraverse<IsConstantExprHelper, true> {
 public:
   using Base = AllTraverse<IsConstantExprHelper, true>;
   IsConstantExprHelper() : Base{*this} {}
   using Base::operator();
 
-  template <int KIND> bool operator()(const TypeParamInquiry<KIND> &inq) const {
+  bool operator()(const TypeParamInquiry &inq) const {
     return IsKindTypeParameter(inq.parameter());
   }
   bool operator()(const semantics::Symbol &symbol) const {
     const auto &ultimate{symbol.GetUltimate()};
     return IsNamedConstant(ultimate) || IsImpliedDoIndex(ultimate) ||
         IsInitialProcedureTarget(ultimate);
   }
   bool operator()(const CoarrayRef &) const { return false; }
if (IsAllocatable(ultimate)) {
             ultimate.name());
         emittedMessage_ = true;
       }
       return false;
     }
     return true;
   }
   bool operator()(const StaticDataObject &) const { return false; }
-  template <int KIND> bool operator()(const TypeParamInquiry<KIND> &) const {
-    return false;
-  }
+  bool operator()(const TypeParamInquiry &) const { return false; }
   bool operator()(const Triplet &x) const {
     return IsConstantExpr(x.lower()) && IsConstantExpr(x.upper()) &&
         IsConstantExpr(x.stride());
   }
   bool operator()(const Subscript &x) const {
     return std::visit(common::visitors{
                           [&](const Triplet &t) { return (*this)(t); },
                           [&](const auto &y) {
public:
   }
   Result operator()(const DescriptorInquiry &) const {
     // Subtle: Uses of SIZE(), LBOUND(), &c. that are valid in specification
     // expressions will have been converted to expressions over descriptor
     // inquiries by Fold().
     return std::nullopt;
   }
 
-  template <int KIND>
-  Result operator()(const TypeParamInquiry<KIND> &inq) const {
+  Result operator()(const TypeParamInquiry &inq) const {
     if (scope_.IsDerivedType() && !IsConstantExpr(inq) &&
         inq.parameter().owner() != scope_) { // C750, C754
       return "non-constant reference to a type parameter inquiry not "
              "allowed for derived type components or type parameter values";
     }
     return std::nullopt;
   }
 

flang/lib/Evaluate/fold-implementation.h

 Expr<Type<TypeCategory::Logical, KIND>> FoldIntrinsicFunction(
     FoldingContext &context, FunctionRef<Type<TypeCategory::Logical, KIND>> &&);
 
 template <typename T>
 Expr<T> FoldOperation(FoldingContext &context, Designator<T> &&designator) {
   return Folder<T>{context}.Folding(std::move(designator));
 }
 
-template <int KIND>
-Expr<Type<TypeCategory::Integer, KIND>> FoldOperation(
-    FoldingContext &, TypeParamInquiry<KIND> &&);
+Expr<TypeParamInquiry::Result> FoldOperation(
+    FoldingContext &, TypeParamInquiry &&);
 Expr<ImpliedDoIndex::Result> FoldOperation(
     FoldingContext &context, ImpliedDoIndex &&);
 template <typename T>
 Expr<T> FoldOperation(FoldingContext &, ArrayConstructor<T> &&);
 Expr<SomeDerived> FoldOperation(FoldingContext &, StructureConstructor &&);
 
 template <typename T>
 std::optional<Expr<T>> Folder<T>::GetNamedConstantValue(const Symbol &symbol0) {

flang/lib/Evaluate/fold-integer.cpp

Expr<Type<TypeCategory::Integer, KIND>> FoldIntrinsicFunction(
   // findloc, iall, iany, iparity, ibits, image_status, ishftc,
   // matmul, maxloc, maxval,
   // minloc, minval, not, pack, product, reduce,
   // sign, spread, sum, transfer, transpose, unpack
   return Expr<T>{std::move(funcRef)};
 }
 
 // Substitute a bare type parameter reference with its value if it has one now
-template <int KIND>
-Expr<Type<TypeCategory::Integer, KIND>> FoldOperation(
-    FoldingContext &context, TypeParamInquiry<KIND> &&inquiry) {
-  using IntKIND = Type<TypeCategory::Integer, KIND>;
+Expr<TypeParamInquiry::Result> FoldOperation(
+    FoldingContext &context, TypeParamInquiry &&inquiry) {
   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(inquiry.parameter().name())};
         if (iter != scope->end()) {
           const Symbol &symbol{*iter->second};
           const auto *details{symbol.detailsIf<semantics::TypeParamDetails>()};
           if (details && details->init() &&
               (details->attr() == common::TypeParamAttr::Kind ||
                   IsConstantExpr(*details->init()))) {
             Expr<SomeInteger> expr{*details->init()};
             return Fold(context,
-                Expr<IntKIND>{
-                    Convert<IntKIND, TypeCategory::Integer>(std::move(expr))});
+                ConvertToType<TypeParamInquiry::Result>(std::move(expr)));
           }
         }
       }
       if (const auto *value{pdt->FindParameter(inquiry.parameter().name())}) {
         if (value->isExplicit()) {
           return Fold(context,
-              Expr<IntKIND>{Convert<IntKIND, TypeCategory::Integer>(
-                  Expr<SomeInteger>{value->GetExplicit().value()})});
+              AsExpr(ConvertToType<TypeParamInquiry::Result>(
+                  Expr<SomeInteger>{value->GetExplicit().value()})));
         }
       }
     }
   }
-  return Expr<IntKIND>{std::move(inquiry)};
+  return AsExpr(std::move(inquiry));
 }
 
 std::optional<std::int64_t> ToInt64(const Expr<SomeInteger> &expr) {
   return std::visit(
       [](const auto &kindExpr) { return ToInt64(kindExpr); }, expr.u);
 }
 
 std::optional<std::int64_t> ToInt64(const Expr<SomeType> &expr) {

flang/lib/Evaluate/formatting.cpp

llvm::raw_ostream &EmitVar(llvm::raw_ostream &o, const std::variant<A...> &u) {
   std::visit([&](const auto &x) { EmitVar(o, x); }, u);
   return o;
 }
 
 llvm::raw_ostream &BaseObject::AsFortran(llvm::raw_ostream &o) const {
   return EmitVar(o, u);
 }
 
-template <int KIND>
-llvm::raw_ostream &TypeParamInquiry<KIND>::AsFortran(
-    llvm::raw_ostream &o) const {
+llvm::raw_ostream &TypeParamInquiry::AsFortran(llvm::raw_ostream &o) const {
   if (base_) {
     return base_->AsFortran(o) << '%';
   }
   return EmitVar(o, parameter_);
 }
 
 llvm::raw_ostream &Component::AsFortran(llvm::raw_ostream &o) const {
   base_.value().AsFortran(o);

flang/lib/Evaluate/variable.cpp

 bool NamedEntity::operator==(const NamedEntity &that) const {
   if (IsSymbol()) {
     return that.IsSymbol() &&
         AreSameSymbol(GetFirstSymbol(), that.GetFirstSymbol());
   } else {
     return !that.IsSymbol() && GetComponent() == that.GetComponent();
   }
 }
-template <int KIND>
-bool TypeParamInquiry<KIND>::operator==(
-    const TypeParamInquiry<KIND> &that) const {
+bool TypeParamInquiry::operator==(const TypeParamInquiry &that) const {
   return &*parameter_ == &*that.parameter_ && base_ == that.base_;
 }
 bool Triplet::operator==(const Triplet &that) const {
   return lower_ == that.lower_ && upper_ == that.upper_ &&
       stride_ == that.stride_;
 }
 bool Subscript::operator==(const Subscript &that) const { return u == that.u; }
 bool ArrayRef::operator==(const ArrayRef &that) const {

flang/lib/Lower/ConvertType.cpp

public:
   }
 
 private:
   //===--------------------------------------------------------------------===//
   // Generate type helpers
   //===--------------------------------------------------------------------===//
 
   mlir::Type gen(const Fortran::evaluate::ImpliedDoIndex &) {
-    return genFIRType<Fortran::common::TypeCategory::Integer>(
-        context, defaultKind<Fortran::common::TypeCategory::Integer>());
+    return genFIRType<Fortran::evaluate::ImpliedDoIndex::Result::category>(
+        context, Fortran::evaluate::ImpliedDoIndex::Result::kind);
   }
 
-  template <int KIND>
-  mlir::Type gen(const Fortran::evaluate::TypeParamInquiry<KIND> &) {
-    return genFIRType<Fortran::common::TypeCategory::Integer, KIND>(context);
+  mlir::Type gen(const Fortran::evaluate::TypeParamInquiry &) {
+    return genFIRType<Fortran::evaluate::TypeParamInquiry::Result::category>(
+        context, Fortran::evaluate::TypeParamInquiry::Result::kind);
   }
 
   template <typename A>
   mlir::Type gen(const Fortran::evaluate::Relational<A> &) {
     return genFIRType<Fortran::common::TypeCategory::Logical, 1>(context);
   }
 
   // some sequence of `n` bytes

flang/lib/Semantics/expression.cpp

MaybeExpr ExpressionAnalyzer::Analyze(const parser::BOZLiteralConstant &x) {
   }
   if (value.overflow) {
     Say("BOZ literal '%s' too large"_err_en_US, x.v);
     return std::nullopt;
   }
   return AsGenericExpr(std::move(value.value));
 }
 
-// For use with SearchTypes to create a TypeParamInquiry with the
-// right integer kind.
-struct TypeParamInquiryVisitor {
-  using Result = std::optional<Expr<SomeInteger>>;
-  using Types = IntegerTypes;
-  TypeParamInquiryVisitor(int k, NamedEntity &&b, const Symbol &param)
-      : kind{k}, base{std::move(b)}, parameter{param} {}
-  TypeParamInquiryVisitor(int k, const Symbol &param)
-      : kind{k}, parameter{param} {}
-  template <typename T> Result Test() {
-    if (kind == T::kind) {
-      return Expr<SomeInteger>{
-          Expr<T>{TypeParamInquiry<T::kind>{std::move(base), parameter}}};
-    }
-    return std::nullopt;
-  }
-  int kind;
-  std::optional<NamedEntity> base;
-  const Symbol &parameter;
-};
-
-static std::optional<Expr<SomeInteger>> MakeBareTypeParamInquiry(
-    const Symbol *symbol) {
-  if (std::optional<DynamicType> dyType{DynamicType::From(symbol)}) {
-    if (dyType->category() == TypeCategory::Integer) {
-      return common::SearchTypes(
-          TypeParamInquiryVisitor{dyType->kind(), *symbol});
-    }
-  }
-  return std::nullopt;
-}
-
 // Names and named constants
 MaybeExpr ExpressionAnalyzer::Analyze(const parser::Name &n) {
   if (std::optional<int> kind{IsImpliedDo(n.source)}) {
     return AsMaybeExpr(ConvertToKind<TypeCategory::Integer>(
         *kind, AsExpr(ImpliedDoIndex{n.source})));
   } else if (context_.HasError(n)) {
     return std::nullopt;
   } else if (!n.symbol) {
     SayAt(n, "Internal error: unresolved name '%s'"_err_en_US, n.source);
     return std::nullopt;
   } else {
     const Symbol &ultimate{n.symbol->GetUltimate()};
     if (ultimate.has<semantics::TypeParamDetails>()) {
       // A bare reference to a derived type parameter (within a parameterized
       // derived type definition)
-      return AsMaybeExpr(MakeBareTypeParamInquiry(&ultimate));
+      return Fold(ConvertToType(
+          ultimate, AsGenericExpr(TypeParamInquiry{std::nullopt, ultimate})));
     } else {
       if (n.symbol->attrs().test(semantics::Attr::VOLATILE)) {
         if (const semantics::Scope *
             pure{semantics::FindPureProcedureContaining(
                 context_.FindScope(n.source))}) {
           SayAt(n,
               "VOLATILE variable '%s' may not be referenced in pure subprogram '%s'"_err_en_US,
               n.source, DEREF(pure->symbol()).name());
MaybeExpr ExpressionAnalyzer::Analyze(const parser::StructureComponent &sc) {
   }
   const auto &name{sc.component.source};
   if (auto *dtExpr{UnwrapExpr<Expr<SomeDerived>>(*base)}) {
     const auto *dtSpec{GetDerivedTypeSpec(dtExpr->GetType())};
     if (sym->detailsIf<semantics::TypeParamDetails>()) {
       if (auto *designator{UnwrapExpr<Designator<SomeDerived>>(*dtExpr)}) {
         if (std::optional<DynamicType> dyType{DynamicType::From(*sym)}) {
           if (dyType->category() == TypeCategory::Integer) {
-            return AsMaybeExpr(
-                common::SearchTypes(TypeParamInquiryVisitor{dyType->kind(),
-                    IgnoreAnySubscripts(std::move(*designator)), *sym}));
+            return Fold(ConvertToType(*dyType,
+                AsGenericExpr(TypeParamInquiry{
+                    IgnoreAnySubscripts(std::move(*designator)), *sym})));
           }
         }
         Say(name, "Type parameter is not INTEGER"_err_en_US);
       } else {
         Say(name,
             "A type parameter inquiry must be applied to "
             "a designator"_err_en_US);
       }

flang/test/Semantics/kinds03.f90

 ! RUN: %S/test_symbols.sh %s %t %f18
  !DEF: /MainProgram1/ipdt DerivedType
  !DEF: /MainProgram1/ipdt/k TypeParam INTEGER(4)
  type :: ipdt(k)
   !REF: /MainProgram1/ipdt/k
   integer, kind :: k
   !REF: /MainProgram1/ipdt/k
-  !DEF: /MainProgram1/ipdt/x ObjectEntity INTEGER(int(k,kind=8))
+  !DEF: /MainProgram1/ipdt/x ObjectEntity INTEGER(int(int(k,kind=4),kind=8))
   integer(kind=k) :: x
  end type ipdt
  !DEF: /MainProgram1/rpdt DerivedType
  !DEF: /MainProgram1/rpdt/k TypeParam INTEGER(4)
  type :: rpdt(k)
   !REF: /MainProgram1/rpdt/k
   integer, kind :: k
   !REF: /MainProgram1/rpdt/k
-  !DEF: /MainProgram1/rpdt/x ObjectEntity REAL(int(k,kind=8))
+  !DEF: /MainProgram1/rpdt/x ObjectEntity REAL(int(int(k,kind=4),kind=8))
   real(kind=k) :: x
  end type rpdt
  !DEF: /MainProgram1/zpdt DerivedType
  !DEF: /MainProgram1/zpdt/k TypeParam INTEGER(4)
  type :: zpdt(k)
   !REF: /MainProgram1/zpdt/k
   integer, kind :: k
   !REF: /MainProgram1/zpdt/k
-  !DEF: /MainProgram1/zpdt/x ObjectEntity COMPLEX(int(k,kind=8))
+  !DEF: /MainProgram1/zpdt/x ObjectEntity COMPLEX(int(int(k,kind=4),kind=8))
   complex(kind=k) :: x
  end type zpdt
  !DEF: /MainProgram1/lpdt DerivedType
  !DEF: /MainProgram1/lpdt/k TypeParam INTEGER(4)
  type :: lpdt(k)
   !REF: /MainProgram1/lpdt/k
   integer, kind :: k
   !REF: /MainProgram1/lpdt/k
-  !DEF: /MainProgram1/lpdt/x ObjectEntity LOGICAL(int(k,kind=8))
+  !DEF: /MainProgram1/lpdt/x ObjectEntity LOGICAL(int(int(k,kind=4),kind=8))
   logical(kind=k) :: x
  end type lpdt
  !REF: /MainProgram1/ipdt
  !DEF: /MainProgram1/i1 ObjectEntity TYPE(ipdt(k=1_4))
  type(ipdt(1)) :: i1
  !REF: /MainProgram1/ipdt
  !DEF: /MainProgram1/i2 ObjectEntity TYPE(ipdt(k=2_4))
  type(ipdt(2)) :: i2

flang/test/Semantics/modfile17.f90

 
 !Expect: m.mod
 !module m
 !type::capture(k1,k2,k4,k8)
 !integer(1),kind::k1
 !integer(2),kind::k2
 !integer(4),kind::k4
 !integer(8),kind::k8
-!integer(int(k1,kind=8))::j1
-!integer(int(k2,kind=8))::j2
-!integer(int(k4,kind=8))::j4
+!integer(int(int(k1,kind=1),kind=8))::j1
+!integer(int(int(k2,kind=2),kind=8))::j2
+!integer(int(int(k4,kind=4),kind=8))::j4
 !integer(k8)::j8
 !end type
 !type::defaulted(n1,n2,n4,n8)
 !integer(1),kind::n1=1_1
-!integer(2),kind::n2=int(int(n1,kind=4)*2_4,kind=2)
-!integer(4),kind::n4=2_4*int(n2,kind=4)
-!integer(8),kind::n8=int(12_4-n4,kind=8)
-!type(capture(k1=n1,k2=n2,k4=n4,k8=n8))::cap
+!integer(2),kind::n2=int(int(int(n1,kind=1),kind=4)*2_4,kind=2)
+!integer(4),kind::n4=2_4*int(int(n2,kind=2),kind=4)
+!integer(8),kind::n8=int(12_4-int(n4,kind=4),kind=8)
+!type(capture(k1=int(n1,kind=1),k2=int(n2,kind=2),k4=int(n4,kind=4),k8=n8))::cap
 !end type
 !type,extends(defaulted)::extension(k5)
 !integer(4),kind::k5=4_4
-!integer(int(k5,kind=8))::j5
+!integer(int(int(k5,kind=4),kind=8))::j5
 !end type
 !type(capture(k1=1_1,k2=1_2,k4=1_4,k8=1_8))::x1111
 !integer(1)::res01_1
 !integer(1)::res02_1
 !integer(1)::res03_1
 !integer(1)::res04_1
 !type(capture(k1=8_1,k2=8_2,k4=8_4,k8=8_8))::x8888
 !integer(8)::res05_8

flang/test/Semantics/modfile22.f90

 type(t), parameter :: p = t(k=1)(a='xx',b='xx')
 character(len=2), parameter :: c2(3) = [character(len=2) :: 'x', 'xx', 'xxx']
 end module m
 
 !Expect: m.mod
 !module m
 !type::t(k)
 !integer(4),kind::k=1_4
-!character(1_4,int(k,kind=8))::a
-!character(3_4,int(k,kind=8))::b
+!character(1_4,int(int(k,kind=4),kind=8))::a
+!character(3_4,int(int(k,kind=4),kind=8))::b
 !end type
 !type(t(k=1_4)),parameter::p=t(k=1_4)(a="x",b="xx ")
 !character(2_4,1),parameter::c2(1_8:3_8)=[CHARACTER(KIND=1,LEN=2)::"x ","xx","xx"]
 !end

flang/test/Semantics/modfile33.f90

subroutine s2(x, y, z)
     real :: z(x + y)  ! resolves to f2
   end
 end
 
 !Expect: m7.mod
 !module m7
 ! type :: t(k)
 !  integer(4), kind :: k
-!  real(int(k, kind=8)) :: a
+!  real(int(int(k,kind=4),kind=8))::a
 ! end type
 ! interface operator(+)
 !  procedure :: f1
 !  procedure :: f2
 ! end interface
 ! interface
 !  pure function f1(x, y)
 !   import :: t

flang/test/Semantics/symbol17.f90

 !DEF: /f2/n (Implicit) ObjectEntity INTEGER(4)
 type(fwdpdt(kind(0))) function f2(n)
  !REF: /f2/fwdpdt
  !DEF: /f2/fwdpdt/k TypeParam INTEGER(4)
  type :: fwdpdt(k)
   !REF: /f2/fwdpdt/k
   integer, kind :: k
   !REF: /f2/fwdpdt/k
-  !DEF: /f2/fwdpdt/n ObjectEntity INTEGER(int(k,kind=8))
+  !DEF: /f2/fwdpdt/n ObjectEntity INTEGER(int(int(k,kind=4),kind=8))
   integer(kind=k) :: n
  end type
  !DEF: /f2/f2 ObjectEntity TYPE(fwdpdt(k=4_4))
  !DEF: /f2/DerivedType2/n ObjectEntity INTEGER(4)
  !REF: /f2/n
  f2%n = n
 end function
 !DEF: /s2 (Subroutine) Subprogram
 !DEF: /s2/q1 (Implicit) ObjectEntity TYPE(fwdpdt(k=4_4))
 subroutine s2 (q1)
  !DEF: /s2/fwdpdt DerivedType
  !DEF: /s2/kind INTRINSIC (Function) ProcEntity
  implicit type(fwdpdt(kind(0)))(q)
  !REF: /s2/fwdpdt
  !DEF: /s2/fwdpdt/k TypeParam INTEGER(4)
  type :: fwdpdt(k)
   !REF: /s2/fwdpdt/k
   integer, kind :: k
   !REF: /s2/fwdpdt/k
-  !DEF: /s2/fwdpdt/n ObjectEntity INTEGER(int(k,kind=8))
+  !DEF: /s2/fwdpdt/n ObjectEntity INTEGER(int(int(k,kind=4),kind=8))
   integer(kind=k) :: n
  end type
  !REF: /s2/q1
  !DEF: /s2/DerivedType2/n ObjectEntity INTEGER(4)
  q1%n = 1
 end subroutine
 !DEF: /m1 Module
 module m1