xref: /llvm-project/flang/lib/Lower/ConvertType.cpp (revision 4ccd57ddb11e833f6b2ec2188e73c4ef3a5ab80e)
1 //===-- ConvertType.cpp ---------------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "flang/Lower/ConvertType.h"
10 #include "flang/Lower/AbstractConverter.h"
11 #include "flang/Lower/CallInterface.h"
12 #include "flang/Lower/ConvertVariable.h"
13 #include "flang/Lower/Mangler.h"
14 #include "flang/Lower/PFTBuilder.h"
15 #include "flang/Lower/Support/Utils.h"
16 #include "flang/Optimizer/Builder/Todo.h"
17 #include "flang/Optimizer/Dialect/FIRType.h"
18 #include "flang/Semantics/tools.h"
19 #include "flang/Semantics/type.h"
20 #include "mlir/IR/Builders.h"
21 #include "mlir/IR/BuiltinTypes.h"
22 #include "llvm/Support/Debug.h"
23 
24 #define DEBUG_TYPE "flang-lower-type"
25 
26 using Fortran::common::VectorElementCategory;
27 
28 //===--------------------------------------------------------------------===//
29 // Intrinsic type translation helpers
30 //===--------------------------------------------------------------------===//
31 
32 static mlir::Type genRealType(mlir::MLIRContext *context, int kind) {
33   if (Fortran::evaluate::IsValidKindOfIntrinsicType(
34           Fortran::common::TypeCategory::Real, kind)) {
35     switch (kind) {
36     case 2:
37       return mlir::FloatType::getF16(context);
38     case 3:
39       return mlir::FloatType::getBF16(context);
40     case 4:
41       return mlir::FloatType::getF32(context);
42     case 8:
43       return mlir::FloatType::getF64(context);
44     case 10:
45       return mlir::FloatType::getF80(context);
46     case 16:
47       return mlir::FloatType::getF128(context);
48     }
49   }
50   llvm_unreachable("REAL type translation not implemented");
51 }
52 
53 template <int KIND>
54 int getIntegerBits() {
55   return Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer,
56                                  KIND>::Scalar::bits;
57 }
58 static mlir::Type genIntegerType(mlir::MLIRContext *context, int kind,
59                                  bool isUnsigned = false) {
60   if (Fortran::evaluate::IsValidKindOfIntrinsicType(
61           Fortran::common::TypeCategory::Integer, kind)) {
62     mlir::IntegerType::SignednessSemantics signedness =
63         (isUnsigned ? mlir::IntegerType::SignednessSemantics::Unsigned
64                     : mlir::IntegerType::SignednessSemantics::Signless);
65 
66     switch (kind) {
67     case 1:
68       return mlir::IntegerType::get(context, getIntegerBits<1>(), signedness);
69     case 2:
70       return mlir::IntegerType::get(context, getIntegerBits<2>(), signedness);
71     case 4:
72       return mlir::IntegerType::get(context, getIntegerBits<4>(), signedness);
73     case 8:
74       return mlir::IntegerType::get(context, getIntegerBits<8>(), signedness);
75     case 16:
76       return mlir::IntegerType::get(context, getIntegerBits<16>(), signedness);
77     }
78   }
79   llvm_unreachable("INTEGER kind not translated");
80 }
81 
82 static mlir::Type genLogicalType(mlir::MLIRContext *context, int KIND) {
83   if (Fortran::evaluate::IsValidKindOfIntrinsicType(
84           Fortran::common::TypeCategory::Logical, KIND))
85     return fir::LogicalType::get(context, KIND);
86   return {};
87 }
88 
89 static mlir::Type genCharacterType(
90     mlir::MLIRContext *context, int KIND,
91     Fortran::lower::LenParameterTy len = fir::CharacterType::unknownLen()) {
92   if (Fortran::evaluate::IsValidKindOfIntrinsicType(
93           Fortran::common::TypeCategory::Character, KIND))
94     return fir::CharacterType::get(context, KIND, len);
95   return {};
96 }
97 
98 static mlir::Type genComplexType(mlir::MLIRContext *context, int KIND) {
99   if (Fortran::evaluate::IsValidKindOfIntrinsicType(
100           Fortran::common::TypeCategory::Complex, KIND))
101     return fir::ComplexType::get(context, KIND);
102   return {};
103 }
104 
105 static mlir::Type
106 genFIRType(mlir::MLIRContext *context, Fortran::common::TypeCategory tc,
107            int kind,
108            llvm::ArrayRef<Fortran::lower::LenParameterTy> lenParameters) {
109   switch (tc) {
110   case Fortran::common::TypeCategory::Real:
111     return genRealType(context, kind);
112   case Fortran::common::TypeCategory::Integer:
113     return genIntegerType(context, kind);
114   case Fortran::common::TypeCategory::Complex:
115     return genComplexType(context, kind);
116   case Fortran::common::TypeCategory::Logical:
117     return genLogicalType(context, kind);
118   case Fortran::common::TypeCategory::Character:
119     if (!lenParameters.empty())
120       return genCharacterType(context, kind, lenParameters[0]);
121     return genCharacterType(context, kind);
122   default:
123     break;
124   }
125   llvm_unreachable("unhandled type category");
126 }
127 
128 //===--------------------------------------------------------------------===//
129 // Symbol and expression type translation
130 //===--------------------------------------------------------------------===//
131 
132 /// TypeBuilderImpl translates expression and symbol type taking into account
133 /// their shape and length parameters. For symbols, attributes such as
134 /// ALLOCATABLE or POINTER are reflected in the fir type.
135 /// It uses evaluate::DynamicType and evaluate::Shape when possible to
136 /// avoid re-implementing type/shape analysis here.
137 /// Do not use the FirOpBuilder from the AbstractConverter to get fir/mlir types
138 /// since it is not guaranteed to exist yet when we lower types.
139 namespace {
140 struct TypeBuilderImpl {
141 
142   TypeBuilderImpl(Fortran::lower::AbstractConverter &converter)
143       : converter{converter}, context{&converter.getMLIRContext()} {}
144 
145   template <typename A>
146   mlir::Type genExprType(const A &expr) {
147     std::optional<Fortran::evaluate::DynamicType> dynamicType = expr.GetType();
148     if (!dynamicType)
149       return genTypelessExprType(expr);
150     Fortran::common::TypeCategory category = dynamicType->category();
151 
152     mlir::Type baseType;
153     bool isPolymorphic = (dynamicType->IsPolymorphic() ||
154                           dynamicType->IsUnlimitedPolymorphic()) &&
155                          !dynamicType->IsAssumedType();
156     if (dynamicType->IsUnlimitedPolymorphic()) {
157       baseType = mlir::NoneType::get(context);
158     } else if (category == Fortran::common::TypeCategory::Derived) {
159       baseType = genDerivedType(dynamicType->GetDerivedTypeSpec());
160     } else {
161       // LOGICAL, INTEGER, REAL, COMPLEX, CHARACTER
162       llvm::SmallVector<Fortran::lower::LenParameterTy> params;
163       translateLenParameters(params, category, expr);
164       baseType = genFIRType(context, category, dynamicType->kind(), params);
165     }
166     std::optional<Fortran::evaluate::Shape> shapeExpr =
167         Fortran::evaluate::GetShape(converter.getFoldingContext(), expr);
168     fir::SequenceType::Shape shape;
169     if (shapeExpr) {
170       translateShape(shape, std::move(*shapeExpr));
171     } else {
172       // Shape static analysis cannot return something useful for the shape.
173       // Use unknown extents.
174       int rank = expr.Rank();
175       if (rank < 0)
176         TODO(converter.getCurrentLocation(), "assumed rank expression types");
177       for (int dim = 0; dim < rank; ++dim)
178         shape.emplace_back(fir::SequenceType::getUnknownExtent());
179     }
180 
181     if (!shape.empty()) {
182       if (isPolymorphic)
183         return fir::ClassType::get(fir::SequenceType::get(shape, baseType));
184       return fir::SequenceType::get(shape, baseType);
185     }
186     if (isPolymorphic)
187       return fir::ClassType::get(baseType);
188     return baseType;
189   }
190 
191   template <typename A>
192   void translateShape(A &shape, Fortran::evaluate::Shape &&shapeExpr) {
193     for (Fortran::evaluate::MaybeExtentExpr extentExpr : shapeExpr) {
194       fir::SequenceType::Extent extent = fir::SequenceType::getUnknownExtent();
195       if (std::optional<std::int64_t> constantExtent =
196               toInt64(std::move(extentExpr)))
197         extent = *constantExtent;
198       shape.push_back(extent);
199     }
200   }
201 
202   template <typename A>
203   std::optional<std::int64_t> toInt64(A &&expr) {
204     return Fortran::evaluate::ToInt64(Fortran::evaluate::Fold(
205         converter.getFoldingContext(), std::move(expr)));
206   }
207 
208   template <typename A>
209   mlir::Type genTypelessExprType(const A &expr) {
210     fir::emitFatalError(converter.getCurrentLocation(), "not a typeless expr");
211   }
212 
213   mlir::Type genTypelessExprType(const Fortran::lower::SomeExpr &expr) {
214     return std::visit(
215         Fortran::common::visitors{
216             [&](const Fortran::evaluate::BOZLiteralConstant &) -> mlir::Type {
217               return mlir::NoneType::get(context);
218             },
219             [&](const Fortran::evaluate::NullPointer &) -> mlir::Type {
220               return fir::ReferenceType::get(mlir::NoneType::get(context));
221             },
222             [&](const Fortran::evaluate::ProcedureDesignator &proc)
223                 -> mlir::Type {
224               return Fortran::lower::translateSignature(proc, converter);
225             },
226             [&](const Fortran::evaluate::ProcedureRef &) -> mlir::Type {
227               return mlir::NoneType::get(context);
228             },
229             [](const auto &x) -> mlir::Type {
230               using T = std::decay_t<decltype(x)>;
231               static_assert(!Fortran::common::HasMember<
232                                 T, Fortran::evaluate::TypelessExpression>,
233                             "missing typeless expr handling");
234               llvm::report_fatal_error("not a typeless expression");
235             },
236         },
237         expr.u);
238   }
239 
240   mlir::Type genSymbolType(const Fortran::semantics::Symbol &symbol,
241                            bool isAlloc = false, bool isPtr = false) {
242     mlir::Location loc = converter.genLocation(symbol.name());
243     mlir::Type ty;
244     // If the symbol is not the same as the ultimate one (i.e, it is host or use
245     // associated), all the symbol properties are the ones of the ultimate
246     // symbol but the volatile and asynchronous attributes that may differ. To
247     // avoid issues with helper functions that would not follow association
248     // links, the fir type is built based on the ultimate symbol. This relies
249     // on the fact volatile and asynchronous are not reflected in fir types.
250     const Fortran::semantics::Symbol &ultimate = symbol.GetUltimate();
251     if (Fortran::semantics::IsProcedurePointer(ultimate))
252       TODO(loc, "procedure pointers");
253     if (const Fortran::semantics::DeclTypeSpec *type = ultimate.GetType()) {
254       if (const Fortran::semantics::IntrinsicTypeSpec *tySpec =
255               type->AsIntrinsic()) {
256         int kind = toInt64(Fortran::common::Clone(tySpec->kind())).value();
257         llvm::SmallVector<Fortran::lower::LenParameterTy> params;
258         translateLenParameters(params, tySpec->category(), ultimate);
259         ty = genFIRType(context, tySpec->category(), kind, params);
260       } else if (type->IsPolymorphic() &&
261                  !converter.getLoweringOptions().getPolymorphicTypeImpl()) {
262         // TODO is kept under experimental flag until feature is complete.
263         TODO(loc, "support for polymorphic types");
264       } else if (type->IsUnlimitedPolymorphic()) {
265         ty = mlir::NoneType::get(context);
266       } else if (const Fortran::semantics::DerivedTypeSpec *tySpec =
267                      type->AsDerived()) {
268         ty = genDerivedType(*tySpec);
269       } else {
270         fir::emitFatalError(loc, "symbol's type must have a type spec");
271       }
272     } else {
273       fir::emitFatalError(loc, "symbol must have a type");
274     }
275     bool isPolymorphic = (Fortran::semantics::IsPolymorphic(symbol) ||
276                           Fortran::semantics::IsUnlimitedPolymorphic(symbol)) &&
277                          !Fortran::semantics::IsAssumedType(symbol);
278     if (ultimate.IsObjectArray()) {
279       auto shapeExpr =
280           Fortran::evaluate::GetShape(converter.getFoldingContext(), ultimate);
281       if (!shapeExpr)
282         TODO(loc, "assumed rank symbol type");
283       fir::SequenceType::Shape shape;
284       translateShape(shape, std::move(*shapeExpr));
285       ty = fir::SequenceType::get(shape, ty);
286     }
287     if (Fortran::semantics::IsPointer(symbol))
288       return fir::wrapInClassOrBoxType(fir::PointerType::get(ty),
289                                        isPolymorphic);
290     if (Fortran::semantics::IsAllocatable(symbol))
291       return fir::wrapInClassOrBoxType(fir::HeapType::get(ty), isPolymorphic);
292     // isPtr and isAlloc are variable that were promoted to be on the
293     // heap or to be pointers, but they do not have Fortran allocatable
294     // or pointer semantics, so do not use box for them.
295     if (isPtr)
296       return fir::PointerType::get(ty);
297     if (isAlloc)
298       return fir::HeapType::get(ty);
299     if (isPolymorphic)
300       return fir::ClassType::get(ty);
301     return ty;
302   }
303 
304   /// Does \p component has non deferred lower bounds that are not compile time
305   /// constant 1.
306   static bool componentHasNonDefaultLowerBounds(
307       const Fortran::semantics::Symbol &component) {
308     if (const auto *objDetails =
309             component.detailsIf<Fortran::semantics::ObjectEntityDetails>())
310       for (const Fortran::semantics::ShapeSpec &bounds : objDetails->shape())
311         if (auto lb = bounds.lbound().GetExplicit())
312           if (auto constant = Fortran::evaluate::ToInt64(*lb))
313             if (!constant || *constant != 1)
314               return true;
315     return false;
316   }
317 
318   mlir::Type genVectorType(const Fortran::semantics::DerivedTypeSpec &tySpec) {
319     assert(tySpec.scope() && "Missing scope for Vector type");
320     auto vectorSize{tySpec.scope()->size()};
321     switch (tySpec.category()) {
322       SWITCH_COVERS_ALL_CASES
323     case (Fortran::semantics::DerivedTypeSpec::Category::IntrinsicVector): {
324       int64_t vecElemKind;
325       int64_t vecElemCategory;
326 
327       for (const auto &pair : tySpec.parameters()) {
328         if (pair.first == "element_category") {
329           vecElemCategory =
330               Fortran::evaluate::ToInt64(pair.second.GetExplicit())
331                   .value_or(-1);
332         } else if (pair.first == "element_kind") {
333           vecElemKind =
334               Fortran::evaluate::ToInt64(pair.second.GetExplicit()).value_or(0);
335         }
336       }
337 
338       assert((vecElemCategory >= 0 &&
339               static_cast<size_t>(vecElemCategory) <
340                   Fortran::common::VectorElementCategory_enumSize) &&
341              "Vector element type is not specified");
342       assert(vecElemKind && "Vector element kind is not specified");
343 
344       int64_t numOfElements = vectorSize / vecElemKind;
345       switch (static_cast<VectorElementCategory>(vecElemCategory)) {
346         SWITCH_COVERS_ALL_CASES
347       case VectorElementCategory::Integer:
348         return fir::VectorType::get(numOfElements,
349                                     genIntegerType(context, vecElemKind));
350       case VectorElementCategory::Unsigned:
351         return fir::VectorType::get(numOfElements,
352                                     genIntegerType(context, vecElemKind, true));
353       case VectorElementCategory::Real:
354         return fir::VectorType::get(numOfElements,
355                                     genRealType(context, vecElemKind));
356       }
357       break;
358     }
359     case (Fortran::semantics::DerivedTypeSpec::Category::PairVector):
360     case (Fortran::semantics::DerivedTypeSpec::Category::QuadVector):
361       return fir::VectorType::get(vectorSize * 8,
362                                   mlir::IntegerType::get(context, 1));
363     case (Fortran::semantics::DerivedTypeSpec::Category::DerivedType):
364       Fortran::common::die("Vector element type not implemented");
365     }
366   }
367 
368   mlir::Type genDerivedType(const Fortran::semantics::DerivedTypeSpec &tySpec) {
369     std::vector<std::pair<std::string, mlir::Type>> ps;
370     std::vector<std::pair<std::string, mlir::Type>> cs;
371     const Fortran::semantics::Symbol &typeSymbol = tySpec.typeSymbol();
372     if (mlir::Type ty = getTypeIfDerivedAlreadyInConstruction(typeSymbol))
373       return ty;
374 
375     if (tySpec.IsVectorType()) {
376       return genVectorType(tySpec);
377     }
378 
379     auto rec = fir::RecordType::get(context, converter.mangleName(tySpec));
380     // Maintain the stack of types for recursive references.
381     derivedTypeInConstruction.emplace_back(typeSymbol, rec);
382 
383     // Gather the record type fields.
384     // (1) The data components.
385     for (const auto &component :
386          Fortran::semantics::OrderedComponentIterator(tySpec)) {
387       // Lowering is assuming non deferred component lower bounds are always 1.
388       // Catch any situations where this is not true for now.
389       if (!converter.getLoweringOptions().getLowerToHighLevelFIR() &&
390           componentHasNonDefaultLowerBounds(component))
391         TODO(converter.genLocation(component.name()),
392              "derived type components with non default lower bounds");
393       if (IsProcedure(component))
394         TODO(converter.genLocation(component.name()), "procedure components");
395       mlir::Type ty = genSymbolType(component);
396       // Do not add the parent component (component of the parents are
397       // added and should be sufficient, the parent component would
398       // duplicate the fields). Note that genSymbolType must be called above on
399       // it so that the dispatch table for the parent type still gets emitted
400       // as needed.
401       if (component.test(Fortran::semantics::Symbol::Flag::ParentComp))
402         continue;
403       cs.emplace_back(converter.getRecordTypeFieldName(component), ty);
404     }
405 
406     mlir::Location loc = converter.genLocation(typeSymbol.name());
407     // (2) The LEN type parameters.
408     for (const auto &param :
409          Fortran::semantics::OrderParameterDeclarations(typeSymbol))
410       if (param->get<Fortran::semantics::TypeParamDetails>().attr() ==
411           Fortran::common::TypeParamAttr::Len) {
412         TODO(loc, "parameterized derived types");
413         // TODO: emplace in ps. Beware that param is the symbol in the type
414         // declaration, not instantiation: its kind may not be a constant.
415         // The instantiated symbol in tySpec.scope should be used instead.
416         ps.emplace_back(param->name().ToString(), genSymbolType(*param));
417       }
418 
419     rec.finalize(ps, cs);
420     popDerivedTypeInConstruction();
421 
422     if (!ps.empty()) {
423       // TODO: this type is a PDT (parametric derived type) with length
424       // parameter. Create the functions to use for allocation, dereferencing,
425       // and address arithmetic here.
426     }
427     LLVM_DEBUG(llvm::dbgs() << "derived type: " << rec << '\n');
428 
429     // Generate the type descriptor object if any
430     if (const Fortran::semantics::Scope *derivedScope =
431             tySpec.scope() ? tySpec.scope() : tySpec.typeSymbol().scope())
432       if (const Fortran::semantics::Symbol *typeInfoSym =
433               derivedScope->runtimeDerivedTypeDescription())
434         converter.registerTypeInfo(loc, *typeInfoSym, tySpec, rec);
435     return rec;
436   }
437 
438   // To get the character length from a symbol, make an fold a designator for
439   // the symbol to cover the case where the symbol is an assumed length named
440   // constant and its length comes from its init expression length.
441   template <int Kind>
442   fir::SequenceType::Extent
443   getCharacterLengthHelper(const Fortran::semantics::Symbol &symbol) {
444     using TC =
445         Fortran::evaluate::Type<Fortran::common::TypeCategory::Character, Kind>;
446     auto designator = Fortran::evaluate::Fold(
447         converter.getFoldingContext(),
448         Fortran::evaluate::Expr<TC>{Fortran::evaluate::Designator<TC>{symbol}});
449     if (auto len = toInt64(std::move(designator.LEN())))
450       return *len;
451     return fir::SequenceType::getUnknownExtent();
452   }
453 
454   template <typename T>
455   void translateLenParameters(
456       llvm::SmallVectorImpl<Fortran::lower::LenParameterTy> &params,
457       Fortran::common::TypeCategory category, const T &exprOrSym) {
458     if (category == Fortran::common::TypeCategory::Character)
459       params.push_back(getCharacterLength(exprOrSym));
460     else if (category == Fortran::common::TypeCategory::Derived)
461       TODO(converter.getCurrentLocation(), "derived type length parameters");
462   }
463   Fortran::lower::LenParameterTy
464   getCharacterLength(const Fortran::semantics::Symbol &symbol) {
465     const Fortran::semantics::DeclTypeSpec *type = symbol.GetType();
466     if (!type ||
467         type->category() != Fortran::semantics::DeclTypeSpec::Character ||
468         !type->AsIntrinsic())
469       llvm::report_fatal_error("not a character symbol");
470     int kind =
471         toInt64(Fortran::common::Clone(type->AsIntrinsic()->kind())).value();
472     switch (kind) {
473     case 1:
474       return getCharacterLengthHelper<1>(symbol);
475     case 2:
476       return getCharacterLengthHelper<2>(symbol);
477     case 4:
478       return getCharacterLengthHelper<4>(symbol);
479     }
480     llvm_unreachable("unknown character kind");
481   }
482 
483   template <typename A>
484   Fortran::lower::LenParameterTy getCharacterLength(const A &expr) {
485     return fir::SequenceType::getUnknownExtent();
486   }
487 
488   template <typename T>
489   Fortran::lower::LenParameterTy
490   getCharacterLength(const Fortran::evaluate::FunctionRef<T> &funcRef) {
491     if (auto constantLen = toInt64(funcRef.LEN()))
492       return *constantLen;
493     return fir::SequenceType::getUnknownExtent();
494   }
495 
496   Fortran::lower::LenParameterTy
497   getCharacterLength(const Fortran::lower::SomeExpr &expr) {
498     // Do not use dynamic type length here. We would miss constant
499     // lengths opportunities because dynamic type only has the length
500     // if it comes from a declaration.
501     if (const auto *charExpr = std::get_if<
502             Fortran::evaluate::Expr<Fortran::evaluate::SomeCharacter>>(
503             &expr.u)) {
504       if (auto constantLen = toInt64(charExpr->LEN()))
505         return *constantLen;
506     } else if (auto dynamicType = expr.GetType()) {
507       // When generating derived type type descriptor as structure constructor,
508       // semantics wraps designators to data component initialization into
509       // CLASS(*), regardless of their actual type.
510       // GetType() will recover the actual symbol type as the dynamic type, so
511       // getCharacterLength may be reached even if expr is packaged as an
512       // Expr<SomeDerived> instead of an Expr<SomeChar>.
513       // Just use the dynamic type here again to retrieve the length.
514       if (auto constantLen = toInt64(dynamicType->GetCharLength()))
515         return *constantLen;
516     }
517     return fir::SequenceType::getUnknownExtent();
518   }
519 
520   mlir::Type genVariableType(const Fortran::lower::pft::Variable &var) {
521     return genSymbolType(var.getSymbol(), var.isHeapAlloc(), var.isPointer());
522   }
523 
524   /// Derived type can be recursive. That is, pointer components of a derived
525   /// type `t` have type `t`. This helper returns `t` if it is already being
526   /// lowered to avoid infinite loops.
527   mlir::Type getTypeIfDerivedAlreadyInConstruction(
528       const Fortran::lower::SymbolRef derivedSym) const {
529     for (const auto &[sym, type] : derivedTypeInConstruction)
530       if (sym == derivedSym)
531         return type;
532     return {};
533   }
534 
535   void popDerivedTypeInConstruction() {
536     assert(!derivedTypeInConstruction.empty());
537     derivedTypeInConstruction.pop_back();
538   }
539 
540   /// Stack derived type being processed to avoid infinite loops in case of
541   /// recursive derived types. The depth of derived types is expected to be
542   /// shallow (<10), so a SmallVector is sufficient.
543   llvm::SmallVector<std::pair<const Fortran::lower::SymbolRef, mlir::Type>>
544       derivedTypeInConstruction;
545   Fortran::lower::AbstractConverter &converter;
546   mlir::MLIRContext *context;
547 };
548 } // namespace
549 
550 mlir::Type Fortran::lower::getFIRType(mlir::MLIRContext *context,
551                                       Fortran::common::TypeCategory tc,
552                                       int kind,
553                                       llvm::ArrayRef<LenParameterTy> params) {
554   return genFIRType(context, tc, kind, params);
555 }
556 
557 mlir::Type Fortran::lower::translateDerivedTypeToFIRType(
558     Fortran::lower::AbstractConverter &converter,
559     const Fortran::semantics::DerivedTypeSpec &tySpec) {
560   return TypeBuilderImpl{converter}.genDerivedType(tySpec);
561 }
562 
563 mlir::Type Fortran::lower::translateSomeExprToFIRType(
564     Fortran::lower::AbstractConverter &converter, const SomeExpr &expr) {
565   return TypeBuilderImpl{converter}.genExprType(expr);
566 }
567 
568 mlir::Type Fortran::lower::translateSymbolToFIRType(
569     Fortran::lower::AbstractConverter &converter, const SymbolRef symbol) {
570   return TypeBuilderImpl{converter}.genSymbolType(symbol);
571 }
572 
573 mlir::Type Fortran::lower::translateVariableToFIRType(
574     Fortran::lower::AbstractConverter &converter,
575     const Fortran::lower::pft::Variable &var) {
576   return TypeBuilderImpl{converter}.genVariableType(var);
577 }
578 
579 mlir::Type Fortran::lower::convertReal(mlir::MLIRContext *context, int kind) {
580   return genRealType(context, kind);
581 }
582 
583 bool Fortran::lower::isDerivedTypeWithLenParameters(
584     const Fortran::semantics::Symbol &sym) {
585   if (const Fortran::semantics::DeclTypeSpec *declTy = sym.GetType())
586     if (const Fortran::semantics::DerivedTypeSpec *derived =
587             declTy->AsDerived())
588       return Fortran::semantics::CountLenParameters(*derived) > 0;
589   return false;
590 }
591 
592 template <typename T>
593 mlir::Type Fortran::lower::TypeBuilder<T>::genType(
594     Fortran::lower::AbstractConverter &converter,
595     const Fortran::evaluate::FunctionRef<T> &funcRef) {
596   return TypeBuilderImpl{converter}.genExprType(funcRef);
597 }
598 
599 using namespace Fortran::evaluate;
600 using namespace Fortran::common;
601 FOR_EACH_SPECIFIC_TYPE(template class Fortran::lower::TypeBuilder, )
602