[flang][NFC] Switch CollectBindings return to SymbolVector

[clementval]

Summary

As suggested on D138129, switching rteurn of CollectBindings
function to SymbolVector.

[clementval]

Use reference

flang/include/flang/Semantics/runtime-type-info.h

 //===-- include/flang/Semantics/runtime-type-info.h -------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // BuildRuntimeDerivedTypeTables() translates the scopes of derived types
 // and parameterized derived type instantiations into the type descriptions
 // defined in module/__fortran_type_info.f90, packaging these descriptions
 // as static initializers for compiler-created objects.
 
 #ifndef FORTRAN_SEMANTICS_RUNTIME_TYPE_INFO_H_
 #define FORTRAN_SEMANTICS_RUNTIME_TYPE_INFO_H_
 
+#include "flang/Common/reference.h"
 #include <set>
 #include <string>
 #include <vector>
 
 namespace llvm {
 class raw_ostream;
 }
 
 namespace Fortran::semantics {
 class Scope;
 class SemanticsContext;
 class Symbol;
 
+using SymbolRef = common::Reference<const Symbol>;
+using SymbolVector = std::vector<SymbolRef>;
+
 struct RuntimeDerivedTypeTables {
   Scope *schemata{nullptr};
   std::set<std::string> names;
 };
 
 RuntimeDerivedTypeTables BuildRuntimeDerivedTypeTables(SemanticsContext &);
 
 /// Name of the builtin module that defines builtin derived types meant
 /// to describe other derived types at runtime in flang descriptor.
 constexpr char typeInfoBuiltinModule[]{"__fortran_type_info"};
 
-std::vector<const Symbol *> CollectBindings(const Scope &dtScope);
+SymbolVector CollectBindings(const Scope &dtScope);
 
 } // namespace Fortran::semantics
 #endif // FORTRAN_SEMANTICS_RUNTIME_TYPE_INFO_H_

flang/lib/Lower/Bridge.cpp

for (const DispatchTableInfo &info : registeredDispatchTableInfo) {
       const Fortran::semantics::DerivedTypeSpec *parent =
           Fortran::evaluate::GetParentTypeSpec(*info.typeSpec);
       fir::FirOpBuilder &builder = converter.getFirOpBuilder();
       fir::DispatchTableOp dt = builder.createDispatchTableOp(
           info.loc, dtName,
           parent ? Fortran::lower::mangle::mangleName(*parent) : "");
       auto insertPt = builder.saveInsertionPoint();
 
-      std::vector<const Fortran::semantics::Symbol *> bindings =
+      Fortran::semantics::SymbolVector bindings =
           Fortran::semantics::CollectBindings(*info.typeSpec->scope());
 
       if (!bindings.empty())
         builder.createBlock(&dt.getRegion());
 
-      for (const Fortran::semantics::Symbol *binding : bindings) {
+      for (const Fortran::semantics::SymbolRef binding : bindings) {
         const auto *details =
-            binding->detailsIf<Fortran::semantics::ProcBindingDetails>();
+            binding.get().detailsIf<Fortran::semantics::ProcBindingDetails>();
         std::string bindingName =
             Fortran::lower::mangle::mangleName(details->symbol());
         builder.create<fir::DTEntryOp>(
             info.loc,
             mlir::StringAttr::get(builder.getContext(),
-                                  binding->name().ToString()),
+                                  binding.get().name().ToString()),
             mlir::SymbolRefAttr::get(builder.getContext(), bindingName));
       }
       if (!bindings.empty())
         builder.create<fir::FirEndOp>(info.loc);
       builder.restoreInsertionPoint(insertPt);
     }
     registeredDispatchTableInfo.clear();
   }

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

evaluate::StructureConstructor RuntimeTableBuilder::PackageIntValue(
   return Structure(valueSchema_, std::move(xs));
 }
 
 SomeExpr RuntimeTableBuilder::PackageIntValueExpr(
     const SomeExpr &genre, std::int64_t n) const {
   return StructureExpr(PackageIntValue(genre, n));
 }
 
-std::vector<const Symbol *> CollectBindings(const Scope &dtScope) {
-  std::vector<const Symbol *> result;
+SymbolVector CollectBindings(const Scope &dtScope) {
+  SymbolVector result;
   std::map<SourceName, const Symbol *> localBindings;
   // Collect local bindings
   for (auto pair : dtScope) {
     const Symbol &symbol{*pair.second};
     if (symbol.has<ProcBindingDetails>()) {
       localBindings.emplace(symbol.name(), &symbol);
     }
   }
   if (const Scope * parentScope{dtScope.GetDerivedTypeParent()}) {
     result = CollectBindings(*parentScope);
     // Apply overrides from the local bindings of the extended type
     for (auto iter{result.begin()}; iter != result.end(); ++iter) {
       const Symbol &symbol{**iter};
       auto overridden{localBindings.find(symbol.name())};
       if (overridden != localBindings.end()) {
-        *iter = overridden->second;
+        *iter = *overridden->second;
         localBindings.erase(overridden);
       }
     }
   }
   // Add remaining (non-overriding) local bindings in name order to the result
   for (auto pair : localBindings) {
-    result.push_back(pair.second);
+    result.push_back(*pair.second);
   }
   return result;
 }
 
 std::vector<evaluate::StructureConstructor>
 RuntimeTableBuilder::DescribeBindings(const Scope &dtScope, Scope &scope) {
   std::vector<evaluate::StructureConstructor> result;
-  for (const Symbol *symbol : CollectBindings(dtScope)) {
+  for (const SymbolRef ref : CollectBindings(dtScope)) {
     evaluate::StructureConstructorValues values;
     AddValue(values, bindingSchema_, "proc"s,
         SomeExpr{evaluate::ProcedureDesignator{
-            symbol->get<ProcBindingDetails>().symbol()}});
+            ref.get().get<ProcBindingDetails>().symbol()}});
     AddValue(values, bindingSchema_, "name"s,
-        SaveNameAsPointerTarget(scope, symbol->name().ToString()));
+        SaveNameAsPointerTarget(scope, ref.get().name().ToString()));
     result.emplace_back(DEREF(bindingSchema_.AsDerived()), std::move(values));
   }
   return result;
 }
 
 void RuntimeTableBuilder::DescribeGeneric(const GenericDetails &generic,
     std::map<int, evaluate::StructureConstructor> &specials) {
   common::visit(common::visitors{