addressing feedback

flang/include/flang/Semantics/symbol.h

@@ -128,7 +128,8 @@ class WithBindName {
 // Device type specific OpenACC routine information
 class OpenACCRoutineDeviceTypeInfo {
 public:
-  OpenACCRoutineDeviceTypeInfo(Fortran::common::OpenACCDeviceType dType)
+  explicit OpenACCRoutineDeviceTypeInfo(
+      Fortran::common::OpenACCDeviceType dType)
       : deviceType_{dType} {}
   bool isSeq() const { return isSeq_; }
   void set_isSeq(bool value = true) { isSeq_ = value; }
@@ -161,6 +162,8 @@ class OpenACCRoutineDeviceTypeInfo {
   bool isWorker_{false};
   bool isGang_{false};
   unsigned gangDim_{0};
+  // bind("name") -> std::string
+  // bind(sym) -> SymbolRef (requires namemangling in lowering)
   std::optional<std::variant<std::string, SymbolRef>> bindName_;
   Fortran::common::OpenACCDeviceType deviceType_{
       Fortran::common::OpenACCDeviceType::None};

flang/lib/Semantics/resolve-directives.cpp

@@ -1036,65 +1036,75 @@ void AccAttributeVisitor::AddRoutineInfoToSymbol(
     Fortran::semantics::OpenACCRoutineInfo info;
     std::vector<OpenACCRoutineDeviceTypeInfo *> currentDevices;
     currentDevices.push_back(&info);
-    const auto &clauses = std::get<Fortran::parser::AccClauseList>(x.t);
+    const auto &clauses{std::get<Fortran::parser::AccClauseList>(x.t)};
     for (const Fortran::parser::AccClause &clause : clauses.v) {
-      if (const auto *dTypeClause =
-              std::get_if<Fortran::parser::AccClause::DeviceType>(&clause.u)) {
+      if (const auto *dTypeClause{
+              std::get_if<Fortran::parser::AccClause::DeviceType>(&clause.u)}) {
         currentDevices.clear();
-        for (const auto &deviceTypeExpr : dTypeClause->v.v)
+        for (const auto &deviceTypeExpr : dTypeClause->v.v) {
           currentDevices.push_back(&info.add_deviceTypeInfo(deviceTypeExpr.v));
+        }
       } else if (std::get_if<Fortran::parser::AccClause::Nohost>(&clause.u)) {
         info.set_isNohost();
       } else if (std::get_if<Fortran::parser::AccClause::Seq>(&clause.u)) {
-        for (auto &device : currentDevices)
+        for (auto &device : currentDevices) {
           device->set_isSeq();
+        }
       } else if (std::get_if<Fortran::parser::AccClause::Vector>(&clause.u)) {
-        for (auto &device : currentDevices)
+        for (auto &device : currentDevices) {
           device->set_isVector();
+        }
       } else if (std::get_if<Fortran::parser::AccClause::Worker>(&clause.u)) {
-        for (auto &device : currentDevices)
+        for (auto &device : currentDevices) {
           device->set_isWorker();
-      } else if (const auto *gangClause =
-                     std::get_if<Fortran::parser::AccClause::Gang>(&clause.u)) {
-        for (auto &device : currentDevices)
+        }
+      } else if (const auto *gangClause{
+                     std::get_if<Fortran::parser::AccClause::Gang>(
+                         &clause.u)}) {
+        for (auto &device : currentDevices) {
           device->set_isGang();
+        }
         if (gangClause->v) {
           const Fortran::parser::AccGangArgList &x = *gangClause->v;
           int numArgs{0};
           for (const Fortran::parser::AccGangArg &gangArg : x.v) {
             CHECK(numArgs <= 1 && "expecting 0 or 1 gang dim args");
-            if (const auto *dim =
-                    std::get_if<Fortran::parser::AccGangArg::Dim>(&gangArg.u)) {
+            if (const auto *dim{std::get_if<Fortran::parser::AccGangArg::Dim>(
+                    &gangArg.u)}) {
               if (const auto v{EvaluateInt64(context_, dim->v)}) {
-                for (auto &device : currentDevices)
+                for (auto &device : currentDevices) {
                   device->set_gangDim(*v);
+                }
               }
             }
             numArgs++;
           }
         }
-      } else if (const auto *bindClause =
-                     std::get_if<Fortran::parser::AccClause::Bind>(&clause.u)) {
-        if (const auto *name =
-                std::get_if<Fortran::parser::Name>(&bindClause->v.u)) {
-          if (Symbol *sym = ResolveFctName(*name)) {
+      } else if (const auto *bindClause{
+                     std::get_if<Fortran::parser::AccClause::Bind>(
+                         &clause.u)}) {
+        if (const auto *name{
+                std::get_if<Fortran::parser::Name>(&bindClause->v.u)}) {
+          if (Symbol * sym{ResolveFctName(*name)}) {
             Symbol &ultimate{sym->GetUltimate()};
-            for (auto &device : currentDevices)
+            for (auto &device : currentDevices) {
               device->set_bindName(SymbolRef(ultimate));
+            }
           } else {
             context_.Say((*name).source,
                 "No function or subroutine declared for '%s'"_err_en_US,
                 (*name).source);
           }
-        } else if (const auto charExpr =
+        } else if (const auto charExpr{
                        std::get_if<Fortran::parser::ScalarDefaultCharExpr>(
-                           &bindClause->v.u)) {
-          auto *charConst =
+                           &bindClause->v.u)}) {
+          auto *charConst{
               Fortran::parser::Unwrap<Fortran::parser::CharLiteralConstant>(
-                  *charExpr);
+                  *charExpr)};
           std::string str{std::get<std::string>(charConst->t)};
-          for (auto &device : currentDevices)
+          for (auto &device : currentDevices) {
             device->set_bindName(std::string(str));
+          }
         }
       }
     }
@@ -3031,3 +3041,5 @@ void OmpAttributeVisitor::IssueNonConformanceWarning(
       warnStrOS.str());
 }
 } // namespace Fortran::semantics
+
+} // namespace Fortran::semantics