Add getCommonRoot Interface in CompilationDatabase.

[hokein]

Summary

Provide a way allowing clang clients to get the common build directory
from the compilation database.

[hokein]

Correct the implementation of FixedCompilationDatabase::getCommonRoot.

include/clang/Tooling/CompilationDatabase.h

public:
   /// A compilation database representing the project would return both command
   /// lines for a.cc and b.cc and only the first command line for t.cc.
   virtual std::vector<CompileCommand> getCompileCommands(
     StringRef FilePath) const = 0;
 
   /// \brief Returns the list of all files available in the compilation database.
   virtual std::vector<std::string> getAllFiles() const = 0;
 
+  /// \brief Returns the common build directory for all translation units in the
+  /// compilation database. Return None if there are different build
+  /// directories.
+  virtual llvm::Optional<std::string> getCommonRoot() const = 0;
+
   /// \brief Returns all compile commands for all the files in the compilation
   /// database.
   ///
   /// FIXME: Add a layer in Tooling that provides an interface to run a tool
   /// over all files in a compilation database. Not all build systems have the
   /// ability to provide a feasible implementation for \c getAllCompileCommands.
   virtual std::vector<CompileCommand> getAllCompileCommands() const = 0;
 };
public:
   std::vector<std::string> getAllFiles() const override;
 
   /// \brief Returns all compile commands for all the files in the compilation
   /// database.
   ///
   /// Note: This is always an empty list for the fixed compilation database.
   std::vector<CompileCommand> getAllCompileCommands() const override;
 
+  /// \brief Returns the common build directory for all translation units in the
+  /// compilation database.
+  llvm::Optional<std::string> getCommonRoot() const override;
+
 private:
   /// This is built up to contain a single entry vector to be returned from
   /// getCompileCommands after adding the positional argument.
   std::vector<CompileCommand> CompileCommands;
 };
 
 } // end namespace tooling
 } // end namespace clang
 
 #endif

include/clang/Tooling/JSONCompilationDatabase.h

public:
   ///
   /// These are the 'file' entries of the JSON objects.
   std::vector<std::string> getAllFiles() const override;
 
   /// \brief Returns all compile commands for all the files in the compilation
   /// database.
   std::vector<CompileCommand> getAllCompileCommands() const override;
 
+  /// \brief Returns the common build directory for all translation units in the
+  /// JSON compilation database.
+  llvm::Optional<std::string> getCommonRoot() const override {
+    return CommonRoot;
+  }
+
 private:
   /// \brief Constructs a JSON compilation database on a memory buffer.
   JSONCompilationDatabase(std::unique_ptr<llvm::MemoryBuffer> Database,
                           JSONCommandLineSyntax Syntax)
       : Database(std::move(Database)), Syntax(Syntax),
-        YAMLStream(this->Database->getBuffer(), SM) {}
+        YAMLStream(this->Database->getBuffer(), SM), CommonRoot(llvm::None) {}
 
   /// \brief Parses the database file and creates the index.
   ///
   /// Returns whether parsing succeeded. Sets ErrorMessage if parsing
   /// failed.
   bool parse(std::string &ErrorMessage);
 
   // Tuple (directory, filename, commandline) where 'commandline' points to the
private:
   std::vector<CompileCommandRef> AllCommands;
 
   FileMatchTrie MatchTrie;
 
   std::unique_ptr<llvm::MemoryBuffer> Database;
   JSONCommandLineSyntax Syntax;
   llvm::SourceMgr SM;
   llvm::yaml::Stream YAMLStream;
+
+  llvm::Optional<std::string> CommonRoot;
 };
 
 } // end namespace tooling
 } // end namespace clang
 
 #endif

lib/Tooling/CommonOptionsParser.cpp

public:
   std::vector<std::string> getAllFiles() const override {
     return Compilations->getAllFiles();
   }
 
   std::vector<CompileCommand> getAllCompileCommands() const override {
     return adjustCommands(Compilations->getAllCompileCommands());
   }
 
