[clang-diff] Add option to compare files across git revisions

[johannes]

Summary

This adds a command line option "-git-rev=<commit[..commit]>". When it is
used, only one filename is accepted. The file in its version in the specified
revision is compared against the current version (or the one in the second
revision if given). Note that this calls git checkout in the current
directory.

[arphaman]

It might be useful to have both source and destination in a different revision. Maybe something like -src-git-rev and -dst-git-rev?

[johannes]

In D36686#840827, @arphaman wrote:

It might be useful to have both source and destination in a different revision. Maybe something like -src-git-rev and -dst-git-rev?

Then I'd rather have a revision range such as -git-revs <commit>..<commit>
and if there is only one specified, then <commit>..HEAD is implied
maybe a different name for the argument

The whole thing is a bit of a hack - if the HEAD is dirty then the checkout fails and the program exits.

I want to change it so it does not interfere with the state of the repository. I can checkout the revisions in a temporary repository and then patch the paths in the compilation database.

[arphaman]

That would be nice. Temporary checkouts are a way to solve the problem. But they might not work for all projects, like when some translation unit includes a file that's not in git using a relative path.

Another solution is to use virtual file systems. A custom vfs could load the files that are in a particular git revision. Then, an overlay fs can be used to combine both the git vfs and the real fs. That overlay should be somehow passed into the AST producer. I don't think it's worth doing this right now because of time constraints, so temporary checkouts is probably the better solution for the time being.

[johannes]

accept a commit range

[johannes]

casing

tools/clang-diff/ClangDiff.cpp

 // Tooling/ASTDiff.
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/Tooling/ASTDiff/ASTDiff.h"
 #include "clang/Tooling/CommonOptionsParser.h"
 #include "clang/Tooling/Tooling.h"
 #include "llvm/Support/CommandLine.h"
+#include "llvm/Support/Program.h"
 
 using namespace llvm;
 using namespace clang;
 using namespace clang::tooling;
 
 static cl::OptionCategory ClangDiffCategory("clang-diff options");
 
 static cl::opt<bool>
     ASTDump("ast-dump",
             cl::desc("Print the internal representation of the AST."),
             cl::init(false), cl::cat(ClangDiffCategory));
 
 static cl::opt<bool> ASTDumpJson(
     "ast-dump-json",
     cl::desc("Print the internal representation of the AST as JSON."),
     cl::init(false), cl::cat(ClangDiffCategory));
 
-static cl::opt<bool>
-    PrintMatches("dump-matches", cl::desc("Print the matched nodes."),
+static cl::opt<bool> PrintMatches("dump-matches",
+                                  cl::desc("Print the matched nodes."),
                                   cl::init(false), cl::cat(ClangDiffCategory));
 
 static cl::opt<bool> HtmlDiff("html",
                               cl::desc("Output a side-by-side diff in HTML."),
                               cl::init(false), cl::cat(ClangDiffCategory));
 
 static cl::opt<std::string> SourcePath(cl::Positional, cl::desc("<source>"),
                                        cl::Required,
                                        cl::cat(ClangDiffCategory));
 
 static cl::opt<std::string> DestinationPath(cl::Positional,
                                             cl::desc("<destination>"),
                                             cl::Optional,
                                             cl::cat(ClangDiffCategory));
 
 static cl::opt<std::string> StopAfter("stop-after",
                                       cl::desc("<topdown|bottomup>"),
                                       cl::Optional, cl::init(""),
                                       cl::cat(ClangDiffCategory));
 
+static cl::opt<std::string>
+    GitRevision("git-rev",
+                cl::desc("Compare a file between a revision range (<rev>..HEAD "
+                         "is assumed if a single revision is given."),
+                cl::Optional, cl::init(""), cl::cat(ClangDiffCategory));
+
 static cl::opt<int> MaxSize("s", cl::desc("<maxsize>"), cl::Optional,
                             cl::init(-1), cl::cat(ClangDiffCategory));
 
 static cl::opt<std::string> BuildPath("p", cl::desc("Build path"), cl::init(""),
                                       cl::Optional, cl::cat(ClangDiffCategory));
 
 static cl::list<std::string> ArgsAfter(
     "extra-arg",
case diff::UpdateMove:
     printNode(OS, DstTree, Dst);
     OS << " into ";
     printNode(OS, DstTree, DstNode.Parent);
     OS << " at " << DstTree.findPositionInParent(Dst) << "\n";
     break;
   }
 }
 
