[SyntaxTree] Add const qualifiers, from [llvm-qualified-auto]

clang/lib/Tooling/Syntax/BuildTree.cpp

private:
   ///
   /// Ensures that added nodes properly nest and cover the whole token stream.
   struct Forest {
     Forest(syntax::Arena &A) {
       assert(!A.getTokenBuffer().expandedTokens().empty());
       assert(A.getTokenBuffer().expandedTokens().back().kind() == tok::eof);
       // Create all leaf nodes.
       // Note that we do not have 'eof' in the tree.
-      for (auto &T : A.getTokenBuffer().expandedTokens().drop_back()) {
+      for (const auto &T : A.getTokenBuffer().expandedTokens().drop_back()) {
         auto *L = new (A.getAllocator()) syntax::Leaf(&T);
         L->Original = true;
         L->CanModify = A.getTokenBuffer().spelledForExpanded(T).hasValue();
         Trees.insert(Trees.end(), {&T, L});
       }
     }
 
     void assignRole(ArrayRef<syntax::Token> Range, syntax::NodeRole Role) {

clang/lib/Tooling/Syntax/ComputeReplacements.cpp

void run(const syntax::Tree *Root) {
       // Report the last span to the user.
       if (SpanBegin)
         Callback(llvm::makeArrayRef(SpanBegin, SpanEnd), SpanIsOriginal);
     }
 
   private:
     void process(const syntax::Node *N) {
       if (auto *T = dyn_cast<syntax::Tree>(N)) {
-        for (auto *C = T->getFirstChild(); C != nullptr;
+        for (const auto *C = T->getFirstChild(); C != nullptr;
              C = C->getNextSibling())
           process(C);
         return;
       }
 
       auto *L = cast<syntax::Leaf>(N);
       if (SpanEnd == L->getToken() && SpanIsOriginal == L->isOriginal()) {
         // Extend the current span.
private:
     ProcessTokensFn Callback;
   };
 
   return Enumerator(Callback).run(Root);
 }
 
 syntax::FileRange rangeOfExpanded(const syntax::Arena &A,
                                   llvm::ArrayRef<syntax::Token> Expanded) {
-  auto &Buffer = A.getTokenBuffer();
-  auto &SM = A.getSourceManager();
+  const auto &Buffer = A.getTokenBuffer();
+  const auto &SM = A.getSourceManager();
 
   // Check that \p Expanded actually points into expanded tokens.
   assert(Buffer.expandedTokens().begin() <= Expanded.begin());
   assert(Expanded.end() < Buffer.expandedTokens().end());
 
   if (Expanded.empty())
     // (!) empty tokens must always point before end().
     return syntax::FileRange(
         SM, SM.getExpansionLoc(Expanded.begin()->location()), /*Length=*/0);
 
   auto Spelled = Buffer.spelledForExpanded(Expanded);
   assert(Spelled && "could not find spelled tokens for expanded");
   return syntax::Token::range(SM, Spelled->front(), Spelled->back());
 }
 } // namespace
 
 tooling::Replacements
 syntax::computeReplacements(const syntax::Arena &A,
                             const syntax::TranslationUnit &TU) {
-  auto &Buffer = A.getTokenBuffer();
-  auto &SM = A.getSourceManager();
+  const auto &Buffer = A.getTokenBuffer();
+  const auto &SM = A.getSourceManager();
 
   tooling::Replacements Replacements;
   // Text inserted by the replacement we are building now.
   std::string Replacement;
   auto emitReplacement = [&](llvm::ArrayRef<syntax::Token> ReplacedRange) {
     if (ReplacedRange.empty() && Replacement.empty())
       return;
     llvm::cantFail(Replacements.add(tooling::Replacement(

clang/lib/Tooling/Syntax/Tree.cpp

 #include <cassert>
 
 using namespace clang;
 
 namespace {
 static void traverse(const syntax::Node *N,
                      llvm::function_ref<void(const syntax::Node *)> Visit) {
   if (auto *T = dyn_cast<syntax::Tree>(N)) {
-    for (auto *C = T->getFirstChild(); C; C = C->getNextSibling())
+    for (const auto *C = T->getFirstChild(); C; C = C->getNextSibling())
       traverse(C, Visit);
   }
   Visit(N);
 }
 static void traverse(syntax::Node *N,
                      llvm::function_ref<void(syntax::Node *)> Visit) {
   traverse(static_cast<const syntax::Node *>(N), [&](const syntax::Node *N) {
     Visit(const_cast<syntax::Node *>(N));
#ifndef NDEBUG
   if (isDetached())
     assert(getParent() == nullptr);
   else
     assert(getParent() != nullptr);
 
   auto *T = dyn_cast<Tree>(this);
   if (!T)
     return;
-  for (auto *C = T->getFirstChild(); C; C = C->getNextSibling()) {
+  for (const auto *C = T->getFirstChild(); C; C = C->getNextSibling()) {
     if (T->isOriginal())
       assert(C->isOriginal());
     assert(!C->isDetached());
     assert(C->getParent() == T);
   }
 #endif
 }