[clang-move] Move all code from old.h/cc directly when moving all class declarations from old.h.

[hokein]

Summary

When moving all code to new.h/cc, these code also will be formatted based on the given code style.

[hokein]

Update.

[ioeric]

First round of comments.

The patch summary says "one moved declaration." Why it is just one moved declaration? Doesn't this also support moving all classes in one file?

Maybe also mention the new behavior in the class comment.

clang-move/ClangMove.h

72

It took me a while to understand this comment...

IIUC, this is the source range of the #include directive of old.h (i.e. #include "old.h") in old.cc?

108

What about trailing comments or whitespaces?

test/clang-move/Inputs/test.h

3

Maybe add some white spaces or something in the file to demonstrate that the file is copied over.

unittests/clang-move/ClangMoveTests.cpp

267

Can you add tests for move all (multiple) classes in file?

Not related to this patch...but it seems that we are missing test case for moving template class?

278

Maybe just insert or push back?

280

Where is foo.cc?

299

I think using namespace decl should also be ignored?

[hokein]

Address review comments.

[hokein]

The patch summary says "one moved declaration." Why it is just one moved declaration? Doesn't this also support moving all classes in one file?

Oh, the patch summary is not totally correct. It actually does what you mention above. Have updated the summary.

clang-move/ClangMove.h

72

Sorry for the confusion.

Indeed this a range for the written file name of #include, i.e. if the #include is #include "old.h", then the range here is for "old.h". Have updated the comment.

108

The trailing comments or whitespaces will be ignored here. We just copy this field from InclusionDirective interface, and seems there is no explicit way to retrieve the comments or whitespaces.

unittests/clang-move/ClangMoveTests.cpp

267

Not related to this patch...but it seems that we are missing test case for moving template class?

Yeah, moving template classes doesn't support perfectly right now.

278

I think using insert or push_back doesn't make the code as clear as initialization here. Code readers might pull up the source file to find the code for the initialized value of this variable.

280

The Code variable above represents the source code of foo.cc.

299

This case should rarely happen in source code, as many code styles prohibit using-namespace decls in headers.
I'd like to keep the current behavior because the using-namespace decl will populate the namespace in all the files which include this header. Ignoring it might break a lot of code.

[ioeric]

unittests/clang-move/ClangMoveTests.cpp

278

But you have only one element here right? With those, you wouldn't need std::string(...) I guess.

299

But if you are moving the whole file, using namespace would also be moved so that code would not break?

[hokein]

Fix remaining comments.

[ioeric]

Lg with a few nits.

clang-move/ClangMove.cpp

538

I'd probably pull this out as an inline function to save some typing.

inline std::string ClangMoveTool::MakeAbsolute(Path) {
    return MakeAbsolutePath(OriginalRunningDirectory, OldFile));
}

unittests/clang-move/ClangMoveTests.cpp

286

Please also check old header is removed or empty.

329

Please also check old headers.

[hokein]

Update test to check old header.

clang-move/ClangMove.h

 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_MOVE_CLANGMOVE_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_MOVE_CLANGMOVE_H
 
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/Frontend/FrontendAction.h"
 #include "clang/Tooling/Core/Replacement.h"
 #include "clang/Tooling/Tooling.h"
 #include <map>
