[flang][NFC] Add accessors to equivalence and common blocks

[klausler]

Summary

Add a way to get mutable equivalence sets to Scope so that they can
have sizes and offsets assigned to them.

Change CommonBlockDetails to have mutable symbols so that they can have
sizes and offets assigned to them. This also allows the removal of some
const_casts.

Add MutableSymbolRef and MutableSymbolVector as mutable analogs to
SymbolRef and SymbolVector. Replace uses of equivalent types with those
names.

flang/include/flang/Semantics/scope.h

 //===-- include/flang/Semantics/scope.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
 //
 //===----------------------------------------------------------------------===//
 
struct EquivalenceObject {
 
   Symbol &symbol;
   std::vector<ConstantSubscript> subscripts; // for array elem
   std::optional<ConstantSubscript> substringStart;
 };
 using EquivalenceSet = std::vector<EquivalenceObject>;
 
 class Scope {
-  using mapType = std::map<SourceName, common::Reference<Symbol>>;
+  using mapType = std::map<SourceName, MutableSymbolRef>;
 
 public:
   ENUM_CLASS(Kind, Global, Module, MainProgram, Subprogram, BlockData,
       DerivedType, Block, Forall, ImpliedDos)
   using ImportKind = common::ImportKind;
 
   // Create the Global scope -- the root of the scope tree
   Scope() : Scope{*this, Kind::Global, nullptr} {}
public:
   iterator end() { return symbols_.end(); }
   const_iterator begin() const { return symbols_.begin(); }
   const_iterator end() const { return symbols_.end(); }
   const_iterator cbegin() const { return symbols_.cbegin(); }
   const_iterator cend() const { return symbols_.cend(); }
 
   // Return symbols in declaration order (the iterators above are in name order)
   SymbolVector GetSymbols() const;
-  std::vector<common::Reference<Symbol>> GetSymbols();
+  MutableSymbolVector GetSymbols();
 
   iterator find(const SourceName &name);
   const_iterator find(const SourceName &name) const {
     return symbols_.find(name);
   }
   size_type erase(const SourceName &);
   bool empty() const { return symbols_.empty(); }
 
public:
   common::IfNoLvalue<std::pair<iterator, bool>, D> try_emplace(
       const SourceName &name, Attrs attrs, D &&details) {
     Symbol &symbol{MakeSymbol(name, attrs, std::move(details))};
     return symbols_.emplace(name, symbol);
   }
   // Make a copy of a symbol in this scope; nullptr if one is already there
   Symbol *CopySymbol(const Symbol &);
 
-  const std::list<EquivalenceSet> &equivalenceSets() const;
+  std::list<EquivalenceSet> &equivalenceSets() { return equivalenceSets_; }
+  const std::list<EquivalenceSet> &equivalenceSets() const {
+    return equivalenceSets_;
+  }
   void add_equivalenceSet(EquivalenceSet &&);
   // Cray pointers are saved as map of pointee name -> pointer symbol
   const mapType &crayPointers() const { return crayPointers_; }
   void add_crayPointer(const SourceName &, Symbol &);
   mapType &commonBlocks() { return commonBlocks_; }
   const mapType &commonBlocks() const { return commonBlocks_; }
   Symbol &MakeCommonBlock(const SourceName &);
   Symbol *FindCommonBlock(const SourceName &);

flang/include/flang/Semantics/symbol.h

 //===-- include/flang/Semantics/symbol.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
 //
 //===----------------------------------------------------------------------===//
 

 /// *Details classes.
 
 class Scope;
 class Symbol;
 class ProgramTree;
 
 using SymbolRef = common::Reference<const Symbol>;
 using SymbolVector = std::vector<SymbolRef>;
+using MutableSymbolRef = common::Reference<Symbol>;
+using MutableSymbolVector = std::vector<MutableSymbolRef>;
 
 // A module or submodule.
 class ModuleDetails {
 public:
   ModuleDetails(bool isSubmodule = false) : isSubmodule_{isSubmodule} {}
   bool isSubmodule() const { return isSubmodule_; }
   const Scope *scope() const { return scope_; }
   const Scope *ancestor() const; // for submodule; nullptr for module
public:
   }
 
 private:
   SymbolVector objects_;
 };
 
 class CommonBlockDetails {
 public:
-  const SymbolVector &objects() const { return objects_; }
-  void add_object(const Symbol &object) { objects_.emplace_back(object); }
+  MutableSymbolVector &objects() { return objects_; }
+  const MutableSymbolVector &objects() const { return objects_; }
+  void add_object(Symbol &object) { objects_.emplace_back(object); }
   MaybeExpr bindName() const { return bindName_; }
   void set_bindName(MaybeExpr &&expr) { bindName_ = std::move(expr); }
 
 private:
-  SymbolVector objects_;
+  MutableSymbolVector objects_;
   MaybeExpr bindName_;
 };
 
 class FinalProcDetails {}; // TODO
 
 class MiscDetails {
 public:
   ENUM_CLASS(Kind, None, ConstructName, ScopeName, PassName, ComplexPartRe,

 inline bool ProcEntityDetails::HasExplicitInterface() const {
   if (auto *symbol{interface_.symbol()}) {
     return symbol->HasExplicitInterface();
   }
   return false;
 }
 
 inline bool operator<(SymbolRef x, SymbolRef y) { return *x < *y; }
-inline bool operator<(
-    common::Reference<Symbol> x, common::Reference<Symbol> y) {
+inline bool operator<(MutableSymbolRef x, MutableSymbolRef y) {
   return *x < *y;
 }
 using SymbolSet = std::set<SymbolRef>;
 
 } // namespace Fortran::semantics
 #endif // FORTRAN_SEMANTICS_SYMBOL_H_

flang/lib/Semantics/mod-file.cpp

 //===-- lib/Semantics/mod-file.cpp ----------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
std::visit(common::visitors{
                      decls_ << sep << object.name();
                      sep = ',';
                    }
                    decls_ << '\n';
                  },
                  [&](const CommonBlockDetails &x) {
                    decls_ << "common/" << symbol.name();
                    char sep = '/';
-                   for (const Symbol &object : x.objects()) {
-                     decls_ << sep << object.name();
+                   for (const auto &object : x.objects()) {
+                     decls_ << sep << object->name();
                      sep = ',';
                    }
                    decls_ << '\n';
                    if (symbol.attrs().test(Attr::BIND_C)) {
                      PutAttrs(decls_, symbol.attrs(), x.bindName(), ""s);
                      decls_ << "::/" << symbol.name() << "/\n";
                    }
                  },
std::visit(common::visitors{
                      DoBound(spec.lbound());
                      DoBound(spec.ubound());
                    }
                    if (const Symbol * commonBlock{details.commonBlock()}) {
                      DoSymbol(*commonBlock);
                    }
                  },
                  [this](const CommonBlockDetails &details) {
-                   for (const Symbol &object : details.objects()) {
-                     DoSymbol(object);
+                   for (const auto &object : details.objects()) {
+                     DoSymbol(*object);
                    }
                  },
                  [](const auto &) {},
              },
       symbol.details());
   if (!symbol.has<UseDetails>()) {
     DoType(symbol.GetType());
   }

flang/lib/Semantics/resolve-names.cpp

 //===-- lib/Semantics/resolve-names.cpp -----------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
if (auto *symbol{currScope().FindCommonBlock(name)}) {
               "'%s' appears as a COMMON block in a SAVE statement but not in"
               " a COMMON statement"_err_en_US);
         } else { // C1108
           Say(name,
               "SAVE statement in BLOCK construct may not contain a"
               " common block name '%s'"_err_en_US);
         }
       } else {
-        for (const Symbol &object :
-            symbol->get<CommonBlockDetails>().objects()) {
-          SetSaveAttr(*const_cast<Symbol *>(&object));
+        for (auto &object : symbol->get<CommonBlockDetails>().objects()) {
+          SetSaveAttr(*object);
         }
       }
     }
   }
   if (saveInfo_.saveAll) {
     // Apply SAVE attribute to applicable symbols
     for (auto pair : currScope()) {
       auto &symbol{*pair.second};
std::visit(
           },
           [&](const parser::Name &name) { // common block
             if (auto *symbol{ResolveOmpCommonBlockName(&name)}) {
               CheckMultipleAppearances(
                   name, *symbol, Symbol::Flag::OmpCommonBlock);
               // 2.15.3 When a named common block appears in a list, it has the
               // same meaning as if every explicit member of the common block
               // appeared in the list
-              for (const Symbol &object :
-                  symbol->get<CommonBlockDetails>().objects()) {
-                Symbol &mutableObject{const_cast<Symbol &>(object)};
+              for (auto &object : symbol->get<CommonBlockDetails>().objects()) {
                 if (auto *resolvedObject{
-                        ResolveOmp(mutableObject, ompFlag, currScope())}) {
+                        ResolveOmp(*object, ompFlag, currScope())}) {
                   AddToContextObjectWithDSA(*resolvedObject, ompFlag);
                 }
               }
             } else {
               context_.Say(name.source, // 2.15.3
                   "COMMON block must be declared in the same scoping unit "
                   "in which the OpenMP directive or clause appears"_err_en_US);
             }

flang/lib/Semantics/scope.cpp

 //===-- lib/Semantics/scope.cpp -------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 

 }
 
 Scope &Scope::MakeScope(Kind kind, Symbol *symbol) {
   return children_.emplace_back(*this, kind, symbol);
 }
 
 template <typename T>
 static std::vector<common::Reference<T>> GetSortedSymbols(
-    std::map<SourceName, common::Reference<Symbol>> symbols) {
+    std::map<SourceName, MutableSymbolRef> symbols) {
   std::vector<common::Reference<T>> result;
   result.reserve(symbols.size());
   for (auto &pair : symbols) {
     result.push_back(*pair.second);
   }
   std::sort(result.begin(), result.end());
   return result;
 }
 
-std::vector<common::Reference<Symbol>> Scope::GetSymbols() {
+MutableSymbolVector Scope::GetSymbols() {
   return GetSortedSymbols<Symbol>(symbols_);
 }
 SymbolVector Scope::GetSymbols() const {
   return GetSortedSymbols<const Symbol>(symbols_);
 }
 
 Scope::iterator Scope::find(const SourceName &name) {
   return symbols_.find(name);
Symbol *Scope::CopySymbol(const Symbol &symbol) {
   } else {
     Symbol &result{*pair.first->second};
     result.flags() = symbol.flags();
     result.set_details(common::Clone(symbol.details()));
     return &result;
   }
 }
 
-const std::list<EquivalenceSet> &Scope::equivalenceSets() const {
-  return equivalenceSets_;
-}
 void Scope::add_equivalenceSet(EquivalenceSet &&set) {
   equivalenceSets_.emplace_back(std::move(set));
 }
 
 void Scope::add_crayPointer(const SourceName &name, Symbol &pointer) {
   CHECK(pointer.test(Symbol::Flag::CrayPointer));
   crayPointers_.emplace(name, pointer);
 }

flang/lib/Semantics/symbol.cpp

 //===-- lib/Semantics/symbol.cpp ------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
std::visit(
             DumpOptional(os, "passName", x.passName());
           },
           [&](const NamelistDetails &x) {
             os << ':';
             DumpSymbolVector(os, x.objects());
           },
           [&](const CommonBlockDetails &x) {
             os << ':';
-            for (const Symbol &object : x.objects()) {
-              os << ' ' << object.name();
+            for (const auto &object : x.objects()) {
+              os << ' ' << object->name();
             }
           },
           [&](const FinalProcDetails &) {},
           [&](const TypeParamDetails &x) {
             DumpOptional(os, "type", x.type());
             os << ' ' << common::EnumToString(x.attr());
             DumpExpr(os, "init", x.init());
           },