[Tooling] Remove file/command enumeration from CompilationDatabase.

[sammccall]

Summary

In practice, these methods aren't used, and several databases don't
implement them.
They remain in libclang as a stub for binary compatibility.
c-index-tests are modified not to rely on them.

[bkramer]

There are a few users of the C++ API out there, do we have migration path for them?

[sammccall]

In D40439#935678, @bkramer wrote:

There are a few users of the C++ API out there, do we have migration path for them?

Do we have any idea what these look like?
One option would be to keep the functionality on the JSONCompilationDatabase implementation (which properly supports it), and remove it from the interface.

bindings/python/clang/cindex.py

def fromDirectory(buildDir):
         return cdb
 
     def getCompileCommands(self, filename):
         """
         Get an iterable object providing all the CompileCommands available to
         build filename. Returns None if filename is not found in the database.
         """
         return conf.lib.clang_CompilationDatabase_getCompileCommands(self,
-                                                                     filename)
-
-    def getAllCompileCommands(self):
-        """
-        Get an iterable object providing all the CompileCommands available from
-        the database.
-        """
-        return conf.lib.clang_CompilationDatabase_getAllCompileCommands(self)
 
 
 class Token(Structure):
     """Represents a single token from the preprocessor.
 
     Tokens are effectively segments of source code. Source code is first parsed
     into tokens before being converted into the AST and Cursors.
 
functionList = [
   ("clang_CompilationDatabase_dispose",
    [c_object_p]),
 
   ("clang_CompilationDatabase_fromDirectory",
    [c_interop_string, POINTER(c_uint)],
    c_object_p,
    CompilationDatabase.from_result),
 
-  ("clang_CompilationDatabase_getAllCompileCommands",
-   [c_object_p],
-   c_object_p,
-   CompileCommands.from_result),
-
   ("clang_CompilationDatabase_getCompileCommands",
    [c_object_p, c_interop_string],
    c_object_p,
    CompileCommands.from_result),
 
   ("clang_CompileCommands_dispose",
    [c_object_p]),
 

include/clang-c/CXCompilationDatabase.h

  * must be freed by \c clang_CompileCommands_dispose.
  */
 CINDEX_LINKAGE CXCompileCommands
 clang_CompilationDatabase_getCompileCommands(CXCompilationDatabase,
                                              const char *CompleteFileName);
 
 /**
  * \brief Get all the compile commands in the given compilation database.
+ * This is no longer supported, the returned list is empty.
  */
 CINDEX_LINKAGE CXCompileCommands
 clang_CompilationDatabase_getAllCompileCommands(CXCompilationDatabase);
 
 /**
  * \brief Free the given CompileCommands
  */
 CINDEX_LINKAGE void clang_CompileCommands_dispose(CXCompileCommands);

include/clang/Tooling/CommonOptionsParser.h

ArgumentsAdjustingCompilations(
       std::unique_ptr<CompilationDatabase> Compilations)
       : Compilations(std::move(Compilations)) {}
 
   void appendArgumentsAdjuster(ArgumentsAdjuster Adjuster);
 
   std::vector<CompileCommand>
   getCompileCommands(StringRef FilePath) const override;
 
-  std::vector<std::string> getAllFiles() const override;
-
-  std::vector<CompileCommand> getAllCompileCommands() const override;
-
 private:
   std::unique_ptr<CompilationDatabase> Compilations;
   std::vector<ArgumentsAdjuster> Adjusters;
-
-  std::vector<CompileCommand>
-  adjustCommands(std::vector<CompileCommand> Commands) const;
 };
 
 }  // namespace tooling
 }  // namespace clang
 
 #endif  // LLVM_TOOLS_CLANG_INCLUDE_CLANG_TOOLING_COMMONOPTIONSPARSER_H

include/clang/Tooling/CompilationDatabase.h

struct CompileCommand {
   /// The output file associated with the command.
   std::string Output;
 };
 
 /// \brief Interface for compilation databases.
 ///
 /// A compilation database allows the user to retrieve compile command lines
 /// for the files in a project.
-///
-/// Many implementations are enumerable, allowing all command lines to be
-/// retrieved. These can be used to run clang tools over a subset of the files
-/// in a project.
 class CompilationDatabase {
 public:
   virtual ~CompilationDatabase();
 
   /// \brief Loads a compilation database from a build directory.
   ///
   /// Looks at the specified 'BuildDirectory' and creates a compilation database
   /// that allows to query compile commands for source files in the
   /// corresponding source tree.
   ///
   /// Returns NULL and sets ErrorMessage if we were not able to build up a
   /// compilation database for the build directory.
   ///
-  /// FIXME: Currently only supports JSON compilation databases, which
-  /// are named 'compile_commands.json' in the given directory. Extend this
-  /// for other build types (like ninja build files).
+  /// Currently supports:
+  ///   - JSON compilation databases (compile_commands.json)
+  ///   - Fixed compilation databases (compile_flags.txt)
+  /// FIXME: Extend this for other build types (like ninja build files).
   static std::unique_ptr<CompilationDatabase>
   loadFromDirectory(StringRef BuildDirectory, std::string &ErrorMessage);
 
   /// \brief Tries to detect a compilation database location and load it.
   ///
   /// Looks for a compilation database in all parent paths of file 'SourceFile'
   /// by calling loadFromDirectory.
   static std::unique_ptr<CompilationDatabase>
   autoDetectFromSource(StringRef SourceFile, std::string &ErrorMessage);
 
   /// \brief Tries to detect a compilation database location and load it.
   ///
   /// Looks for a compilation database in directory 'SourceDir' and all
   /// its parent paths by calling loadFromDirectory.
   static std::unique_ptr<CompilationDatabase>
   autoDetectFromDirectory(StringRef SourceDir, std::string &ErrorMessage);
 
-  /// \brief Returns all compile commands in which the specified file was
-  /// compiled.
+  /// \brief Returns the compile commands to build a file.
   ///
   /// This includes compile commands that span multiple source files.
   /// For example, consider a project with the following compilations:
   /// $ clang++ -o test a.cc b.cc t.cc
   /// $ clang++ -o production a.cc b.cc -DPRODUCTION
   /// 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.
-  ///
-  /// By default, returns nothing. Implementations should override this if they
-  /// can enumerate their source files.
-  virtual std::vector<std::string> getAllFiles() const { return {}; }
-
-  /// \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.
-  ///
-  /// By default, this is implemented in terms of getAllFiles() and
-  /// getCompileCommands(). Subclasses may override this for efficiency.
-  virtual std::vector<CompileCommand> getAllCompileCommands() const;
 };
 
 /// \brief Interface for compilation database plugins.
 ///
 /// A compilation database plugin allows the user to register custom compilation
 /// databases that are picked up as compilation database if the corresponding
 /// library is linked in. To register a plugin, declare a static variable like:
 ///

include/clang/Tooling/JSONCompilationDatabase.h

public:
   /// \brief Returns all compile commands in which the specified file was
   /// compiled.
   ///
   /// FIXME: Currently FilePath must be an absolute path inside the
   /// source directory which does not have symlinks resolved.
   std::vector<CompileCommand>
   getCompileCommands(StringRef FilePath) const override;
 
-  /// \brief Returns the list of all files available in the compilation database.
-  ///
-  /// 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;
-
 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) {}
 
   /// \brief Parses the database file and creates the index.
private:
   // Otherwise, each entry in the command line vector is a literal
   // argument to the compiler.
   // The output field may be a nullptr.
   typedef std::tuple<llvm::yaml::ScalarNode *,
                      llvm::yaml::ScalarNode *,
                      std::vector<llvm::yaml::ScalarNode *>,
                      llvm::yaml::ScalarNode *> CompileCommandRef;
 
-  /// \brief Converts the given array of CompileCommandRefs to CompileCommands.
-  void getCommands(ArrayRef<CompileCommandRef> CommandsRef,
-                   std::vector<CompileCommand> &Commands) const;
-
   // Maps file paths to the compile command lines for that file.
   llvm::StringMap<std::vector<CompileCommandRef>> IndexByFile;
 
   /// All the compile commands in the order that they were provided in the
   /// JSON stream.
   std::vector<CompileCommandRef> AllCommands;
 
   FileMatchTrie MatchTrie;

lib/Tooling/CommonOptionsParser.cpp

const char *const CommonOptionsParser::HelpMessage =
     "\tsuffix of a path in the compile command database.\n"
     "\n";
 
 void ArgumentsAdjustingCompilations::appendArgumentsAdjuster(
     ArgumentsAdjuster Adjuster) {
   Adjusters.push_back(std::move(Adjuster));
 }
 
-std::vector<CompileCommand> ArgumentsAdjustingCompilations::getCompileCommands(
-    StringRef FilePath) const {
-  return adjustCommands(Compilations->getCompileCommands(FilePath));
-}
-
-std::vector<std::string>
-ArgumentsAdjustingCompilations::getAllFiles() const {
-  return Compilations->getAllFiles();
-}
-
 std::vector<CompileCommand>
-ArgumentsAdjustingCompilations::getAllCompileCommands() const {
-  return adjustCommands(Compilations->getAllCompileCommands());
-}
-
-std::vector<CompileCommand> ArgumentsAdjustingCompilations::adjustCommands(
-    std::vector<CompileCommand> Commands) const {
+ArgumentsAdjustingCompilations::getCompileCommands(StringRef FilePath) const {
+  auto Commands = Compilations->getCompileCommands(FilePath);
   for (CompileCommand &Command : Commands)
     for (const auto &Adjuster : Adjusters)
       Command.CommandLine = Adjuster(Command.CommandLine, Command.Filename);
   return Commands;
 }
 
 llvm::Error CommonOptionsParser::init(
     int &argc, const char **argv, cl::OptionCategory &Category,

lib/Tooling/CompilationDatabase.cpp

std::unique_ptr<CompilationDatabase> DB =
       findCompilationDatabaseFromDirectory(AbsolutePath, ErrorMessage);
 
   if (!DB)
     ErrorMessage = ("Could not auto-detect compilation database from directory \"" +
                    SourceDir + "\"\n" + ErrorMessage).str();
   return DB;
 }
 
-std::vector<CompileCommand> CompilationDatabase::getAllCompileCommands() const {
-  std::vector<CompileCommand> Result;
-  for (const auto &File : getAllFiles()) {
-    auto C = getCompileCommands(File);
-    std::move(C.begin(), C.end(), std::back_inserter(Result));
-  }
-  return Result;
-}
-
 CompilationDatabasePlugin::~CompilationDatabasePlugin() {}
 
 namespace {
 // Helper for recursively searching through a chain of actions and collecting
 // all inputs, direct and indirect, of compile jobs.
 struct CompileJobAnalyzer {
   void run(const driver::Action *A) {
     runImpl(A, false);

lib/Tooling/JSONCompilationDatabase.cpp

std::unique_ptr<llvm::MemoryBuffer> DatabaseBuffer(
       llvm::MemoryBuffer::getMemBuffer(DatabaseString));
   std::unique_ptr<JSONCompilationDatabase> Database(
       new JSONCompilationDatabase(std::move(DatabaseBuffer), Syntax));
   if (!Database->parse(ErrorMessage))
     return nullptr;
   return Database;
 }
 
+static std::vector<std::string>
+nodeToCommandLine(JSONCommandLineSyntax Syntax,
+                  const std::vector<llvm::yaml::ScalarNode *> &Nodes) {
+  SmallString<1024> Storage;
+  if (Nodes.size() == 1) {
+    return unescapeCommandLine(Syntax, Nodes[0]->getValue(Storage));
+  }
+  std::vector<std::string> Arguments;
+  for (auto *Node : Nodes) {
+    Arguments.push_back(Node->getValue(Storage));
+  }
+  return Arguments;
+}
+
 std::vector<CompileCommand>
 JSONCompilationDatabase::getCompileCommands(StringRef FilePath) const {
   SmallString<128> NativeFilePath;
   llvm::sys::path::native(FilePath, NativeFilePath);
 
   std::string Error;
   llvm::raw_string_ostream ES(Error);
   StringRef Match = MatchTrie.findEquivalent(NativeFilePath, ES);
   if (Match.empty())
     return std::vector<CompileCommand>();
   llvm::StringMap< std::vector<CompileCommandRef> >::const_iterator
     CommandsRefI = IndexByFile.find(Match);
   if (CommandsRefI == IndexByFile.end())
     return std::vector<CompileCommand>();
   std::vector<CompileCommand> Commands;
-  getCommands(CommandsRefI->getValue(), Commands);
-  return Commands;
-}
-
-std::vector<std::string>
-JSONCompilationDatabase::getAllFiles() const {
-  std::vector<std::string> Result;
-
-  llvm::StringMap< std::vector<CompileCommandRef> >::const_iterator
-    CommandsRefI = IndexByFile.begin();
-  const llvm::StringMap< std::vector<CompileCommandRef> >::const_iterator
-    CommandsRefEnd = IndexByFile.end();
-  for (; CommandsRefI != CommandsRefEnd; ++CommandsRefI) {
-    Result.push_back(CommandsRefI->first().str());
-  }
-
-  return Result;
-}
-
-std::vector<CompileCommand>
-JSONCompilationDatabase::getAllCompileCommands() const {
-  std::vector<CompileCommand> Commands;
-  getCommands(AllCommands, Commands);
-  return Commands;
-}
-
-static std::vector<std::string>
-nodeToCommandLine(JSONCommandLineSyntax Syntax,
-                  const std::vector<llvm::yaml::ScalarNode *> &Nodes) {
-  SmallString<1024> Storage;
-  if (Nodes.size() == 1) {
-    return unescapeCommandLine(Syntax, Nodes[0]->getValue(Storage));
-  }
-  std::vector<std::string> Arguments;
-  for (auto *Node : Nodes) {
-    Arguments.push_back(Node->getValue(Storage));
-  }
-  return Arguments;
-}
-
-void JSONCompilationDatabase::getCommands(
-    ArrayRef<CompileCommandRef> CommandsRef,
-    std::vector<CompileCommand> &Commands) const {
+  ArrayRef<CompileCommandRef> CommandsRef = CommandsRefI->getValue();
   for (int I = 0, E = CommandsRef.size(); I != E; ++I) {
     SmallString<8> DirectoryStorage;
     SmallString<32> FilenameStorage;
     SmallString<32> OutputStorage;
     auto Output = std::get<3>(CommandsRef[I]);
     Commands.emplace_back(
         std::get<0>(CommandsRef[I])->getValue(DirectoryStorage),
         std::get<1>(CommandsRef[I])->getValue(FilenameStorage),
         nodeToCommandLine(Syntax, std::get<2>(CommandsRef[I])),
         Output ? Output->getValue(OutputStorage) : "");
   }
+  return Commands;
 }
 
 bool JSONCompilationDatabase::parse(std::string &ErrorMessage) {
   llvm::yaml::document_iterator I = YAMLStream.begin();
   if (I == YAMLStream.end()) {
     ErrorMessage = "Error while parsing YAML.";
     return false;
   }

test/Index/skip-parsed-bodies/compile_commands.json

 [
 {
-  "directory": ".",
+  "directory": "WORKDIR",
   "command": "/usr/bin/clang++ -fsyntax-only -fno-ms-compatibility -fno-delayed-template-parsing t1.cpp",
   "file": "t1.cpp"
 },
 {
-  "directory": ".",
+  "directory": "WORKDIR",
   "command": "/usr/bin/clang++ -fsyntax-only -fno-ms-compatibility -fno-delayed-template-parsing t2.cpp -DBLAH",
   "file": "t2.cpp"
 },
 {
-  "directory": ".",
+  "directory": "WORKDIR",
   "command": "/usr/bin/clang++ -fsyntax-only -fno-ms-compatibility -fno-delayed-template-parsing t3.cpp -DBLAH",
   "file": "t2.cpp"
 }
 ]
 
-// RUN: c-index-test -index-compile-db %s | FileCheck %s
+// RUN: sed "s|WORKDIR|%S|" < %s > %T/compile_commands.json
+// RUN: c-index-test -index-compile-db %T/compile_commands.json %S/t1.cpp %S/t2.cpp | FileCheck %s
 
 // CHECK:      [startedTranslationUnit]
 // CHECK-NEXT: [enteredMainFile]: t1.cpp
 // CHECK:      [indexDeclaration]: kind: c++-instance-method | name: method_decl | {{.*}} | isRedecl: 0 | isDef: 0 | isContainer: 0
 // CHECK-NEXT: [indexDeclaration]: kind: c++-instance-method | name: method_def1 | {{.*}} | isRedecl: 0 | isDef: 1 | isContainer: 1
 // CHECK-NEXT: [indexEntityReference]: kind: variable | name: some_val | {{.*}} | loc: ./t.h:9:27
 // CHECK-NEXT: [indexDeclaration]: kind: c++-instance-method | name: method_def2 | {{.*}} | isRedecl: 0 | isDef: 0 | isContainer: 0
 // CHECK-NEXT: [indexDeclaration]: kind: c++-instance-method | name: method_def2 | {{.*}} | isRedecl: 1 | isDef: 1 | isContainer: 1

tools/c-index-test/c-index-test.c

static int index_tu(int argc, const char **argv) {
 
   clang_IndexAction_dispose(idxAction);
   clang_disposeIndex(Idx);
   return result;
 }
 
 static int index_compile_db(int argc, const char **argv) {
   const char *check_prefix;
+  const char *database;
   CXIndex Idx;
   CXIndexAction idxAction;
   int errorCode = 0;
 
   check_prefix = 0;
   if (argc > 0) {
     if (strstr(argv[0], "-check-prefix=") == argv[0]) {
       check_prefix = argv[0] + strlen("-check-prefix=");
       ++argv;
       --argc;
     }
   }
 
   if (argc == 0) {
     fprintf(stderr, "no compilation database\n");
     return -1;
   }
+  database = argv[0];
+  argv++;
+  --argc;
 
   if (!(Idx = clang_createIndex(/* excludeDeclsFromPCH */ 1,
                                 /* displayDiagnostics=*/1))) {
     fprintf(stderr, "Could not create Index\n");
     return 1;
   }
   idxAction = clang_IndexAction_create(Idx);
 
   {
-    const char *database = argv[0];
     CXCompilationDatabase db = 0;
     CXCompileCommands CCmds = 0;
     CXCompileCommand CCmd;
     CXCompilationDatabase_Error ec;
     CXString wd;
 #define MAX_COMPILE_ARGS 512
     CXString cxargs[MAX_COMPILE_ARGS];
     const char *args[MAX_COMPILE_ARGS];
if (db) {
       }
 
       if (chdir(buildDir) != 0) {
         printf("Could not chdir to %s\n", buildDir);
         errorCode = -1;
         goto cdb_end;
       }
 
-      CCmds = clang_CompilationDatabase_getAllCompileCommands(db);
+      for (; argc > 0 && errorCode == 0; ++argv, --argc) {
+        CCmds = clang_CompilationDatabase_getCompileCommands(db, argv[0]);
         if (!CCmds) {
-        printf("compilation db is empty\n");
+          printf("no compile commands for %s\n", argv[0]);
           errorCode = -1;
-        goto cdb_end;
+          goto file_end;
         }
-
         numCmds = clang_CompileCommands_getSize(CCmds);
-
-      if (numCmds==0) {
-        fprintf(stderr, "should not get an empty compileCommand set\n");
-        errorCode = -1;
-        goto cdb_end;
-      }
-
-      for (i=0; i<numCmds && errorCode == 0; ++i) {
+        for (i = 0; i < numCmds && errorCode == 0; ++i) {
           CCmd = clang_CompileCommands_getCommand(CCmds, i);
 
           wd = clang_CompileCommand_getDirectory(CCmd);
           if (chdir(clang_getCString(wd)) != 0) {
             printf("Could not chdir to %s\n", clang_getCString(wd));
             errorCode = -1;
-          goto cdb_end;
+            goto file_end;
           }
           clang_disposeString(wd);
 
           numArgs = clang_CompileCommand_getNumArgs(CCmd);
           if (numArgs > MAX_COMPILE_ARGS){
             fprintf(stderr, "got more compile arguments than maximum\n");
             errorCode = -1;
-          goto cdb_end;
+            goto file_end;
           }
           for (a=0; a<numArgs; ++a) {
             cxargs[a] = clang_CompileCommand_getArg(CCmd, a);
             args[a] = clang_getCString(cxargs[a]);
           }
 
           errorCode = index_compile_args(numArgs, args, idxAction,
                                          /*importedASTs=*/0, check_prefix);
 
           for (a=0; a<numArgs; ++a)
             clang_disposeString(cxargs[a]);
         }
+      file_end:
+        clang_CompileCommands_dispose(CCmds);
+      }
     } else {
       printf("database loading failed with error code %d.\n", ec);
       errorCode = -1;
     }
 
   cdb_end:
-    clang_CompileCommands_dispose(CCmds);
     clang_CompilationDatabase_dispose(db);
     free(tmp);
 
   }
 
   clang_IndexAction_dispose(idxAction);
   clang_disposeIndex(Idx);
   return errorCode;
fprintf(stderr,
     "       c-index-test -evaluate-cursor-at=<site> <compiler arguments>\n"
     "       c-index-test -get-macro-info-cursor-at=<site> <compiler arguments>\n"
     "       c-index-test -file-refs-at=<site> <compiler arguments>\n"
     "       c-index-test -file-includes-in=<filename> <compiler arguments>\n");
   fprintf(stderr,
     "       c-index-test -index-file [-check-prefix=<FileCheck prefix>] <compiler arguments>\n"
     "       c-index-test -index-file-full [-check-prefix=<FileCheck prefix>] <compiler arguments>\n"
     "       c-index-test -index-tu [-check-prefix=<FileCheck prefix>] <AST file>\n"
-    "       c-index-test -index-compile-db [-check-prefix=<FileCheck prefix>] <compilation database>\n"
+    "       c-index-test -index-compile-db [-check-prefix=<FileCheck prefix>] <compilation database> <files>\n"
     "       c-index-test -test-file-scan <AST file> <source file> "
           "[FileCheck prefix]\n");
   fprintf(stderr,
     "       c-index-test -test-load-tu <AST file> <symbol filter> "
           "[FileCheck prefix]\n"
     "       c-index-test -test-load-tu-usrs <AST file> <symbol filter> "
            "[FileCheck prefix]\n"
     "       c-index-test -test-load-source <symbol filter> {<args>}*\n");

tools/libclang/CXCompilationDatabase.cpp

if (!CCmd.empty())
       return new AllocatedCXCompileCommands(std::move(CCmd));
   }
 
   return nullptr;
 }
 
 CXCompileCommands
 clang_CompilationDatabase_getAllCompileCommands(CXCompilationDatabase CDb) {
-  if (CompilationDatabase *db = static_cast<CompilationDatabase *>(CDb)) {
-    std::vector<CompileCommand> CCmd(db->getAllCompileCommands());
-    if (!CCmd.empty())
-      return new AllocatedCXCompileCommands(std::move(CCmd));
-  }
-
+  // Left here for backwards compatibility.
+  // Enumerating the commands is not supported anymore.
   return nullptr;
 }
 
 void
 clang_CompileCommands_dispose(CXCompileCommands Cmds)
 {
   delete static_cast<AllocatedCXCompileCommands *>(Cmds);
 }

unittests/Tooling/CompilationDatabaseTest.cpp

TEST(JSONCompilationDatabase, ErrsOnInvalidFormat) {
   expectFailure("[{\"arguments\":\"\",\"file\":\"\"}]", "Missing directory");
   expectFailure("[{\"directory\":\"\",\"arguments\":\"\",\"file\":\"\"}]", "Arguments not array");
   expectFailure("[{\"directory\":\"\",\"command\":[],\"file\":\"\"}]", "Command not string");
   expectFailure("[{\"directory\":\"\",\"arguments\":[[]],\"file\":\"\"}]",
                 "Arguments contain non-string");
   expectFailure("[{\"output\":[]}]", "Expected strings as value.");
 }
 
-static std::vector<std::string> getAllFiles(StringRef JSONDatabase,
-                                            std::string &ErrorMessage,
-                                            JSONCommandLineSyntax Syntax) {
-  std::unique_ptr<CompilationDatabase> Database(
-      JSONCompilationDatabase::loadFromBuffer(JSONDatabase, ErrorMessage,
-                                              Syntax));
-  if (!Database) {
-    ADD_FAILURE() << ErrorMessage;
-    return std::vector<std::string>();
-  }
-  return Database->getAllFiles();
-}
-
-static std::vector<CompileCommand>
-getAllCompileCommands(JSONCommandLineSyntax Syntax, StringRef JSONDatabase,
-                      std::string &ErrorMessage) {
-  std::unique_ptr<CompilationDatabase> Database(
-      JSONCompilationDatabase::loadFromBuffer(JSONDatabase, ErrorMessage,
-                                              Syntax));
-  if (!Database) {
-    ADD_FAILURE() << ErrorMessage;
-    return std::vector<CompileCommand>();
-  }
-  return Database->getAllCompileCommands();
-}
-
-TEST(JSONCompilationDatabase, GetAllFiles) {
-  std::string ErrorMessage;
-  EXPECT_EQ(std::vector<std::string>(),
-            getAllFiles("[]", ErrorMessage, JSONCommandLineSyntax::Gnu))
-      << ErrorMessage;
-
-  std::vector<std::string> expected_files;
-  SmallString<16> PathStorage;
-  llvm::sys::path::native("//net/dir/file1", PathStorage);
-  expected_files.push_back(PathStorage.str());
-  llvm::sys::path::native("//net/dir/file2", PathStorage);
-  expected_files.push_back(PathStorage.str());
-  EXPECT_EQ(expected_files,
-            getAllFiles("[{\"directory\":\"//net/dir\","
-                        "\"command\":\"command\","
-                        "\"file\":\"file1\"},"
-                        " {\"directory\":\"//net/dir\","
-                        "\"command\":\"command\","
-                        "\"file\":\"file2\"}]",
-                        ErrorMessage, JSONCommandLineSyntax::Gnu))
-      << ErrorMessage;
-}
-
-TEST(JSONCompilationDatabase, GetAllCompileCommands) {
-  std::string ErrorMessage;
-  EXPECT_EQ(
-      0u, getAllCompileCommands(JSONCommandLineSyntax::Gnu, "[]", ErrorMessage)
-              .size())
-      << ErrorMessage;
-
-  StringRef Directory1("//net/dir1");
-  StringRef FileName1("file1");
-  StringRef Command1("command1");
-  StringRef Output1("file1.o");
-  StringRef Directory2("//net/dir2");
-  StringRef FileName2("file2");
-  StringRef Command2("command2");
-  StringRef Output2("");
-
-  std::vector<CompileCommand> Commands = getAllCompileCommands(
-      JSONCommandLineSyntax::Gnu,
-      ("[{\"directory\":\"" + Directory1 + "\"," + "\"command\":\"" + Command1 +
-       "\","
-       "\"file\":\"" +
-       FileName1 + "\", \"output\":\"" +
-       Output1 + "\"},"
-                   " {\"directory\":\"" +
-       Directory2 + "\"," + "\"command\":\"" + Command2 + "\","
-                                                          "\"file\":\"" +
-       FileName2 + "\"}]")
-          .str(),
-      ErrorMessage);
-  EXPECT_EQ(2U, Commands.size()) << ErrorMessage;
-  EXPECT_EQ(Directory1, Commands[0].Directory) << ErrorMessage;
-  EXPECT_EQ(FileName1, Commands[0].Filename) << ErrorMessage;
-  EXPECT_EQ(Output1, Commands[0].Output) << ErrorMessage;
-  ASSERT_EQ(1u, Commands[0].CommandLine.size());
-  EXPECT_EQ(Command1, Commands[0].CommandLine[0]) << ErrorMessage;
-  EXPECT_EQ(Directory2, Commands[1].Directory) << ErrorMessage;
-  EXPECT_EQ(FileName2, Commands[1].Filename) << ErrorMessage;
-  EXPECT_EQ(Output2, Commands[1].Output) << ErrorMessage;
-  ASSERT_EQ(1u, Commands[1].CommandLine.size());
-  EXPECT_EQ(Command2, Commands[1].CommandLine[0]) << ErrorMessage;
-
-  // Check that order is preserved.
-  Commands = getAllCompileCommands(
-      JSONCommandLineSyntax::Gnu,
-      ("[{\"directory\":\"" + Directory2 + "\"," + "\"command\":\"" + Command2 +
-       "\","
-       "\"file\":\"" +
-       FileName2 + "\"},"
-                   " {\"directory\":\"" +
-       Directory1 + "\"," + "\"command\":\"" + Command1 + "\","
-                                                          "\"file\":\"" +
-       FileName1 + "\"}]")
-          .str(),
-      ErrorMessage);
-  EXPECT_EQ(2U, Commands.size()) << ErrorMessage;
-  EXPECT_EQ(Directory2, Commands[0].Directory) << ErrorMessage;
-  EXPECT_EQ(FileName2, Commands[0].Filename) << ErrorMessage;
-  ASSERT_EQ(1u, Commands[0].CommandLine.size());
-  EXPECT_EQ(Command2, Commands[0].CommandLine[0]) << ErrorMessage;
-  EXPECT_EQ(Directory1, Commands[1].Directory) << ErrorMessage;
-  EXPECT_EQ(FileName1, Commands[1].Filename) << ErrorMessage;
-  ASSERT_EQ(1u, Commands[1].CommandLine.size());
-  EXPECT_EQ(Command1, Commands[1].CommandLine[0]) << ErrorMessage;
-}
-
 static CompileCommand findCompileArgsInJsonDatabase(StringRef FileName,
                                                     StringRef JSONDatabase,
                                                     std::string &ErrorMessage) {
   std::unique_ptr<CompilationDatabase> Database(
       JSONCompilationDatabase::loadFromBuffer(JSONDatabase, ErrorMessage,
                                               JSONCommandLineSyntax::Gnu));
   if (!Database)
     return CompileCommand();
TEST(FixedCompilationDatabase, ReturnsFixedCommandLine) {
   ExpectedCommandLine.insert(ExpectedCommandLine.end(),
                              CommandLine.begin(), CommandLine.end());
   ExpectedCommandLine.push_back("source");
   EXPECT_EQ(".", Result[0].Directory);
   EXPECT_EQ(FileName, Result[0].Filename);
   EXPECT_EQ(ExpectedCommandLine, Result[0].CommandLine);
 }
 
-TEST(FixedCompilationDatabase, GetAllFiles) {
-  std::vector<std::string> CommandLine;
-  CommandLine.push_back("one");
-  CommandLine.push_back("two");
-  FixedCompilationDatabase Database(".", CommandLine);
-
-  EXPECT_EQ(0ul, Database.getAllFiles().size());
-}
-
-TEST(FixedCompilationDatabase, GetAllCompileCommands) {
-  std::vector<std::string> CommandLine;
-  CommandLine.push_back("one");
-  CommandLine.push_back("two");
-  FixedCompilationDatabase Database(".", CommandLine);
-
-  EXPECT_EQ(0ul, Database.getAllCompileCommands().size());
-}
-
 TEST(ParseFixedCompilationDatabase, ReturnsNullOnEmptyArgumentList) {
   int Argc = 0;
   std::string ErrorMsg;
   std::unique_ptr<FixedCompilationDatabase> Database =
       FixedCompilationDatabase::loadFromCommandLine(Argc, nullptr, ErrorMsg);
   EXPECT_FALSE(Database);
   EXPECT_TRUE(ErrorMsg.empty());
   EXPECT_EQ(0, Argc);