[flang][NFC] Unify todo messages

[clementval]

Summary

This patch is part of the upstreaming effort from fir-dev branch.

Co-authored-by: Peter Steinfeld <[e-mail]>

[jeanPerier]

LGTM

flang/include/flang/Optimizer/Builder/Todo.h

 #undef TODOQUOTE
 #define TODOQUOTE(X) #X
 
 #ifdef NDEBUG
 
 // In a release build, just give a message and exit.
 #define TODO_NOLOC(ToDoMsg)                                                    \
   do {                                                                         \
-    llvm::errs() << __FILE__ << ':' << __LINE__ << ": not yet implemented "    \
-                 << ToDoMsg << '\n';                                           \
+    llvm::errs() << __FILE__ << ':' << __LINE__                                \
+                 << ": not yet implemented: " << ToDoMsg << '\n';              \
     std::exit(1);                                                              \
   } while (false)
 
 #undef TODO_DEFN
 #define TODO_DEFN(MlirLoc, ToDoMsg, ToDoFile, ToDoLine)                        \
   do {                                                                         \
-    mlir::emitError(MlirLoc, ToDoFile                                          \
-                    ":" TODOQUOTE(ToDoLine) ": not yet implemented " ToDoMsg); \
+    mlir::emitError(MlirLoc, ToDoFile ":" TODOQUOTE(                           \
+                                 ToDoLine) ": not yet implemented: " ToDoMsg); \
     std::exit(1);                                                              \
   } while (false)
 
 #define TODO(MlirLoc, ToDoMsg) TODO_DEFN(MlirLoc, ToDoMsg, __FILE__, __LINE__)
 
 #else
 
 // In a developer build, print a message and give a backtrace.
 #undef TODO_NOLOCDEFN
 #define TODO_NOLOCDEFN(ToDoMsg, ToDoFile, ToDoLine)                            \
   do {                                                                         \
     llvm::report_fatal_error(                                                  \
-        __FILE__ ":" TODOQUOTE(__LINE__) ": not yet implemented " ToDoMsg);    \
+        ToDoFile ":" TODOQUOTE(ToDoLine) ": not yet implemented: " ToDoMsg);   \
   } while (false)
 
 #define TODO_NOLOC(ToDoMsg) TODO_NOLOCDEFN(ToDoMsg, __FILE__, __LINE__)
 
 #undef TODO_DEFN
 #define TODO_DEFN(MlirLoc, ToDoMsg, ToDoFile, ToDoLine)                        \
   do {                                                                         \
     fir::emitFatalError(                                                       \
         MlirLoc,                                                               \
-        ToDoFile ":" TODOQUOTE(ToDoLine) ": not yet implemented " ToDoMsg);    \
+        ToDoFile ":" TODOQUOTE(ToDoLine) ": not yet implemented: " ToDoMsg);   \
   } while (false)
 
 #define TODO(MlirLoc, ToDoMsg) TODO_DEFN(MlirLoc, ToDoMsg, __FILE__, __LINE__)
 
 #endif
 
 #endif // FORTRAN_LOWER_TODO_H

flang/lib/Lower/Allocatable.cpp