+#include <set>
 #include <string>
 #include <vector>
 
 namespace clang {
 namespace move {
 
 // FIXME: Make it support more types, e.g. function definitions.
 // Currently only support moving class definition.
public:
   /// Add #includes from old.h/cc files.
   ///
   /// \param IncludeHeader The name of the file being included, as written in
   /// the source code.
   /// \param IsAngled Whether the file name was enclosed in angle brackets.
   /// \param SearchPath The search path which was used to find the IncludeHeader
   /// in the file system. It can be a relative path or an absolute path.
   /// \param FileName The name of file where the IncludeHeader comes from.
   /// \param SM The SourceManager.
   void addIncludes(llvm::StringRef IncludeHeader,
                    bool IsAngled,
                    llvm::StringRef SearchPath,
                    llvm::StringRef FileName,
+                   clang::CharSourceRange IncludeRange,
                    const SourceManager& SM);
 
 private:
   void removeClassDefinitionInOldFiles();
   void moveClassDefinitionToNewFiles();
+  void moveAll(SourceManager& SM, StringRef OldFile, StringRef NewFile);
 
   MoveDefinitionSpec Spec;
   // The Key is file path, value is the replacements being applied to the file.
   std::map<std::string, tooling::Replacements> &FileToReplacements;
   // All declarations (the class decl being moved, forward decls) that need to
   // be moved/copy to the new files, saving in an AST-visited order.
   std::vector<MovedDecl> MovedDecls;
   // The declarations that needs to be removed in old.cc/h.
   std::vector<MovedDecl> RemovedDecls;
   // The #includes in old_header.h.
   std::vector<std::string> HeaderIncludes;
   // The #includes in old_cc.cc.
   std::vector<std::string> CCIncludes;
   // The original working directory where the local clang-move binary runs.
   //
   // clang-move will change its current working directory to the build
   // directory when analyzing the source file. We save the original working
   // directory in order to get the absolute file path for the fields in Spec.
   std::string OriginalRunningDirectory;
   // The name of a predefined code style.
   std::string FallbackStyle;
+  // The unmoved named declarations in old header.
+  std::set<const NamedDecl*> UnremovedDeclsInOldHeader;
+  // The source range for the old.h of #include in old.cc, including the
+  // enclosing quotes or angle brackets.
+  clang::CharSourceRange OldHeaderIncludeRange;
 };
 
 class ClangMoveAction : public clang::ASTFrontendAction {
 public:
   ClangMoveAction(
       const ClangMoveTool::MoveDefinitionSpec &spec,
       std::map<std::string, tooling::Replacements> &FileToReplacements,
       llvm::StringRef OriginalRunningDirectory, llvm::StringRef FallbackStyle)

clang-move/ClangMove.cpp

 class FindAllIncludes : public clang::PPCallbacks {
 public:
   explicit FindAllIncludes(SourceManager *SM, ClangMoveTool *const MoveTool)
       : SM(*SM), MoveTool(MoveTool) {}
 
   void InclusionDirective(clang::SourceLocation HashLoc,
                           const clang::Token & /*IncludeTok*/,
                           StringRef FileName, bool IsAngled,
-                          clang::CharSourceRange /*FilenameRange*/,
+                          clang::CharSourceRange FilenameRange,
                           const clang::FileEntry * /*File*/,
                           StringRef SearchPath, StringRef /*RelativePath*/,
                           const clang::Module * /*Imported*/) override {
     if (const auto *FileEntry = SM.getFileEntryForID(SM.getFileID(HashLoc)))
       MoveTool->addIncludes(FileName, IsAngled, SearchPath,
-                            FileEntry->getName(), SM);
+                            FileEntry->getName(), FilenameRange, SM);
   }
 
 private:
   const SourceManager &SM;
   ClangMoveTool *const MoveTool;
 };
 
 // Expand to get the end location of the line where the EndLoc of the given
void ClangMoveTool::registerMatchers(ast_matchers::MatchFinder *Finder) {
   auto InOldHeader = isExpansionInFile(
       MakeAbsolutePath(OriginalRunningDirectory, Spec.OldHeader));
   auto InOldCC = isExpansionInFile(
       MakeAbsolutePath(OriginalRunningDirectory, Spec.OldCC));
   auto InOldFiles = anyOf(InOldHeader, InOldCC);
   auto InMovedClass =
       hasOutermostEnclosingClass(cxxRecordDecl(*InMovedClassNames));
 
+  auto ForwardDecls =
+      cxxRecordDecl(unless(anyOf(isImplicit(), isDefinition())));
+
+  //============================================================================
+  // Matchers for old header
+  //============================================================================
+  // Match all top-level named declarations (e.g. function, variable, enum) in
+  // old header, except forward class declarations and namespace declarations.
+  //
+  // The old header which contains only one declaration being moved and forward
+  // declarations is considered to be moved totally.
+  auto AllDeclsInHeader = namedDecl(
+      unless(ForwardDecls), unless(namespaceDecl()),
+      unless(classTemplateDecl(has(ForwardDecls))), // template forward decl.
+      InOldHeader,
+      hasParent(decl(anyOf(namespaceDecl(), translationUnitDecl()))));
+  Finder->addMatcher(AllDeclsInHeader.bind("decls_in_header"), this);
+  // Match forward declarations in old header.
+  Finder->addMatcher(namedDecl(ForwardDecls, InOldHeader).bind("fwd_decl"),
+                     this);
+
+  //============================================================================
+  // Matchers for old files, including old.h/old.cc
+  //============================================================================
   // Match moved class declarations.
   auto MovedClass = cxxRecordDecl(
       InOldFiles, *InMovedClassNames, isDefinition(),
       hasDeclContext(anyOf(namespaceDecl(), translationUnitDecl())));
   Finder->addMatcher(MovedClass.bind("moved_class"), this);
-
   // Match moved class methods (static methods included) which are defined
   // outside moved class declaration.
   Finder->addMatcher(
       cxxMethodDecl(InOldFiles, ofOutermostEnclosingClass(*InMovedClassNames),
                     isDefinition())
           .bind("class_method"),
       this);
 
+  //============================================================================
+  // Matchers for old cc
+  //============================================================================
   // Match static member variable definition of the moved class.
   Finder->addMatcher(varDecl(InMovedClass, InOldCC, isDefinition(),
                              isStaticDataMember())
                          .bind("class_static_var_decl"),
                      this);
 
   auto InOldCCNamedNamespace =
       allOf(hasParent(namespaceDecl(unless(isAnonymous()))), InOldCC);
void ClangMoveTool::registerMatchers(ast_matchers::MatchFinder *Finder) {
   auto IsOldCCStaticDefinition =
       allOf(isDefinition(), unless(InMovedClass), InOldCCNamedNamespace,
             isStaticStorageClass());
   Finder->addMatcher(
       namedDecl(anyOf(functionDecl(IsOldCCStaticDefinition),
                       varDecl(IsOldCCStaticDefinition)))
           .bind("static_decls"),
       this);
-
-  // Match forward declarations in old header.
-  Finder->addMatcher(
-      cxxRecordDecl(unless(anyOf(isImplicit(), isDefinition())), InOldHeader)
-          .bind("fwd_decl"),
-      this);
 }
 
 void ClangMoveTool::run(const ast_matchers::MatchFinder::MatchResult &Result) {
-  if (const auto *CMD =
+  if (const auto *D =
+          Result.Nodes.getNodeAs<clang::NamedDecl>("decls_in_header")) {
+    UnremovedDeclsInOldHeader.insert(D);
+  } else if (const auto *CMD =
           Result.Nodes.getNodeAs<clang::CXXMethodDecl>("class_method")) {
     // Skip inline class methods. isInline() ast matcher doesn't ignore this
     // case.
     if (!CMD->isInlined()) {
       MovedDecls.emplace_back(CMD, &Result.Context->getSourceManager());
       RemovedDecls.push_back(MovedDecls.back());
     }
   } else if (const auto *VD = Result.Nodes.getNodeAs<clang::VarDecl>(
                  "class_static_var_decl")) {
     MovedDecls.emplace_back(VD, &Result.Context->getSourceManager());
     RemovedDecls.push_back(MovedDecls.back());
   } else if (const auto *class_decl =
                  Result.Nodes.getNodeAs<clang::CXXRecordDecl>("moved_class")) {
     MovedDecls.emplace_back(class_decl, &Result.Context->getSourceManager());
     RemovedDecls.push_back(MovedDecls.back());
+    UnremovedDeclsInOldHeader.erase(class_decl);
   } else if (const auto *FWD =
                  Result.Nodes.getNodeAs<clang::CXXRecordDecl>("fwd_decl")) {
     // Skip all forwad declarations which appear after moved class declaration.
     if (RemovedDecls.empty()) {
       if (const auto *DCT = FWD->getDescribedClassTemplate()) {
         MovedDecls.emplace_back(DCT, &Result.Context->getSourceManager());
       } else {
         MovedDecls.emplace_back(FWD, &Result.Context->getSourceManager());
if (const auto *D =
     MovedDecls.emplace_back(UD, &Result.Context->getSourceManager());
   }
 }
 
 void ClangMoveTool::addIncludes(llvm::StringRef IncludeHeader,
                                 bool IsAngled,
                                 llvm::StringRef SearchPath,
                                 llvm::StringRef FileName,
+                                clang::CharSourceRange IncludeRange,
                                 const SourceManager& SM) {
   SmallVector<char, 128> HeaderWithSearchPath;
   llvm::sys::path::append(HeaderWithSearchPath, SearchPath, IncludeHeader);
   std::string AbsoluteOldHeader =
       MakeAbsolutePath(OriginalRunningDirectory, Spec.OldHeader);
   // FIXME: Add old.h to the new.cc/h when the new target has dependencies on
   // old.h/c. For instance, when moved class uses another class defined in
   // old.h, the old.h should be added in new.h.
   if (AbsoluteOldHeader ==
       MakeAbsolutePath(SM, llvm::StringRef(HeaderWithSearchPath.data(),
-                                           HeaderWithSearchPath.size())))
+                                           HeaderWithSearchPath.size()))) {
+    OldHeaderIncludeRange = IncludeRange;
     return;
+  }
 
   std::string IncludeLine =
       IsAngled ? ("#include <" + IncludeHeader + ">\n").str()
                : ("#include \"" + IncludeHeader + "\"\n").str();
 
   std::string AbsoluteCurrentFile = MakeAbsolutePath(SM, FileName);
   if (AbsoluteOldHeader == AbsoluteCurrentFile) {
     HeaderIncludes.push_back(IncludeLine);
void ClangMoveTool::moveClassDefinitionToNewFiles() {
   if (!Spec.NewHeader.empty())
     FileToReplacements[Spec.NewHeader] = createInsertedReplacements(
         HeaderIncludes, NewHeaderDecls, Spec.NewHeader, /*IsHeader=*/true);
   if (!Spec.NewCC.empty())
     FileToReplacements[Spec.NewCC] =
         createInsertedReplacements(CCIncludes, NewCCDecls, Spec.NewCC);
 }
 
+// Move all contents from OldFile to NewFile.
+void ClangMoveTool::moveAll(SourceManager &SM, StringRef OldFile,
+                            StringRef NewFile) {
+  const FileEntry *FE = SM.getFileManager().getFile(
+      MakeAbsolutePath(OriginalRunningDirectory, OldFile));
+  if (!FE) {
+    llvm::errs() << "Failed to get file: " << OldFile << "\n";
+    return;
+  }
+  FileID ID = SM.getOrCreateFileID(FE, SrcMgr::C_User);
+  auto Begin = SM.getLocForStartOfFile(ID);
+  auto End = SM.getLocForEndOfFile(ID);
+  clang::tooling::Replacement RemoveAll (
+      SM, clang::CharSourceRange::getCharRange(Begin, End), "");
+  std::string FilePath = RemoveAll.getFilePath().str();
+  FileToReplacements[FilePath] = clang::tooling::Replacements(RemoveAll);
+
+  StringRef Code = SM.getBufferData(ID);
+  if (!NewFile.empty()) {
+    auto AllCode = clang::tooling::Replacements(
+        clang::tooling::Replacement(NewFile, 0, 0, Code));
+    // If we are moving from old.cc, an extra step is required: excluding
+    // the #include of "old.h", instead, we replace it with #include of "new.h".
+    if (Spec.NewCC == NewFile && OldHeaderIncludeRange.isValid()) {
+      AllCode = AllCode.merge(
+          clang::tooling::Replacements(clang::tooling::Replacement(
+              SM, OldHeaderIncludeRange, '"' + Spec.NewHeader + '"')));
+    }
+    FileToReplacements[NewFile] = std::move(AllCode);
+  }
+}
+
 void ClangMoveTool::onEndOfTranslationUnit() {
   if (RemovedDecls.empty())
     return;
+  if (UnremovedDeclsInOldHeader.empty() && !Spec.OldHeader.empty()) {
+    auto &SM = *RemovedDecls[0].SM;
+    moveAll(SM, Spec.OldHeader, Spec.NewHeader);
+    moveAll(SM, Spec.OldCC, Spec.NewCC);
+    return;
+  }
   removeClassDefinitionInOldFiles();
   moveClassDefinitionToNewFiles();
 }
 
 } // namespace move
 } // namespace clang

test/clang-move/Inputs/test.h

+#ifndef TEST_H
+#define TEST_H
 namespace a {
 class Foo {
 public:
   int f();
   int f2(int a, int b);
 };
 } // namespace a
+#endif // TEST_H

test/clang-move/move-class.cpp

 // RUN: mkdir -p %T/clang-move/build
 // RUN: mkdir -p %T/clang-move/include
 // RUN: mkdir -p %T/clang-move/src
 // RUN: sed 's|$test_dir|%/T/clang-move|g' %S/Inputs/database_template.json > %T/clang-move/compile_commands.json
 // RUN: cp %S/Inputs/test.h  %T/clang-move/include
 // RUN: cp %S/Inputs/test.cpp %T/clang-move/src
 // RUN: touch %T/clang-move/include/test2.h
 // RUN: cd %T/clang-move/build
 // RUN: clang-move -names="a::Foo" -new_cc=%T/clang-move/new_test.cpp -new_header=%T/clang-move/new_test.h -old_cc=../src/test.cpp -old_header=../include/test.h %T/clang-move/src/test.cpp
 // RUN: FileCheck -input-file=%T/clang-move/new_test.cpp -check-prefix=CHECK-NEW-TEST-CPP %s
 // RUN: FileCheck -input-file=%T/clang-move/new_test.h -check-prefix=CHECK-NEW-TEST-H %s
-// RUN: FileCheck -input-file=%T/clang-move/src/test.cpp -check-prefix=CHECK-OLD-TEST-CPP %s
-// RUN: FileCheck -input-file=%T/clang-move/include/test.h %s -implicit-check-not='{{namespace.*}}'
+// RUN: FileCheck -input-file=%T/clang-move/src/test.cpp -check-prefix=CHECK-OLD-TEST-EMPTY -allow-empty %s
+// RUN: FileCheck -input-file=%T/clang-move/include/test.h -check-prefix=CHECK-OLD-TEST-EMPTY -allow-empty %s
 //
 // RUN: cp %S/Inputs/test.h  %T/clang-move/include
 // RUN: cp %S/Inputs/test.cpp %T/clang-move/src
 // RUN: cd %T/clang-move/build
 // RUN: clang-move -names="a::Foo" -new_cc=%T/clang-move/new_test.cpp -new_header=%T/clang-move/new_test.h -old_cc=%T/clang-move/src/test.cpp -old_header=%T/clang-move/include/test.h %T/clang-move/src/test.cpp
 // RUN: FileCheck -input-file=%T/clang-move/new_test.cpp -check-prefix=CHECK-NEW-TEST-CPP %s
 // RUN: FileCheck -input-file=%T/clang-move/new_test.h -check-prefix=CHECK-NEW-TEST-H %s
-// RUN: FileCheck -input-file=%T/clang-move/src/test.cpp -check-prefix=CHECK-OLD-TEST-CPP %s
-// RUN: FileCheck -input-file=%T/clang-move/include/test.h %s -implicit-check-not='{{namespace.*}}'
+// RUN: FileCheck -input-file=%T/clang-move/src/test.cpp -check-prefix=CHECK-OLD-TEST-EMPTY -allow-empty %s
+// RUN: FileCheck -input-file=%T/clang-move/include/test.h -check-prefix=CHECK-OLD-TEST-EMPTY -allow-empty %s
 //
 //
-// CHECK-NEW-TEST-H: #ifndef {{.*}}CLANG_MOVE_NEW_TEST_H
-// CHECK-NEW-TEST-H: #define {{.*}}CLANG_MOVE_NEW_TEST_H
+// CHECK-NEW-TEST-H: #ifndef TEST_H
+// CHECK-NEW-TEST-H: #define TEST_H
 // CHECK-NEW-TEST-H: namespace a {
 // CHECK-NEW-TEST-H: class Foo {
 // CHECK-NEW-TEST-H: public:
 // CHECK-NEW-TEST-H:   int f();
 // CHECK-NEW-TEST-H:   int f2(int a, int b);
 // CHECK-NEW-TEST-H: };
 // CHECK-NEW-TEST-H: } // namespace a
-// CHECK-NEW-TEST-H: #endif // {{.*}}CLANG_MOVE_NEW_TEST_H
+// CHECK-NEW-TEST-H: #endif // TEST_H
 //
 // CHECK-NEW-TEST-CPP: #include "{{.*}}new_test.h"
 // CHECK-NEW-TEST-CPP: #include "test2.h"
 // CHECK-NEW-TEST-CPP: namespace a {
 // CHECK-NEW-TEST-CPP: int Foo::f() { return 0; }
 // CHECK-NEW-TEST-CPP: int Foo::f2(int a, int b) { return a + b; }
 // CHECK-NEW-TEST-CPP: } // namespace a
 //
-// CHECK-OLD-TEST-CPP: #include "test.h"
-// CHECK-OLD-TEST-CPP: #include "test2.h"
+// CHECK-OLD-TEST-EMPTY: {{^}}{{$}}

unittests/clang-move/ClangMoveTests.cpp

const char ExpectedNewCC[] = "namespace a {\n"
                              "/////////////\n"
                              "// comment //\n"
                              "/////////////\n"
                              "int Foo::b = 2;\n"
                              "} // namespace b\n"
                              "} // namespace a\n";
 
 std::map<std::string, std::string>
-runClangMoveOnCode(const move::ClangMoveTool::MoveDefinitionSpec &Spec) {
+runClangMoveOnCode(const move::ClangMoveTool::MoveDefinitionSpec &Spec,
+                   const char *const Header = TestHeader,
+                   const char *const CC = TestCC) {
   clang::RewriterTestContext Context;
 
   std::map<llvm::StringRef, clang::FileID> FileToFileID;
   std::vector<std::pair<std::string, std::string>> FileToSourceText = {
-      {TestHeaderName, TestHeader}, {TestCCName, TestCC}};
+      {TestHeaderName, Header}, {TestCCName, CC}};
 
   auto CreateFiles = [&FileToSourceText, &Context, &FileToFileID](
       llvm::StringRef Name, llvm::StringRef Code) {
     if (!Name.empty()) {
-      FileToSourceText.emplace_back(Name, Code);
       FileToFileID[Name] = Context.createInMemoryFile(Name, Code);
     }
   };
   CreateFiles(Spec.NewCC, "");
   CreateFiles(Spec.NewHeader, "");
-  CreateFiles(Spec.OldHeader, TestHeader);
-  CreateFiles(Spec.OldCC, TestCC);
+  CreateFiles(Spec.OldHeader, Header);
+  CreateFiles(Spec.OldCC, CC);
 
   std::map<std::string, tooling::Replacements> FileToReplacements;
   llvm::SmallString<128> InitialDirectory;
   std::error_code EC = llvm::sys::fs::current_path(InitialDirectory);
   assert(!EC);
   (void)EC;
   auto Factory = llvm::make_unique<clang::move::ClangMoveActionFactory>(
       Spec, FileToReplacements, InitialDirectory.str(), "LLVM");
 
   tooling::runToolOnCodeWithArgs(
-      Factory->create(), TestCC, {"-std=c++11", "-fparse-all-comments"},
+      Factory->create(), CC, {"-std=c++11", "-fparse-all-comments"},
       TestCCName, "clang-move", std::make_shared<PCHContainerOperations>(),
       FileToSourceText);
   formatAndApplyAllReplacements(FileToReplacements, Context.Rewrite, "llvm");
   // The Key is file name, value is the new code after moving the class.
   std::map<std::string, std::string> Results;
   for (const auto &It : FileToReplacements) {
     StringRef FilePath = It.first;
     Results[FilePath] = Context.getRewrittenText(FileToFileID[FilePath]);
TEST(ClangMove, MoveNonExistClass) {
   Spec.OldHeader = "foo.h";
   Spec.OldCC = "foo.cc";
   Spec.NewHeader = "new_foo.h";
   Spec.NewCC = "new_foo.cc";
   auto Results = runClangMoveOnCode(Spec);
   EXPECT_EQ(0u, Results.size());
 }
 
+TEST(ClangMove, MoveAll) {
+  move::ClangMoveTool::MoveDefinitionSpec Spec;
+  std::vector<std::string> TestHeaders = {
+    "class A {\npublic:\n  int f();\n};",
+    "class B;\nclass A {\npublic:\n  int f();\n};",
+    "template <typename T> class B;\nclass A {\npublic:\n  int f();\n};"
+    "namespace a {}\nclass A {\npublic:\n  int f();\n};",
+  };
+  const char Code[] = "#include \"foo.h\"\nint A::f() { return 0; }";
+  Spec.Names = {std::string("A")};
+  Spec.OldHeader = "foo.h";
+  Spec.OldCC = "foo.cc";
+  Spec.NewHeader = "new_foo.h";
+  Spec.NewCC = "new_foo.cc";
+  for (const auto& Header : TestHeaders) {
+    auto Results = runClangMoveOnCode(Spec, Header.c_str(), Code);
+    EXPECT_EQ(Header, Results[Spec.NewHeader]);
+  }
+}
+
+TEST(ClangMove, DontMoveAll) {
+  move::ClangMoveTool::MoveDefinitionSpec Spec;
+  const char ExpectedHeader[] = "#ifndef NEW_FOO_H\n"
+                                "#define NEW_FOO_H\n"
+                                "class A {\npublic:\n  int f();\n};\n"
+                                "#endif // NEW_FOO_H\n";
+  const char Code[] = "#include \"foo.h\"\nint A::f() { return 0; }";
+  std::vector<std::string> TestHeaders = {
+    "typedef int Int;\nclass A {\npublic:\n  int f();\n};",
+    "using Int=int;\nclass A {\npublic:\n  int f();\n};",
+    "namespace a {}\nusing namespace a;\nclass A {\npublic:\n  int f();\n};"
+  };
+  Spec.Names = {std::string("A")};
+  Spec.OldHeader = "foo.h";
+  Spec.OldCC = "foo.cc";
+  Spec.NewHeader = "new_foo.h";
+  Spec.NewCC = "new_foo.cc";
+  for (const auto& Header : TestHeaders) {
+    auto Results = runClangMoveOnCode(Spec, Header.c_str(), Code);
+    EXPECT_EQ(ExpectedHeader, Results[Spec.NewHeader]);
+  }
+}
+
 } // namespace
 } // namespce move
 } // namespace clang