[SyntaxTree][NFC] follow naming convention + remove auto on empty vector declaration

clang/lib/Tooling/Syntax/BuildTree.cpp

template <class PtrLoc> SourceLocation HandlePointer(PtrLoc T) {
     if (L.isValid())
       return L;
     return T.getLocalSourceRange().getBegin();
   }
 };
 } // namespace
 
 static CallExpr::arg_range dropDefaultArgs(CallExpr::arg_range Args) {
-  auto firstDefaultArg = std::find_if(Args.begin(), Args.end(), [](auto it) {
-    return isa<CXXDefaultArgExpr>(it);
+  auto FirstDefaultArg = std::find_if(Args.begin(), Args.end(), [](auto It) {
+    return isa<CXXDefaultArgExpr>(It);
   });
-  return llvm::make_range(Args.begin(), firstDefaultArg);
+  return llvm::make_range(Args.begin(), FirstDefaultArg);
 }
 
 static syntax::NodeKind getOperatorNodeKind(const CXXOperatorCallExpr &E) {
   switch (E.getOperator()) {
   // Comparison
   case OO_EqualEqual:
   case OO_ExclaimEqual:
   case OO_Greater:
public:
 
   // To build syntax tree nodes for NestedNameSpecifierLoc we override
   // Traverse instead of WalkUpFrom because we want to traverse the children
   // ourselves and build a list instead of a nested tree of name specifier
   // prefixes.
   bool TraverseNestedNameSpecifierLoc(NestedNameSpecifierLoc QualifierLoc) {
     if (!QualifierLoc)
       return true;
-    for (auto it = QualifierLoc; it; it = it.getPrefix()) {
-      auto *NS = buildNameSpecifier(it);
+    for (auto It = QualifierLoc; It; It = It.getPrefix()) {
+      auto *NS = buildNameSpecifier(It);
       if (!NS)
         return false;
       Builder.markChild(NS, syntax::NodeRole::ListElement);
-      Builder.markChildToken(it.getEndLoc(), syntax::NodeRole::ListDelimiter);
+      Builder.markChildToken(It.getEndLoc(), syntax::NodeRole::ListDelimiter);
     }
     Builder.foldNode(Builder.getRange(QualifierLoc.getSourceRange()),
                      new (allocator()) syntax::NestedNameSpecifier,
                      QualifierLoc);
     return true;
   }
 
   syntax::IdExpression *buildIdExpression(NestedNameSpecifierLoc QualifierLoc,

clang/lib/Tooling/Syntax/Nodes.cpp

raw_ostream &syntax::operator<<(raw_ostream &OS, NodeRole R) {
   }
   llvm_unreachable("invalid role");
 }
 
 // We could have an interator in list to not pay memory costs of temporary
 // vector
 std::vector<syntax::NameSpecifier *>
 syntax::NestedNameSpecifier::getSpecifiers() {
-  auto specifiersAsNodes = getElementsAsNodes();
+  auto SpecifiersAsNodes = getElementsAsNodes();
   std::vector<syntax::NameSpecifier *> Children;
-  for (const auto &element : specifiersAsNodes) {
-    Children.push_back(llvm::cast<syntax::NameSpecifier>(element));
+  for (const auto &Element : SpecifiersAsNodes) {
+    Children.push_back(llvm::cast<syntax::NameSpecifier>(Element));
   }
   return Children;
 }
 
 std::vector<syntax::List::ElementAndDelimiter<syntax::NameSpecifier>>
 syntax::NestedNameSpecifier::getSpecifiersAndDoubleColons() {
-  auto specifiersAsNodesAndDoubleColons = getElementsAsNodesAndDelimiters();
+  auto SpecifiersAsNodesAndDoubleColons = getElementsAsNodesAndDelimiters();
   std::vector<syntax::List::ElementAndDelimiter<syntax::NameSpecifier>>
       Children;
-  for (const auto &specifierAndDoubleColon : specifiersAsNodesAndDoubleColons) {
+  for (const auto &SpecifierAndDoubleColon : SpecifiersAsNodesAndDoubleColons) {
     Children.push_back(
-        {llvm::cast<syntax::NameSpecifier>(specifierAndDoubleColon.element),
-         specifierAndDoubleColon.delimiter});
+        {llvm::cast<syntax::NameSpecifier>(SpecifierAndDoubleColon.element),
+         SpecifierAndDoubleColon.delimiter});
   }
   return Children;
 }
 
 std::vector<syntax::Expression *> syntax::CallArguments::getArguments() {
   auto ArgumentsAsNodes = getElementsAsNodes();
   std::vector<syntax::Expression *> Children;
   for (const auto &ArgumentAsNode : ArgumentsAsNodes) {

clang/lib/Tooling/Syntax/Tree.cpp

static void dumpLeaf(raw_ostream &OS, const syntax::Leaf *L,
   if (Token->kind() == tok::eof)
     OS << "<eof>";
   else
     OS << Token->text(SM);
 }
 
 static void dumpNode(raw_ostream &OS, const syntax::Node *N,
                      const SourceManager &SM, std::vector<bool> IndentMask) {
-  auto dumpExtraInfo = [&OS](const syntax::Node *N) {
+  auto DumpExtraInfo = [&OS](const syntax::Node *N) {
     if (N->getRole() != syntax::NodeRole::Unknown)
       OS << " " << N->getRole();
     if (!N->isOriginal())
       OS << " synthesized";
     if (!N->canModify())
       OS << " unmodifiable";
   };
 
   assert(N);
   if (const auto *L = dyn_cast<syntax::Leaf>(N)) {
     OS << "'";
     dumpLeaf(OS, L, SM);
     OS << "'";
-    dumpExtraInfo(N);
+    DumpExtraInfo(N);
     OS << "\n";
     return;
   }
 
   const auto *T = cast<syntax::Tree>(N);
   OS << T->getKind();
-  dumpExtraInfo(N);
+  DumpExtraInfo(N);
   OS << "\n";
 
   for (const auto *It = T->getFirstChild(); It; It = It->getNextSibling()) {
     for (bool Filled : IndentMask) {
       if (Filled)
         OS << "| ";
       else
         OS << "  ";
bool syntax::List::classof(const syntax::Node *N) {
   }
 }
 
 std::vector<syntax::List::ElementAndDelimiter<syntax::Node>>
 syntax::List::getElementsAsNodesAndDelimiters() {
   if (!getFirstChild())
     return {};
 
-  auto children = std::vector<syntax::List::ElementAndDelimiter<Node>>();
-  syntax::Node *elementWithoutDelimiter = nullptr;
+  std::vector<syntax::List::ElementAndDelimiter<Node>> Children;
+  syntax::Node *ElementWithoutDelimiter = nullptr;
   for (auto *C = getFirstChild(); C; C = C->getNextSibling()) {
     switch (C->getRole()) {
     case syntax::NodeRole::ListElement: {
-      if (elementWithoutDelimiter) {
-        children.push_back({elementWithoutDelimiter, nullptr});
+      if (ElementWithoutDelimiter) {
+        Children.push_back({ElementWithoutDelimiter, nullptr});
       }
-      elementWithoutDelimiter = C;
+      ElementWithoutDelimiter = C;
       break;
     }
     case syntax::NodeRole::ListDelimiter: {
-      children.push_back({elementWithoutDelimiter, cast<syntax::Leaf>(C)});
-      elementWithoutDelimiter = nullptr;
+      Children.push_back({ElementWithoutDelimiter, cast<syntax::Leaf>(C)});
+      ElementWithoutDelimiter = nullptr;
       break;
     }
     default:
       llvm_unreachable(
           "A list can have only elements and delimiters as children.");
     }
   }
 
   switch (getTerminationKind()) {
   case syntax::List::TerminationKind::Separated: {
-    children.push_back({elementWithoutDelimiter, nullptr});
+    Children.push_back({ElementWithoutDelimiter, nullptr});
     break;
   }
   case syntax::List::TerminationKind::Terminated:
   case syntax::List::TerminationKind::MaybeTerminated: {
-    if (elementWithoutDelimiter) {
-      children.push_back({elementWithoutDelimiter, nullptr});
+    if (ElementWithoutDelimiter) {
+      Children.push_back({ElementWithoutDelimiter, nullptr});
     }
     break;
   }
   }
 
-  return children;
+  return Children;
 }
 
 // Almost the same implementation of `getElementsAsNodesAndDelimiters` but
 // ignoring delimiters
 std::vector<syntax::Node *> syntax::List::getElementsAsNodes() {
   if (!getFirstChild())
     return {};
 
-  auto children = std::vector<syntax::Node *>();
-  syntax::Node *elementWithoutDelimiter = nullptr;
+  std::vector<syntax::Node *> Children;
+  syntax::Node *ElementWithoutDelimiter = nullptr;
   for (auto *C = getFirstChild(); C; C = C->getNextSibling()) {
     switch (C->getRole()) {
     case syntax::NodeRole::ListElement: {
-      if (elementWithoutDelimiter) {
-        children.push_back(elementWithoutDelimiter);
+      if (ElementWithoutDelimiter) {
+        Children.push_back(ElementWithoutDelimiter);
       }
-      elementWithoutDelimiter = C;
+      ElementWithoutDelimiter = C;
       break;
     }
     case syntax::NodeRole::ListDelimiter: {
-      children.push_back(elementWithoutDelimiter);
-      elementWithoutDelimiter = nullptr;
+      Children.push_back(ElementWithoutDelimiter);
+      ElementWithoutDelimiter = nullptr;
       break;
     }
     default:
       llvm_unreachable("A list has only elements or delimiters.");
     }
   }
 
   switch (getTerminationKind()) {
   case syntax::List::TerminationKind::Separated: {
-    children.push_back(elementWithoutDelimiter);
+    Children.push_back(ElementWithoutDelimiter);
     break;
   }
   case syntax::List::TerminationKind::Terminated:
   case syntax::List::TerminationKind::MaybeTerminated: {
-    if (elementWithoutDelimiter) {
-      children.push_back(elementWithoutDelimiter);
+    if (ElementWithoutDelimiter) {
+      Children.push_back(ElementWithoutDelimiter);
     }
     break;
   }
   }
 
-  return children;
+  return Children;
 }
 
 clang::tok::TokenKind syntax::List::getDelimiterTokenKind() const {
   switch (this->getKind()) {
   case NodeKind::NestedNameSpecifier:
     return clang::tok::coloncolon;
   case NodeKind::CallArguments:
   case NodeKind::ParameterDeclarationList: