[SyntaxTree][NFC][Style] Functions start with lowercase

clang/lib/Tooling/Syntax/BuildTree.cpp

syntax::NodeKind getNameSpecifierKind(const NestedNameSpecifier &NNS) {
     default:
       // FIXME: Support Microsoft's __super
       llvm::report_fatal_error("We don't yet support the __super specifier",
                                true);
     }
   }
 
   syntax::NameSpecifier *
-  BuildNameSpecifier(const NestedNameSpecifierLoc &NNSLoc) {
+  buildNameSpecifier(const NestedNameSpecifierLoc &NNSLoc) {
     assert(NNSLoc.hasQualifier());
     auto NameSpecifierTokens =
         Builder.getRange(getLocalSourceRange(NNSLoc)).drop_back();
     switch (getNameSpecifierKind(*NNSLoc.getNestedNameSpecifier())) {
     case syntax::NodeKind::GlobalNameSpecifier:
       return new (allocator()) syntax::GlobalNameSpecifier;
     case syntax::NodeKind::IdentifierNameSpecifier: {
       assert(NameSpecifierTokens.size() == 1);
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);
+      auto *NS = buildNameSpecifier(it);
       if (!NS)
         return false;
       Builder.markChild(NS, syntax::NodeRole::ListElement);
       Builder.markChildToken(it.getEndLoc(), syntax::NodeRole::ListDelimiter);
     }
     Builder.foldNode(Builder.getRange(QualifierLoc.getSourceRange()),
                      new (allocator()) syntax::NestedNameSpecifier,
                      QualifierLoc);
Builder.foldNode(Builder.getRange(L.getLParenLoc(), L.getEndLoc()),
                      new (allocator()) syntax::ParametersAndQualifiers, L);
     return true;
   }
 
   bool WalkUpFromFunctionProtoTypeLoc(FunctionProtoTypeLoc L) {
     if (!L.getTypePtr()->hasTrailingReturn())
       return WalkUpFromFunctionTypeLoc(L);
 
-    auto *TrailingReturnTokens = BuildTrailingReturn(L);
+    auto *TrailingReturnTokens = buildTrailingReturn(L);
     // Finish building the node for parameters.
     Builder.markChild(TrailingReturnTokens, syntax::NodeRole::TrailingReturn);
     return WalkUpFromFunctionTypeLoc(L);
   }
 
   bool TraverseMemberPointerTypeLoc(MemberPointerTypeLoc L) {
     // In the source code "void (Y::*mp)()" `MemberPointerTypeLoc` corresponds
     // to "Y::*" but it points to a `ParenTypeLoc` that corresponds to
template <class T> bool processDeclaratorAndDeclaration(T *D) {
     if (Builder.isResponsibleForCreatingDeclaration(D)) {
       Builder.foldNode(Builder.getDeclarationRange(D),
                        new (allocator()) syntax::SimpleDeclaration, D);
     }
     return true;
   }
 
   /// Returns the range of the built node.
-  syntax::TrailingReturnType *BuildTrailingReturn(FunctionProtoTypeLoc L) {
+  syntax::TrailingReturnType *buildTrailingReturn(FunctionProtoTypeLoc L) {
     assert(L.getTypePtr()->hasTrailingReturn());
 
     auto ReturnedType = L.getReturnLoc();
     // Build node for the declarator, if any.
     auto ReturnDeclaratorRange =
         getDeclaratorRange(this->Builder.sourceManager(), ReturnedType,
                            /*Name=*/SourceLocation(),
                            /*Initializer=*/SourceLocation());