+  llvm::Optional<std::string> getCommonRoot() const override {
+    return Compilations->getCommonRoot();
+  }
+
 private:
   std::unique_ptr<CompilationDatabase> Compilations;
   std::vector<ArgumentsAdjuster> Adjusters;
 
   std::vector<CompileCommand>
   adjustCommands(std::vector<CompileCommand> Commands) const {
     for (CompileCommand &Command : Commands)
       for (const auto &Adjuster : Adjusters)

lib/Tooling/CompilationDatabase.cpp

FixedCompilationDatabase::getAllFiles() const {
   return std::vector<std::string>();
 }
 
 std::vector<CompileCommand>
 FixedCompilationDatabase::getAllCompileCommands() const {
   return std::vector<CompileCommand>();
 }
 
+llvm::Optional<std::string> FixedCompilationDatabase::getCommonRoot() const {
+  auto It =
+      std::find_if(CompileCommands.begin(), CompileCommands.end(),
+                   [&](const clang::tooling::CompileCommand &Command) {
+                     return CompileCommands[0].Directory != Command.Directory;
+                   });
+  if (It == CompileCommands.end())
+    return CompileCommands[0].Directory;
+  return llvm::None;
+}
+
 namespace clang {
 namespace tooling {
 
 // This anchor is used to force the linker to link in the generated object file
 // and thus register the JSONCompilationDatabasePlugin.
 extern volatile int JSONAnchorSource;
 static int LLVM_ATTRIBUTE_UNUSED JSONAnchorDest = JSONAnchorSource;
 
 } // end namespace tooling
 } // end namespace clang

lib/Tooling/JSONCompilationDatabase.cpp

for (auto& NextObject : *Array) {
     } else {
       llvm::sys::path::native(FileName, NativeFilePath);
     }
     auto Cmd = CompileCommandRef(Directory, File, *Command);
     IndexByFile[NativeFilePath].push_back(Cmd);
     AllCommands.push_back(Cmd);
     MatchTrie.insert(NativeFilePath);
   }
+  if (!AllCommands.empty()) {
+    SmallString<128> DirectoryStorage;
+    SmallString<128> NextDirectoryStorage;
+    llvm::StringRef Directory =
+        std::get<0>(AllCommands[0])->getValue(DirectoryStorage);
+    auto It = std::find_if(
+        AllCommands.begin() + 1, AllCommands.end(),
+        [&](JSONCompilationDatabase::CompileCommandRef &Command) {
+          return Directory !=
+                 std::get<0>(Command)->getValue(NextDirectoryStorage);
+        });
+    if (It == AllCommands.end())
+      CommonRoot = Directory.str();
+  }
   return true;
 }
 
 } // end namespace tooling
 } // end namespace clang

unittests/Tooling/CompilationDatabaseTest.cpp

EXPECT_EQ(expected_files,
                         "\"file\":\"file1\"},"
                         " {\"directory\":\"//net/dir\","
                         "\"command\":\"command\","
                         "\"file\":\"file2\"}]",
                         ErrorMessage, JSONCommandLineSyntax::Gnu))
       << ErrorMessage;
 }
 
+TEST(JSONCompilationDatabase, GetCommonRoot) {
+  std::string ErrorMessage;
+  std::string JSONDatabase = "[{\"directory\":\"//dir/build/\","
+                             "\"command\":\"command\","
+                             "\"file\":\"file1\"},"
+                             " {\"directory\":\"//dir/build/\","
+                             "\"command\":\"command\","
+                             "\"file\":\"file2\"}]";
+
+  std::unique_ptr<CompilationDatabase> Database(
+      JSONCompilationDatabase::loadFromBuffer(JSONDatabase, ErrorMessage,
+                                              JSONCommandLineSyntax::Gnu));
+  auto CommonRoot = Database->getCommonRoot();
+  ASSERT_TRUE(CommonRoot.hasValue());
+  EXPECT_EQ("//dir/build/", *CommonRoot);
+
+  JSONDatabase = "[{\"directory\":\"//dir/build/\","
+                 "\"command\":\"command\","
+                 "\"file\":\"file1\"},"
+                 " {\"directory\":\"//dir/build2/\","
+                 "\"command\":\"command\","
+                 "\"file\":\"file2\"}]";
+  Database = JSONCompilationDatabase::loadFromBuffer(
+      JSONDatabase, ErrorMessage, JSONCommandLineSyntax::Gnu);
+  CommonRoot = Database->getCommonRoot();
+  EXPECT_FALSE(CommonRoot.hasValue());
+}
+
 TEST(JSONCompilationDatabase, GetAllCompileCommands) {
   std::string ErrorMessage;
   EXPECT_EQ(
       0u, getAllCompileCommands(JSONCommandLineSyntax::Gnu, "[]", ErrorMessage)
               .size())
       << ErrorMessage;
 
   StringRef Directory1("//net/dir1");