[flang][NFC] Add debug dump method to evaluate::Expr and semantics::Symbol

[jeanPerier]

Summary

Helps debugging when working with symbol/expression issue. The dump
method is easy to call in the debugger.

Co-authored-by: Eric Schweitz <[e-mail]>

[klausler]

flang/lib/Evaluate/expression.cpp

21

This inclusion could be conditional to reduce dependencies in non-debug builds.

[jeanPerier]

Remove useless Config.h include, it is include indirectly by raw_ostream.h

flang/include/flang/Evaluate/expression.h

template <typename A> common::IfNoLvalue<Derived &, A> operator=(A &&x) {
     Derived &d{derived()};
     d.u = std::move(x);
     return d;
   }
 
   std::optional<DynamicType> GetType() const;
   int Rank() const;
   std::string AsFortran() const;
+#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+  LLVM_DUMP_METHOD void dump() const;
+#endif
   llvm::raw_ostream &AsFortran(llvm::raw_ostream &) const;
   static Derived Rewrite(FoldingContext &, Derived &&);
 };
 
 // Operations always have specific Fortran result types (i.e., with known
 // intrinsic type category and kind parameter value).  The classes that
 // represent the operations all inherit from this Operation<> base class
 // template.  Note that Operation has as its first type parameter (DERIVED) a

flang/include/flang/Semantics/symbol.h

public:
   }
 
   // If there is a parent component, return a pointer to its derived type spec.
   // The Scope * argument defaults to this->scope_ but should be overridden
   // for a parameterized derived type instantiation with the instance's scope.
   const DerivedTypeSpec *GetParentTypeSpec(const Scope * = nullptr) const;
 
   SemanticsContext &GetSemanticsContext() const;
+#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+  LLVM_DUMP_METHOD void dump() const;
+#endif
 
 private:
   const Scope *owner_;
   SourceName name_;
   Attrs attrs_;
   Flags flags_;
   Scope *scope_{nullptr};
   std::size_t size_{0}; // size in bytes

flang/lib/Evaluate/expression.cpp

 #include "flang/Evaluate/tools.h"
 #include "flang/Evaluate/variable.h"
 #include "flang/Parser/char-block.h"
 #include "flang/Parser/message.h"
 #include "flang/Semantics/scope.h"
 #include "flang/Semantics/symbol.h"
 #include "flang/Semantics/tools.h"
 #include "flang/Semantics/type.h"
 #include "llvm/Support/raw_ostream.h"
 #include <string>
 #include <type_traits>
 
 using namespace Fortran::parser::literals;
 
 namespace Fortran::evaluate {
 
 template <int KIND>
return std::visit(
       },
       derived().u);
 }
 
 DynamicType Parentheses<SomeDerived>::GetType() const {
   return left().GetType().value();
 }
 
+#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+template <typename A> LLVM_DUMP_METHOD void ExpressionBase<A>::dump() const {
+  llvm::errs() << "Expr is <{" << AsFortran() << "}>\n";
+}
+#endif
+
 // Equality testing
 
 bool ImpliedDoIndex::operator==(const ImpliedDoIndex &that) const {
   return name == that.name;
 }
 
 template <typename T>
 bool ImpliedDo<T>::operator==(const ImpliedDo<T> &that) const {

flang/lib/Semantics/symbol.cpp

llvm::raw_ostream &operator<<(llvm::raw_ostream &os, const Symbol &symbol) {
   }
   if (symbol.size_) {
     os << " size=" << symbol.size_ << " offset=" << symbol.offset_;
   }
   os << ": " << symbol.details_;
   return os;
 }
 
+#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+void Symbol::dump() const { llvm::errs() << *this << '\n'; }
+#endif
+
 // Output a unique name for a scope by qualifying it with the names of
 // parent scopes. For scopes without corresponding symbols, use the kind
 // with an index (e.g. Block1, Block2, etc.).
 static void DumpUniqueName(llvm::raw_ostream &os, const Scope &scope) {
   if (!scope.IsGlobal()) {
     DumpUniqueName(os, scope.parent());
     os << '/';
     if (auto *scopeSymbol{scope.symbol()};