Make FilePath of Replacement an absolute file path when possible.

[hokein]

Summary

The FilePath of the Replacement constructed from a SourceManager can be
an absolute file path or a file path relative to the build directory (It
depends on the compliation commands).

If the FilePath is a relative path, it may caused crash issues
when applying the Replacement if the running directory of the binary is
not the same with the build directory. Have verified the crashes in
several clang-tools, e.g. clang-rename, clang-move, clang-change-name,

clang-tidy (fixed in D17335).

By making the FilePath an absolute path, it resolves the crashes.

[hokein]

As discussed offline with klimek, we should change to the correct working directory before applying the replacements. So abandon this.

lib/Tooling/Core/Replacement.cpp

 #include "clang/Basic/DiagnosticIDs.h"
 #include "clang/Basic/DiagnosticOptions.h"
 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Lex/Lexer.h"
 #include "clang/Rewrite/Core/Rewriter.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/raw_os_ostream.h"
+#include "llvm/Support/Path.h"
 
 namespace clang {
 namespace tooling {
 
 static const char * const InvalidLocation = "";
 
 Replacement::Replacement()
   : FilePath(InvalidLocation) {}
return LHS.getOffset() == RHS.getOffset() &&
          LHS.getReplacementText() == RHS.getReplacementText();
 }
 
 void Replacement::setFromSourceLocation(const SourceManager &Sources,
                                         SourceLocation Start, unsigned Length,
                                         StringRef ReplacementText) {
   const std::pair<FileID, unsigned> DecomposedLocation =
       Sources.getDecomposedLoc(Start);
-  const FileEntry *Entry = Sources.getFileEntryForID(DecomposedLocation.first);
-  this->FilePath = Entry ? Entry->getName() : InvalidLocation;
+  this->FilePath = InvalidLocation;
+  if (const FileEntry *Entry =
+          Sources.getFileEntryForID(DecomposedLocation.first)) {
+    auto Dir = Sources.getFileManager()
+                   .getVirtualFileSystem()
+                   ->getCurrentWorkingDirectory();
+    if (Dir) {
+      llvm::SmallString<128> AbsolutePath(Entry->getName());
+      std::error_code EC =
+          llvm::sys::fs::make_absolute((Dir.get()), AbsolutePath);
+      if (!EC) {
+        llvm::sys::path::remove_dots(AbsolutePath, /*remove_dot_dot=*/true);
+        this->FilePath = AbsolutePath.str();
+      }
+    }
+  }
   this->ReplacementRange = Range(DecomposedLocation.second, Length);
   this->ReplacementText = ReplacementText;
 }
 
 // FIXME: This should go into the Lexer, but we need to figure out how
 // to handle ranges for refactoring in general first - there is no obvious
 // good way how to integrate this into the Lexer yet.
 static int getRangeSize(const SourceManager &Sources,

unittests/Tooling/RefactoringTest.cpp

private:
     TestVisitor *Visitor;
   };
 };
 } // end namespace
 
 void expectReplacementAt(const Replacement &Replace,
                          StringRef File, unsigned Offset, unsigned Length) {
   ASSERT_TRUE(Replace.isApplicable());
-  EXPECT_EQ(File, Replace.getFilePath());
+  EXPECT_TRUE(Replace.getFilePath().endswith(File));
   EXPECT_EQ(Offset, Replace.getOffset());
   EXPECT_EQ(Length, Replace.getLength());
 }
 
 class ClassDeclXVisitor : public TestVisitor<ClassDeclXVisitor> {
 public:
   bool VisitCXXRecordDecl(CXXRecordDecl *Record) {
     if (Record->getName() == "X") {