Run clang-format on clang-rename code

[vmiklos]

Summary

So that later commits don't introduce non-functional changes when
running clang-format before committing.

[klimek]

lg

[omtcyfz]

Actually few changes clang-format would produce weren't there. It's either you used old clang-format or you missed them, but there were header reordering issues. Pushed quick fix.

[vmiklos]

Thanks. Yes, I used the Linux-distro-provided clang-format-3.7, I didn't notice that the trunk version now also sorts includes.

clang-rename/RenamingAction.h

public:
   std::unique_ptr<ASTConsumer> newASTConsumer();
 
 private:
   const std::vector<std::string> &NewNames, &PrevNames;
   const std::vector<std::vector<std::string>> &USRList;
   std::map<std::string, tooling::Replacements> &FileToReplaces;
   bool PrintLocations;
 };
-
 }
 }
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_RENAME_RENAMING_ACTION_H_

clang-rename/USRFinder.h

 
 // Converts a Decl into a USR.
 std::string getUSRForDecl(const Decl *Decl);
 
 // FIXME: Implement RecursiveASTVisitor<T>::VisitNestedNameSpecifier instead.
 class NestedNameSpecifierLocFinder : public MatchFinder::MatchCallback {
 public:
   explicit NestedNameSpecifierLocFinder(ASTContext &Context)
       : Context(Context) {}
 
   std::vector<NestedNameSpecifierLoc> getNestedNameSpecifierLocations() {
     addMatchers();
     Finder.matchAST(Context);
     return Locations;
   }
 
 private:
   void addMatchers() {
     const auto NestedNameSpecifierLocMatcher =
         nestedNameSpecifierLoc().bind("nestedNameSpecifierLoc");
     Finder.addMatcher(NestedNameSpecifierLocMatcher, this);
   }
 
   virtual void run(const MatchFinder::MatchResult &Result) {
-    const auto *NNS =
-        Result.Nodes.getNodeAs<NestedNameSpecifierLoc>("nestedNameSpecifierLoc");
+    const auto *NNS = Result.Nodes.getNodeAs<NestedNameSpecifierLoc>(
+        "nestedNameSpecifierLoc");
     Locations.push_back(*NNS);
   }
 
   ASTContext &Context;
   std::vector<NestedNameSpecifierLoc> Locations;
   MatchFinder Finder;
 };
-
 }
 }
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_RENAME_USR_FINDER_H

clang-rename/USRFindingAction.cpp

 #include "clang/Tooling/CommonOptionsParser.h"
 #include "clang/Tooling/Refactoring.h"
 #include "clang/Tooling/Tooling.h"
 #include <algorithm>
 #include <string>
 #include <set>
 #include <vector>
 
-
 using namespace llvm;
 
 namespace clang {
 namespace rename {
 
 namespace {
 // \brief NamedDeclFindingConsumer should delegate finding USRs of given Decl to
 // AdditionalUSRFinder. AdditionalUSRFinder adds USRs of ctor and dtor if given
 // Decl refers to class and adds USRs of all overridden methods if Decl refers
 // to virtual method.
 class AdditionalUSRFinder : public RecursiveASTVisitor<AdditionalUSRFinder> {
 public:
   explicit AdditionalUSRFinder(const Decl *FoundDecl, ASTContext &Context,
                                std::vector<std::string> *USRs)
       : FoundDecl(FoundDecl), Context(Context), USRs(USRs) {}
 
   void Find() {
     // Fill OverriddenMethods and PartialSpecs storages.
     TraverseDecl(Context.getTranslationUnitDecl());
     if (const auto *MethodDecl = dyn_cast<CXXMethodDecl>(FoundDecl)) {
       addUSRsOfOverridenFunctions(MethodDecl);
       for (const auto &OverriddenMethod : OverriddenMethods) {
         if (checkIfOverriddenFunctionAscends(OverriddenMethod)) {
           USRSet.insert(getUSRForDecl(OverriddenMethod));
         }
       }
     } else if (const auto *RecordDecl = dyn_cast<CXXRecordDecl>(FoundDecl)) {
       handleCXXRecordDecl(RecordDecl);
     } else if (const auto *TemplateDecl =
                    dyn_cast<ClassTemplateDecl>(FoundDecl)) {
       handleClassTemplateDecl(TemplateDecl);
     } else {
       USRSet.insert(getUSRForDecl(FoundDecl));
     }
     USRs->insert(USRs->end(), USRSet.begin(), USRSet.end());
   }
 
   bool VisitCXXMethodDecl(const CXXMethodDecl *MethodDecl) {
     if (MethodDecl->isVirtual()) {
       OverriddenMethods.push_back(MethodDecl);
     }
     return true;
   }
 
   bool VisitClassTemplatePartialSpecializationDecl(
       const ClassTemplatePartialSpecializationDecl *PartialSpec) {
     PartialSpecs.push_back(PartialSpec);
     return true;
   }
 
 private:
   void handleCXXRecordDecl(const CXXRecordDecl *RecordDecl) {
     RecordDecl = RecordDecl->getDefinition();
-    if (const auto *ClassTemplateSpecDecl
-            = dyn_cast<ClassTemplateSpecializationDecl>(RecordDecl)) {
+    if (const auto *ClassTemplateSpecDecl =
+            dyn_cast<ClassTemplateSpecializationDecl>(RecordDecl)) {
       handleClassTemplateDecl(ClassTemplateSpecDecl->getSpecializedTemplate());
     }
     addUSRsOfCtorDtors(RecordDecl);
   }
 
   void handleClassTemplateDecl(const ClassTemplateDecl *TemplateDecl) {
     for (const auto *Specialization : TemplateDecl->specializations()) {
       addUSRsOfCtorDtors(Specialization);
bool checkIfOverriddenFunctionAscends(const CXXMethodDecl *MethodDecl) {
     }
     return false;
   }
 
   const Decl *FoundDecl;
   ASTContext &Context;
   std::vector<std::string> *USRs;
   std::set<std::string> USRSet;
-  std::vector<const CXXMethodDecl*> OverriddenMethods;
-  std::vector<const ClassTemplatePartialSpecializationDecl*> PartialSpecs;
+  std::vector<const CXXMethodDecl *> OverriddenMethods;
+  std::vector<const ClassTemplatePartialSpecializationDecl *> PartialSpecs;
 };
 } // namespace
 
 struct NamedDeclFindingConsumer : public ASTConsumer {
   void HandleTranslationUnit(ASTContext &Context) override {
     const auto &SourceMgr = Context.getSourceManager();
     // The file we look for the USR in will always be the main source file.
     const auto Point = SourceMgr.getLocForStartOfFile(SourceMgr.getMainFileID())