private:
   void lowerAllocateLengthParameters() {
     const Fortran::semantics::DeclTypeSpec *typeSpec =
         getIfAllocateStmtTypeSpec();
     if (!typeSpec)
       return;
     if (const Fortran::semantics::DerivedTypeSpec *derived =
             typeSpec->AsDerived())
       if (Fortran::semantics::CountLenParameters(*derived) > 0)
-        TODO(loc, "TODO: setting derived type params in allocation");
+        TODO(loc, "setting derived type params in allocation");
     if (typeSpec->category() ==
         Fortran::semantics::DeclTypeSpec::Category::Character) {
       Fortran::semantics::ParamValue lenParam =
           typeSpec->characterTypeSpec().length();
       if (Fortran::semantics::MaybeIntExpr intExpr = lenParam.GetExplicit()) {
         Fortran::lower::StatementContext stmtCtx;
         Fortran::lower::SomeExpr lenExpr{*intExpr};
         lenParams.push_back(
private:
 
   void genSourceAllocation(const Allocation &, const fir::MutableBoxValue &) {
     TODO(loc, "SOURCE allocation lowering");
   }
   void genMoldAllocation(const Allocation &, const fir::MutableBoxValue &) {
     TODO(loc, "MOLD allocation lowering");
   }
   void genSetType(const Allocation &, const fir::MutableBoxValue &) {
-    TODO(loc, "Polymorphic entity allocation lowering");
+    TODO(loc, "polymorphic entity allocation lowering");
   }
 
   /// Returns a pointer to the DeclTypeSpec if a type-spec is provided in the
   /// allocate statement. Returns a null pointer otherwise.
   const Fortran::semantics::DeclTypeSpec *getIfAllocateStmtTypeSpec() const {
     if (const auto &typeSpec =
             std::get<std::optional<Fortran::parser::TypeSpec>>(stmt.t))
       return typeSpec->declTypeSpec;

flang/lib/Lower/Bridge.cpp

#endif
   }
 
   /// Lower a procedure (nest).
   void lowerFunc(Fortran::lower::pft::FunctionLikeUnit &funit) {
     if (!funit.isMainProgram()) {
       const Fortran::semantics::Symbol &procSymbol =
           funit.getSubprogramSymbol();
       if (procSymbol.owner().IsSubmodule()) {
-        TODO(toLocation(), "support submodules");
+        TODO(toLocation(), "support for submodules");
         return;
       }
     }
     setCurrentPosition(funit.getStartingSourceLoc());
     for (int entryIndex = 0, last = funit.entryPointList.size();
          entryIndex < last; ++entryIndex) {
       funit.setActiveEntry(entryIndex);
       startNewFunction(funit); // the entry point for lowering this procedure

flang/lib/Lower/CallInterface.cpp

void handleExplicitDummy(
     llvm::SmallVector<mlir::NamedAttribute> attrs = dummyNameAttr(entity);
     auto addMLIRAttr = [&](llvm::StringRef attr) {
       attrs.emplace_back(mlir::StringAttr::get(&mlirContext, attr),
                          mlir::UnitAttr::get(&mlirContext));
     };
     if (obj.attrs.test(Attrs::Optional))
       addMLIRAttr(fir::getOptionalAttrName());
     if (obj.attrs.test(Attrs::Asynchronous))
-      TODO(loc, "Asynchronous in procedure interface");
+      TODO(loc, "ASYNCHRONOUS in procedure interface");
     if (obj.attrs.test(Attrs::Contiguous))
       addMLIRAttr(fir::getContiguousAttrName());
     if (obj.attrs.test(Attrs::Value))
       isValueAttr = true; // TODO: do we want an mlir::Attribute as well?
     if (obj.attrs.test(Attrs::Volatile))
-      TODO(loc, "Volatile in procedure interface");
+      TODO(loc, "VOLATILE in procedure interface");
     if (obj.attrs.test(Attrs::Target))
       addMLIRAttr(fir::getTargetAttrName());
 
     // TODO: intents that require special care (e.g finalization)
 
     using ShapeAttr = Fortran::evaluate::characteristics::TypeAndShape::Attr;
     const Fortran::evaluate::characteristics::TypeAndShape::Attrs &shapeAttrs =
         obj.type.attrs();
     if (shapeAttrs.test(ShapeAttr::AssumedRank))
-      TODO(loc, "Assumed Rank in procedure interface");
+      TODO(loc, "assumed rank in procedure interface");
     if (shapeAttrs.test(ShapeAttr::Coarray))
-      TODO(loc, "Coarray in procedure interface");
+      TODO(loc, "coarray in procedure interface");
 
     // So far assume that if the argument cannot be passed by implicit interface
     // it must be by box. That may no be always true (e.g for simple optionals)
 
     Fortran::evaluate::DynamicType dynamicType = obj.type.type();
     mlir::Type type = translateDynamicType(dynamicType);
     fir::SequenceType::Shape bounds = getBounds(obj.type.shape());
     if (!bounds.empty())

flang/lib/Lower/ConvertExpr.cpp

case Fortran::evaluate::DescriptorInquiry::Field::LowerBound:
           builder.createIntegerConstant(loc, idxTy, 1)));
     case Fortran::evaluate::DescriptorInquiry::Field::Extent:
       return castResult(
           fir::factory::readExtent(builder, loc, exv, desc.dimension()));
     case Fortran::evaluate::DescriptorInquiry::Field::Rank:
       TODO(loc, "rank inquiry on assumed rank");
     case Fortran::evaluate::DescriptorInquiry::Field::Stride:
       // So far the front end does not generate this inquiry.
-      TODO(loc, "Stride inquiry");
+      TODO(loc, "stride inquiry");
     }
     llvm_unreachable("unknown descriptor inquiry");
   }
 
   ExtValue genval(const Fortran::evaluate::TypeParamInquiry &) {
     TODO(getLoc(), "type parameter inquiry");
   }
 
ExtValue genArrayTempFromMold(const ExtValue &mold,
     mlir::Type elementType = fir::unwrapSequenceType(type);
     if (auto charType = elementType.dyn_cast<fir::CharacterType>()) {
       charLen = allocMemTypeParams.empty()
                     ? fir::factory::readCharLen(builder, loc, mold)
                     : allocMemTypeParams[0];
       if (charType.hasDynamicLen() && allocMemTypeParams.empty())
         allocMemTypeParams.push_back(charLen);
     } else if (fir::hasDynamicSize(elementType)) {
-      TODO(loc, "Creating temporary for derived type with length parameters");
+      TODO(loc, "creating temporary for derived type with length parameters");
     }
 
     mlir::Value temp = builder.create<fir::AllocMemOp>(
         loc, type, tempName, allocMemTypeParams, extents);
     if (fir::unwrapSequenceType(type).isa<fir::CharacterType>())
       return fir::CharArrayBoxValue{temp, charLen, extents};
     return fir::ArrayBoxValue{temp, extents};
   }

flang/lib/Lower/ConvertType.cpp

mlir::Type genExprType(const Fortran::lower::SomeExpr &expr) {
     if (shapeExpr) {
       translateShape(shape, std::move(*shapeExpr));
     } else {
       // Shape static analysis cannot return something useful for the shape.
       // Use unknown extents.
       int rank = expr.Rank();
       if (rank < 0)
         TODO(converter.getCurrentLocation(),
-             "Assumed rank expression type lowering");
+             "assumed rank expression type lowering");
       for (int dim = 0; dim < rank; ++dim)
         shape.emplace_back(fir::SequenceType::getUnknownExtent());
     }
     if (!shape.empty())
       return fir::SequenceType::get(shape, baseType);
     return baseType;
   }
 
mlir::Type genDerivedType(const Fortran::semantics::DerivedTypeSpec &tySpec) {
 
     rec.finalize(ps, cs);
     popDerivedTypeInConstruction();
 
     mlir::Location loc = converter.genLocation(typeSymbol.name());
     if (!ps.empty()) {
       // This type is a PDT (parametric derived type). Create the functions to
       // use for allocation, dereferencing, and address arithmetic here.
-      TODO(loc, "parametrized derived types lowering");
+      TODO(loc, "parameterized derived types lowering");
     }
     LLVM_DEBUG(llvm::dbgs() << "derived type: " << rec << '\n');
 
     // Generate the type descriptor object if any
     if (const Fortran::semantics::Scope *derivedScope =
             tySpec.scope() ? tySpec.scope() : tySpec.typeSymbol().scope())
       if (const Fortran::semantics::Symbol *typeInfoSym =
               derivedScope->runtimeDerivedTypeDescription())

flang/lib/Lower/VectorSubscripts.cpp

private:
 
   mlir::Type gen(const Fortran::evaluate::Component &component) {
     auto recTy = gen(component.base()).cast<fir::RecordType>();
     const Fortran::semantics::Symbol &componentSymbol =
         component.GetLastSymbol();
     // Parent components will not be found here, they are not part
     // of the FIR type and cannot be used in the path yet.
     if (componentSymbol.test(Fortran::semantics::Symbol::Flag::ParentComp))
-      TODO(loc, "Reference to parent component");
+      TODO(loc, "reference to parent component");
     mlir::Type fldTy = fir::FieldType::get(&converter.getMLIRContext());
     llvm::StringRef componentName = toStringRef(componentSymbol.name());
     // Parameters threading in field_index is not yet very clear. We only
     // have the ones of the ranked array ref at hand, but it looks like
     // the fir.field_index expects the one of the direct base.
     if (recTy.getNumLenParams() != 0)
       TODO(loc, "threading length parameters in field index op");
     fir::FirOpBuilder &builder = converter.getFirOpBuilder();
for (const auto &subscript : llvm::enumerate(arrayRef.subscript())) {
           subscript.value().u);
     }
     return fir::unwrapSequenceType(
         fir::unwrapPassByRefType(fir::getBase(loweredBase).getType()));
   }
 
   mlir::Type gen(const Fortran::evaluate::CoarrayRef &) {
     // Is this possible/legal ?
-    TODO(loc, "Coarray ref with vector subscript in IO input");
+    TODO(loc, "coarray ref with vector subscript in IO input");
   }
 
   template <typename A>
   mlir::Value genScalarValue(const A &expr) {
     return fir::getBase(converter.genExprValue(toEvExpr(expr), stmtCtx));
   }
 
   Fortran::evaluate::DataRef

flang/lib/Optimizer/Builder/MutableBox.cpp

return !fir::valueHasFirAttribute(box.getAddr(),
                                     fir::getContiguousAttrName());
 }
 
 fir::ExtendedValue
 fir::factory::genMutableBoxRead(fir::FirOpBuilder &builder, mlir::Location loc,
                                 const fir::MutableBoxValue &box,
                                 bool mayBePolymorphic) {
   if (box.hasAssumedRank())
-    TODO(loc, "Assumed rank allocatables or pointers");
+    TODO(loc, "assumed rank allocatables or pointers");
   llvm::SmallVector<mlir::Value> lbounds;
   llvm::SmallVector<mlir::Value> extents;
   llvm::SmallVector<mlir::Value> lengths;
   if (readToBoxValue(box, mayBePolymorphic)) {
     auto reader = MutablePropertyReader(builder, loc, box);
     reader.getLowerBounds(lbounds);
     return fir::BoxValue{reader.getIrBox(), lbounds,
                          box.nonDeferredLenParams()};
source.match(
       [&](const fir::MutableBoxValue &) {
         // No point implementing this, if right-hand side is a
         // pointer/allocatable, the related MutableBoxValue has been read into
         // another ExtendedValue category.
         fir::emitFatalError(loc,
                             "Cannot write MutableBox to another MutableBox");
       },
       [&](const fir::ProcBoxValue &) {
-        TODO(loc, "Procedure pointer assignment");
+        TODO(loc, "procedure pointer assignment");
       });
 }
 
 void fir::factory::associateMutableBoxWithRemap(
     fir::FirOpBuilder &builder, mlir::Location loc,
     const fir::MutableBoxValue &box, const fir::ExtendedValue &source,
     mlir::ValueRange lbounds, mlir::ValueRange ubounds) {
   // Compute new extents
source.match(
       [&](const fir::MutableBoxValue &) {
         // No point implementing this, if right-hand side is a pointer or
         // allocatable, the related MutableBoxValue has already been read into
         // another ExtendedValue category.
         fir::emitFatalError(loc,
                             "Cannot write MutableBox to another MutableBox");
       },
       [&](const fir::ProcBoxValue &) {
-        TODO(loc, "Procedure pointer assignment");
+        TODO(loc, "procedure pointer assignment");
       });
 }
 
 void fir::factory::disassociateMutableBox(fir::FirOpBuilder &builder,
                                           mlir::Location loc,
                                           const fir::MutableBoxValue &box) {
   MutablePropertyWriter{builder, loc, box}.setUnallocatedStatus();
 }

flang/test/Fir/Todo/allocmem.fir

 // RUN: %not_todo_cmd fir-opt --fir-to-llvm-ir="target=x86_64-unknown-linux-gnu" %s 2>&1 | FileCheck %s
 
 // Test `fir.allocmem` of derived type with LEN parameters conversion to llvm.
 // Not implemented yet.
 
 func.func @allocmem_test(%arg0 : i32, %arg1 : i16) {
-// CHECK: not yet implemented fir.allocmem codegen of derived type with length parameters
+// CHECK: not yet implemented: fir.allocmem codegen of derived type with length parameters
   %0 = fir.allocmem !fir.type<_QTt(p1:i32,p2:i16){f1:i32,f2:f32}>(%arg0, %arg1 : i32, i16) {name = "_QEvar"}
   return 
 }

flang/test/Fir/Todo/coordinate_of_1.fir

 // RUN: %not_todo_cmd fir-opt --fir-to-llvm-ir="target=x86_64-unknown-linux-gnu" %s 2>&1 | FileCheck %s
 
 // `fir.coordinate_of` - derived type with `fir.len_param_index`. As
 // `fir.len_param_index` is not implemented yet, that's the error that's
 // currently being generated (this error is generated before trying to convert
 // `fir.coordinate_of`)
 func.func @coordinate_box_derived_with_fir_len(%arg0: !fir.box<!fir.type<derived_2{len1:i32}>>) {
-// CHECK: not yet implemented fir.len_param_index codegen
+// CHECK: not yet implemented: fir.len_param_index codegen
   %e = fir.len_param_index len1, !fir.type<derived_2{len1:i32}>
   %q = fir.coordinate_of %arg0, %e : (!fir.box<!fir.type<derived_2{len1:i32}>>, !fir.len) -> !fir.ref<i32>
   return
 }

flang/test/Fir/Todo/coordinate_of_2.fir

 // RUN: %not_todo_cmd fir-opt --fir-to-llvm-ir="target=x86_64-unknown-linux-gnu" %s 2>&1 | FileCheck %s
 
-// CHECK: not yet implemented fir.array nested inside other array and/or derived type
+// CHECK: not yet implemented: fir.array nested inside other array and/or derived type
 
 // `!fir.coordinate_of` - `!fir.array` inside "boxed" `!fir.type`
 func.func @coordinate_box_array_inside_derived(%arg0: !fir.box<!fir.type<derived_2{field_1:!fir.array<10 x i32>, field_2:i32}>>, %arg1 : index) {
    %idx0 = arith.constant 0 : i32
    %q = fir.coordinate_of %arg0, %idx0, %arg1 : (!fir.box<!fir.type<derived_2{field_1:!fir.array<10 x i32>, field_2:i32}>>, i32, index) -> !fir.ref<f32>
    return
 }

flang/test/Fir/Todo/coordinate_of_3.fir

 // RUN: %not_todo_cmd fir-opt --fir-to-llvm-ir="target=x86_64-unknown-linux-gnu" %s 2>&1 | FileCheck %s
 
-// CHECK: not yet implemented fir.array nested inside other array and/or derived type
+// CHECK: not yet implemented: fir.array nested inside other array and/or derived type
 
 // `fir.coordinate_of` - `fir.array` inside "boxed" `!fir.type<derived_1{!fir.type<derived_2{}>}` (i.e. nested `!fir.type`)
 func.func @coordinate_box_array_inside_derived(%arg0: !fir.box<!fir.type<derived_1{field_1:!fir.type<derived_2{field_2:!fir.array<10 x i32>}>}>>, %arg1 : index) {
    %idx0 = arith.constant 0 : i32
    %q = fir.coordinate_of %arg0, %idx0, %idx0, %arg1 : (!fir.box<!fir.type<derived_1{field_1:!fir.type<derived_2{field_2:!fir.array<10 x i32>}>}>>, i32, i32, index) -> !fir.ref<f32>
    return
 }

flang/test/Fir/Todo/coordinate_of_4.fir

 // RUN: %not_todo_cmd fir-opt --fir-to-llvm-ir="target=x86_64-unknown-linux-gnu" %s 2>&1 | FileCheck %s
 
 // `!fir.coordinate_of` - derived type with `!fir.len_param_index`. As
 // `!fir.len_param_index` is not implemented yet, the error that we hit is
 // related to `!fir.len_param_index` rather than `!fir.coordinate_of`.
 func.func @coordinate_box_derived_with_fir_len(%arg0: !fir.box<!fir.type<derived_2{len1:i32}>>) {
-// CHECK: not yet implemented fir.len_param_index codegen
+// CHECK: not yet implemented: fir.len_param_index codegen
   %e = fir.len_param_index len1, !fir.type<derived_2{len1:i32}>
   %q = fir.coordinate_of %arg0, %e : (!fir.box<!fir.type<derived_2{len1:i32}>>, !fir.len) -> !fir.ref<i32>
   return
 }

flang/test/Fir/Todo/dispatch.fir

 // RUN: %not_todo_cmd fir-opt --fir-to-llvm-ir="target=x86_64-unknown-linux-gnu" %s 2>&1 | FileCheck %s
 
 // Test `fir.dispatch` conversion to llvm.
 // Not implemented yet.
 
 func.func @dispatch(%arg0: !fir.box<!fir.type<derived3{f:f32}>>) {
-// CHECK: not yet implemented fir.dispatch codegen
+// CHECK: not yet implemented: fir.dispatch codegen
   %0 = fir.dispatch "method"(%arg0) : (!fir.box<!fir.type<derived3{f:f32}>>) -> i32
   return
 }

flang/test/Fir/Todo/dispatch_table.fir

 // RUN: %not_todo_cmd fir-opt --fir-to-llvm-ir="target=x86_64-unknown-linux-gnu" %s 2>&1 | FileCheck %s
 
 // Test fir.dispatch_table conversion to llvm.
 // Not implemented yet.
 
-// CHECK: not yet implemented fir.dispatch_table codegen
+// CHECK: not yet implemented: fir.dispatch_table codegen
 fir.dispatch_table @dispatch_tbl {
   fir.dt_entry "method", @method_impl
 }

flang/test/Fir/Todo/end.fir

 // RUN: %not_todo_cmd fir-opt --fir-to-llvm-ir="target=x86_64-unknown-linux-gnu" %s 2>&1 | FileCheck %s
 
 // Test `fir.end` conversion to llvm.
 // Not implemented yet.
 
 func.func @end_test() {
-// CHECK: not yet implemented fir.end codegen
+// CHECK: not yet implemented: fir.end codegen
   "fir.end"() : () -> ()
 }

flang/test/Fir/Todo/gentypedesc.fir

 // RUN: %not_todo_cmd fir-opt --fir-to-llvm-ir="target=x86_64-unknown-linux-gnu" %s 2>&1 | FileCheck %s
 
 // Test `fir.gentypedesc` conversion to llvm.
 // Not implemented yet.
 
 func.func @gentypedesc() {
-// CHECK: not yet implemented fir.gentypedesc codegen
+// CHECK: not yet implemented: fir.gentypedesc codegen
   %0 = fir.gentypedesc !fir.type<derived3>
   return
 }

flang/test/Fir/Todo/global_len.fir

 // RUN: %not_todo_cmd fir-opt --fir-to-llvm-ir="target=x86_64-unknown-linux-gnu" %s 2>&1 | FileCheck %s
 
 // Test `fir.global_len` conversion to llvm.
 // Not implemented yet.
 
 fir.global @global_derived : !fir.type<minez(f:i32)> {
-// CHECK: not yet implemented fir.global_len codegen
+// CHECK: not yet implemented: fir.global_len codegen
   fir.global_len f, 1 : i32
   %0 = fir.undefined !fir.type<minez>
   fir.has_value %0 : !fir.type<minez>
 }

flang/test/Fir/Todo/len_param_index.fir

 // RUN: %not_todo_cmd fir-opt --fir-to-llvm-ir="target=x86_64-unknown-linux-gnu" %s 2>&1 | FileCheck %s
 
 // Test `fir.len_param_index` conversion to llvm.
 // Not implemented yet.
 
 func.func @lenparamindex() {
-  // CHECK: not yet implemented fir.len_param_index codegen
+  // CHECK: not yet implemented: fir.len_param_index codegen
   %0 = fir.len_param_index l1, !fir.type<twolens(l1:i32, l2:i32){i:i32, f:f32, l:i64}>
   return
 }
 

flang/test/Fir/Todo/select_case_with_character.fir

 // RUN: %not_todo_cmd fir-opt --fir-to-llvm-ir="target=x86_64-unknown-linux-gnu" %s 2>&1 | FileCheck %s
 
 // Test `fir.select_case` conversion to llvm with character type.
 // Not implemented yet.
 
 func.func @select_case_charachter(%arg0: !fir.char<2, 10>, %arg1: !fir.char<2, 10>, %arg2: !fir.char<2, 10>) {
-// CHECK: not yet implemented fir.select_case codegen with character type
+// CHECK: not yet implemented: fir.select_case codegen with character type
   fir.select_case %arg0 : !fir.char<2, 10> [#fir.point, %arg1, ^bb1,
                                             #fir.point, %arg2, ^bb2,
                                             unit, ^bb3]
 ^bb1:
   %c1_i32 = arith.constant 1 : i32
   cf.br ^bb3
 ^bb2:
   %c2_i32 = arith.constant 2 : i32
   cf.br ^bb3
 ^bb3:
   return
 }

flang/test/Lower/derived-types.f90

 ! Test basic parts of derived type entities lowering
 ! RUN: bbc -emit-fir %s -o - | FileCheck %s
 
-! Note: only testing non parametrized derived type here.
+! Note: only testing non parameterized derived type here.
 
 module d
   type r
     real :: x
   end type
   type r2
     real :: x_array(10, 20)
   end type