[flang][OpenMP] Fix collectSymbolSet for supporting default clause

[peixin]

Summary

The lowering of default clause requires creating multiple levels of host
associated symbols with private/firstprivate flag. Fix collectSymbolSet
so that it can collect all levels of symbols with the specific flag.

[peixin]

@NimishMishra Please try this to check if this can solve your problem of collecting symbols for default clause.

[peixin]

Fix the typo.

flang/include/flang/Lower/AbstractConverter.h

public:
 
   /// For a given symbol which is host-associated, create a clone using
   /// parameters from the host-associated symbol.
   virtual bool
   createHostAssociateVarClone(const Fortran::semantics::Symbol &sym) = 0;
 
   virtual void copyHostAssociateVar(const Fortran::semantics::Symbol &sym) = 0;
 
-  /// Collect the set of ultimate symbols of symbols with \p flag in \p eval
-  /// region if \p isUltimateSymbol is true. Otherwise, collect the set of
-  /// symbols with \p flag.
+  /// Collect the set of symbols with \p flag in \p eval region. Also collect
+  /// the host symbols with \p flag when the symbols are host associated if \p
+  /// checkHostAssocSymbols is true, in which case note that the host symbols
+  /// may not be in \p eval region.
   virtual void collectSymbolSet(
       pft::Evaluation &eval,
       llvm::SetVector<const Fortran::semantics::Symbol *> &symbolSet,
-      Fortran::semantics::Symbol::Flag flag, bool isUltimateSymbol = true) = 0;
+      Fortran::semantics::Symbol::Flag flag,
+      bool checkHostAssocSymbols = true) = 0;
 
   //===--------------------------------------------------------------------===//
   // Expressions
   //===--------------------------------------------------------------------===//
 
   /// Generate the address of the location holding the expression, \p expr.
   /// If \p expr is a Designator that is not compile time contiguous, the
   /// address returned is the one of a contiguous temporary storage holding the

flang/lib/Lower/Bridge.cpp

public:
   //===--------------------------------------------------------------------===//
   // Utility methods
   //===--------------------------------------------------------------------===//
 
   void collectSymbolSet(
       Fortran::lower::pft::Evaluation &eval,
       llvm::SetVector<const Fortran::semantics::Symbol *> &symbolSet,
       Fortran::semantics::Symbol::Flag flag,
-      bool isUltimateSymbol) override final {
+      bool checkHostAssocSymbols) override final {
     auto addToList = [&](const Fortran::semantics::Symbol &sym) {
-      const Fortran::semantics::Symbol &symbol =
-          isUltimateSymbol ? sym.GetUltimate() : sym;
-      if (symbol.test(flag))
-        symbolSet.insert(&symbol);
+      std::function<void(const Fortran::semantics::Symbol &)> insertSymbols =
+          [&](const Fortran::semantics::Symbol &oriSymbol) {
+            if (oriSymbol.test(flag))
+              symbolSet.insert(&oriSymbol);
+            if (checkHostAssocSymbols)
+              if (const auto *details{
+                      oriSymbol
+                          .detailsIf<Fortran::semantics::HostAssocDetails>()})
+                insertSymbols(details->symbol());
+          };
+      insertSymbols(sym);
     };
     Fortran::lower::pft::visitAllSymbols(eval, addToList);
   }
 
   mlir::Location getCurrentLocation() override final { return toLocation(); }
 
   /// Generate a dummy location.
   mlir::Location genUnknownLocation() override final {

flang/lib/Lower/OpenMP.cpp

mlir::Value symValue =
         mlir::dyn_cast<mlir::omp::ThreadprivateOp>(op).sym_addr();
     return firOpBuilder.create<mlir::omp::ThreadprivateOp>(
         currentLocation, symValue.getType(), symValue);
   };
 
   llvm::SetVector<const Fortran::semantics::Symbol *> threadprivateSyms;
   converter.collectSymbolSet(eval, threadprivateSyms,
                              Fortran::semantics::Symbol::Flag::OmpThreadprivate,
-                             /*isUltimateSymbol=*/false);
+                             /*checkHostAssocSymbols=*/false);
   std::set<Fortran::semantics::SourceName> threadprivateSymNames;
 
   // For a COMMON block, the ThreadprivateOp is generated for itself instead of
   // its members, so only bind the value of the new copied ThreadprivateOp
   // inside the parallel region to the common block symbol only once for
   // multiple members in one COMMON block.
   llvm::SetVector<const Fortran::semantics::Symbol *> commonSyms;
   for (std::size_t i = 0; i < threadprivateSyms.size(); i++) {