[flang][NFC] rename IsKindParameterizedDerivedType and fix comment typos

[jeanPerier]

Summary

Following post-review feedback on https://reviews.llvm.org/D120804 and
https://reviews.llvm.org/D120801 about type descriptor changes, fix typos in
comments and rename IsKindParameterizedDerivedType to
IsDerivedTypeWithKindParameter. Remove a useless ;.

[clementval]

LG

[PeteSteinfeld]

All builds and tests correctly and looks good.

flang/include/flang/Optimizer/CodeGen/CodeGen.h

 /// Prerequiste pass for code gen. Perform intermediate rewrites to tailor the
 /// FIR for the chosen target.
 std::unique_ptr<mlir::OperationPass<mlir::ModuleOp>> createFirTargetRewritePass(
     const TargetRewriteOptions &options = TargetRewriteOptions());
 
 /// FIR to LLVM translation pass options.
 struct FIRToLLVMPassOptions {
   // Do not fail when type descriptors are not found when translating
-  // operations that uses them at the LLVM level like fir.embox. Instead,
+  // operations that use them at the LLVM level like fir.embox. Instead,
   // just use a null pointer.
   // This is useful to test translating programs manually written where a
   // frontend did not generate type descriptor data structures. However, note
-  // that this programs would crash at runtime if the derived type descriptors
-  // are required by the runtime, so this only an option to help debugging.
+  // that such programs would crash at runtime if the derived type descriptors
+  // are required by the runtime, so this is only an option to help debugging.
   bool ignoreMissingTypeDescriptors = false;
 };
 
 /// Convert FIR to the LLVM IR dialect with default options.
 std::unique_ptr<mlir::Pass> createFIRToLLVMPass();
 
 /// Convert FIR to the LLVM IR dialect
 std::unique_ptr<mlir::Pass> createFIRToLLVMPass(FIRToLLVMPassOptions options);

flang/include/flang/Semantics/scope.h

bool IsSubmodule() const {
     return kind_ == Kind::Module && symbol_->get<ModuleDetails>().isSubmodule();
   }
   bool IsDerivedType() const { return kind_ == Kind::DerivedType; }
   bool IsStmtFunction() const;
   bool IsParameterizedDerivedType() const;
   bool IsParameterizedDerivedTypeInstantiation() const {
     return kind_ == Kind::DerivedType && !symbol_;
   }
-  bool IsKindParameterizedDerivedType() const;
+  bool IsDerivedTypeWithKindParameter() const;
   Symbol *symbol() { return symbol_; }
   const Symbol *symbol() const { return symbol_; }
   SemanticsContext &context() const { return context_; }
 
   inline const Symbol *GetSymbol() const;
   const Scope *GetDerivedTypeParent() const;
   const Scope &GetDerivedTypeBase() const;
   inline std::optional<SourceName> GetName() const;

flang/lib/Semantics/compute-offsets.cpp

private:
   std::map<MutableSymbolRef, SizeAndAlignment, SymbolAddressCompare>
       equivalenceBlock_;
 };
 
 void ComputeOffsetsHelper::Compute(Scope &scope) {
   for (Scope &child : scope.children()) {
     ComputeOffsets(context_, child);
   }
-  if (scope.symbol() && scope.IsKindParameterizedDerivedType()) {
+  if (scope.symbol() && scope.IsDerivedTypeWithKindParameter()) {
     return; // only process instantiations of kind parameterized derived types
   }
   if (scope.alignment().has_value()) {
     return; // prevent infinite recursion in error cases
   }
   scope.SetAlignment(0);
   // Build dependents_ from equivalences: symbol -> symbol+offset
   for (const EquivalenceSet &set : scope.equivalenceSets()) {

flang/lib/Semantics/runtime-type-info.cpp

for (SymbolRef ref : *parameters) {
       if (tpd.attr() == common::TypeParamAttr::Kind) {
         if (const auto *pv{derivedTypeSpec.FindParameter(ref->name())}) {
           if (pv->GetExplicit()) {
             if (auto instantiatedValue{evaluate::ToInt64(*pv->GetExplicit())}) {
               if (suffix.has_value()) {
                 *suffix += "."s + std::to_string(*instantiatedValue);
               } else {
                 suffix = "."s + std::to_string(*instantiatedValue);
-                ;
               }
             }
           }
         }
       }
     }
     return suffix;
   }
   return std::nullopt;
 }
 
 const Symbol *RuntimeTableBuilder::DescribeType(Scope &dtScope) {
   if (const Symbol * info{dtScope.runtimeDerivedTypeDescription()}) {
     return info;
   }
   const DerivedTypeSpec *derivedTypeSpec{dtScope.derivedTypeSpec()};
-  if (!derivedTypeSpec && !dtScope.IsKindParameterizedDerivedType() &&
+  if (!derivedTypeSpec && !dtScope.IsDerivedTypeWithKindParameter() &&
       dtScope.symbol()) {
     // This derived type was declared (obviously, there's a Scope) but never
     // used in this compilation (no instantiated DerivedTypeSpec points here).
     // Create a DerivedTypeSpec now for it so that ComponentIterator
     // will work. This covers the case of a derived type that's declared in
     // a module but used only by clients and submodules, enabling the
     // run-time "no initialization needed here" flag to work.
     DerivedTypeSpec derived{dtScope.symbol()->name(), *dtScope.symbol()};
const Symbol *RuntimeTableBuilder::DescribeType(Scope &dtScope) {
   // Create a new description object before populating it so that mutual
   // references will work as pointer targets.
   Symbol &dtObject{CreateObject(dtDescName, derivedTypeSchema_, scope)};
   dtScope.set_runtimeDerivedTypeDescription(dtObject);
   evaluate::StructureConstructorValues dtValues;
   AddValue(dtValues, derivedTypeSchema_, "name"s,
       SaveNameAsPointerTarget(scope, typeName));
   bool isPDTdefinitionWithKindParameters{
-      !derivedTypeSpec && dtScope.IsKindParameterizedDerivedType()};
+      !derivedTypeSpec && dtScope.IsDerivedTypeWithKindParameter()};
   if (!isPDTdefinitionWithKindParameters) {
     auto sizeInBytes{static_cast<common::ConstantSubscript>(dtScope.size())};
     if (auto alignment{dtScope.alignment().value_or(0)}) {
       sizeInBytes += alignment - 1;
       sizeInBytes /= alignment;
       sizeInBytes *= alignment;
     }
     AddValue(

flang/lib/Semantics/scope.cpp

bool Scope::IsParameterizedDerivedType() const {
   for (const auto &pair : symbols_) {
     if (pair.second->has<TypeParamDetails>()) {
       return true;
     }
   }
   return false;
 }
 
-bool Scope::IsKindParameterizedDerivedType() const {
+bool Scope::IsDerivedTypeWithKindParameter() const {
   if (!IsDerivedType()) {
     return false;
   }
   if (const Scope * parent{GetDerivedTypeParent()}) {
-    if (parent->IsKindParameterizedDerivedType()) {
+    if (parent->IsDerivedTypeWithKindParameter()) {
       return true;
     }
   }
   for (const auto &pair : symbols_) {
     if (const auto *typeParam{pair.second->detailsIf<TypeParamDetails>()}) {
       if (typeParam->attr() == common::TypeParamAttr::Kind) {
         return true;
       }