+std::string Exec(const char *Command) {
+  char Buffer[128];
+  std::string Result;
+  std::shared_ptr<FILE> Pipe(popen(Command, "r"), pclose);
+  if (!Pipe)
+    return Result;
+  while (!feof(Pipe.get())) {
+    if (fgets(Buffer, 128, Pipe.get()) != nullptr)
+      Result += Buffer;
+  }
+  return Result;
+}
+
 int main(int argc, const char **argv) {
   std::string ErrorMessage;
   std::unique_ptr<CompilationDatabase> CommonCompilations =
       FixedCompilationDatabase::loadFromCommandLine(argc, argv, ErrorMessage);
   if (!CommonCompilations && !ErrorMessage.empty())
     llvm::errs() << ErrorMessage;
   cl::HideUnrelatedOptions(ClangDiffCategory);
   if (!cl::ParseCommandLineOptions(argc, argv)) {
if (ASTDump || ASTDumpJson) {
     llvm::outs() << R"({"filename":")";
     printJsonString(llvm::outs(), SourcePath);
     llvm::outs() << R"(","root":)";
     printNodeAsJson(llvm::outs(), Tree, Tree.getRootId());
     llvm::outs() << "}\n";
     return 0;
   }
 
-  if (DestinationPath.empty()) {
+  if (DestinationPath.empty() && GitRevision.empty()) {
     llvm::errs() << "Error: Exactly two paths are required.\n";
     return 1;
   }
 
-  std::unique_ptr<ASTUnit> Src = getAST(CommonCompilations, SourcePath);
-  std::unique_ptr<ASTUnit> Dst = getAST(CommonCompilations, DestinationPath);
+  std::unique_ptr<ASTUnit> Src, Dst;
+
+  if (!GitRevision.empty()) {
+    std::string Git;
+    auto ErrorOrGit = llvm::sys::findProgramByName("git");
+    if (!ErrorOrGit) {
+      llvm::errs() << "Error: Could not find git executable.\n";
+      return 1;
+    }
+    Git = ErrorOrGit.get();
+    if (GitRevision.find("..") == std::string::npos)
+      GitRevision += "..HEAD";
+    size_t Dots = GitRevision.find("..");
+    GitRevision.replace(Dots, 2, "  ");
+    GitRevision += " HEAD";
+    std::string RevParseCommand = "git rev-parse " + GitRevision;
+    std::string Revisions = Exec(RevParseCommand.data());
+    std::transform(Revisions.begin(), Revisions.end(), Revisions.begin(),
+                   [](char C) { return C == '\n' ? '\0' : C; });
+    auto SrcRev = Revisions.data();
+    size_t Offset = Revisions.find('\0') + 1;
+    auto DstRev = Revisions.data() + Offset;
+    auto UserRev = Revisions.data() + Revisions.find('\0', Offset) + 1;
+    const char *CheckoutCommand[] = {"git", "checkout", nullptr, nullptr};
+    auto Checkout = [&](const char *Rev) {
+      CheckoutCommand[2] = Rev;
+      if (llvm::sys::ExecuteAndWait(Git, CheckoutCommand)) {
+        llvm::errs() << "Error: Failed to checkout " << Rev << "\n";
+        return false;
+      }
+      return true;
+    };
+    if (!Checkout(SrcRev))
+      return 1;
+    Src = getAST(CommonCompilations, SourcePath);
+    if (!Checkout(DstRev))
+      return 1;
+    Dst = getAST(CommonCompilations, SourcePath);
+    Checkout(UserRev);
+  } else {
+    Src = getAST(CommonCompilations, SourcePath);
+    Dst = getAST(CommonCompilations, DestinationPath);
+  }
+
   if (!Src || !Dst)
     return 1;
 
   diff::ComparisonOptions Options;
   if (MaxSize != -1)
     Options.MaxSize = MaxSize;
   if (!StopAfter.empty()) {
     if (StopAfter == "topdown")