[SyntaxTree] Remove dead code on dump functions

[eduucaldas]

Summary

• Node::dumpTokens was never used.
• ::dumpTokens(llvm::raw_ostream, ArrayRef<syntax::Token>, const SourceManager &SM) was used twice, once by Node::dumpTokens. Additionally it always received as parameter a syntax::Token * pointing to one token only, instead of an ArrayRef

I removed the first and inlined a simplified version of the second in its only caller.

[gribozavr2]

Node::dumpTokens was never used.

I think it is because it was meant to be a debugger-only helper. I think we should keep it. However, simplifying static void dumpTokens to only take one token instead of ArrayRef makes sense!

clang/include/clang/Tooling/Syntax/Tree.h

public:
   const Tree *parent() const { return Parent; }
   Tree *parent() { return Parent; }
 
   const Node *nextSibling() const { return NextSibling; }
   Node *nextSibling() { return NextSibling; }
 
   /// Dumps the structure of a subtree. For debugging and testing purposes.
   std::string dump(const Arena &A) const;
-  /// Dumps the tokens forming this subtree.
-  std::string dumpTokens(const Arena &A) const;
 
   /// Asserts invariants on this node of the tree and its immediate children.
   /// Will not recurse into the subtree. No-op if NDEBUG is set.
   void assertInvariants() const;
   /// Runs checkInvariants on all nodes in the subtree. No-op if NDEBUG is set.
   void assertInvariantsRecursive() const;
 
 private:

clang/lib/Tooling/Syntax/Tree.cpp

#endif
   }
 
   // Mark the node as modified.
   for (auto *T = this; T && T->Original; T = T->Parent)
     T->Original = false;
 }
 
 namespace {
-static void dumpTokens(llvm::raw_ostream &OS, ArrayRef<syntax::Token> Tokens,
-                       const SourceManager &SM) {
-  assert(!Tokens.empty());
-  bool First = true;
-  for (const auto &T : Tokens) {
-    if (!First)
-      OS << " ";
-    else
-      First = false;
-    // Handle 'eof' separately, calling text() on it produces an empty string.
-    if (T.kind() == tok::eof) {
-      OS << "<eof>";
-      continue;
-    }
-    OS << T.text(SM);
-  }
-}
-
 static void dumpTree(llvm::raw_ostream &OS, const syntax::Node *N,
                      const syntax::Arena &A, std::vector<bool> IndentMask) {
   std::string Marks;
   if (!N->isOriginal())
     Marks += "M";
   if (N->role() == syntax::NodeRole::Detached)
     Marks += "*"; // FIXME: find a nice way to print other roles.
   if (!N->canModify())
     Marks += "I";
   if (!Marks.empty())
     OS << Marks << ": ";
 
   if (auto *L = llvm::dyn_cast<syntax::Leaf>(N)) {
-    dumpTokens(OS, *L->token(), A.sourceManager());
+    auto *Token = L->token();
+    assert(Token);
+    // Handle 'eof' separately, calling text() on it produces an empty string.
+    if (Token->kind() == tok::eof)
+      OS << "<eof>";
+    else
+      OS << Token->text(A.sourceManager());
     OS << "\n";
     return;
   }
 
   auto *T = llvm::cast<syntax::Tree>(N);
   OS << T->kind() << "\n";
 
-  for (auto It = T->firstChild(); It != nullptr; It = It->nextSibling()) {
+  for (const auto *It = T->firstChild(); It != nullptr;
+       It = It->nextSibling()) {
     for (bool Filled : IndentMask) {
       if (Filled)
         OS << "| ";
       else
         OS << "  ";
     }
     if (!It->nextSibling()) {
       OS << "`-";

 
 std::string syntax::Node::dump(const Arena &A) const {
   std::string Str;
   llvm::raw_string_ostream OS(Str);
   dumpTree(OS, this, A, /*IndentMask=*/{});
   return std::move(OS.str());
 }
 
-std::string syntax::Node::dumpTokens(const Arena &A) const {
-  std::string Storage;
-  llvm::raw_string_ostream OS(Storage);
-  traverse(this, [&](const syntax::Node *N) {
-    auto *L = llvm::dyn_cast<syntax::Leaf>(N);
-    if (!L)
-      return;
-    ::dumpTokens(OS, *L->token(), A.sourceManager());
-    OS << " ";
-  });
-  return OS.str();
-}
-
 void syntax::Node::assertInvariants() const {
 #ifndef NDEBUG
   if (isDetached())
     assert(parent() == nullptr);
   else
     assert(parent() != nullptr);
 
   auto *T = dyn_cast<Tree>(this);