[clang-tools-extra] r323204 - [clangd] Simplify code handling compile commands
Ilya Biryukov via cfe-commits
cfe-commits at lists.llvm.org
Tue Jan 23 07:07:52 PST 2018
Author: ibiryukov
Date: Tue Jan 23 07:07:52 2018
New Revision: 323204
URL: http://llvm.org/viewvc/llvm-project?rev=323204&view=rev
Log:
[clangd] Simplify code handling compile commands
Summary:
CppFile can now change compilation arguments during rebuild. This allows
simplifying code that manages CppFiles.
Reviewers: sammccall, bkramer, jkorous-apple
Reviewed By: sammccall
Subscribers: ioeric, jkorous-apple, klimek, cfe-commits
Differential Revision: https://reviews.llvm.org/D42173
Modified:
clang-tools-extra/trunk/clangd/ClangdServer.cpp
clang-tools-extra/trunk/clangd/ClangdServer.h
clang-tools-extra/trunk/clangd/ClangdUnit.cpp
clang-tools-extra/trunk/clangd/ClangdUnit.h
clang-tools-extra/trunk/clangd/ClangdUnitStore.cpp
clang-tools-extra/trunk/clangd/ClangdUnitStore.h
Modified: clang-tools-extra/trunk/clangd/ClangdServer.cpp
URL: http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/clangd/ClangdServer.cpp?rev=323204&r1=323203&r2=323204&view=diff
==============================================================================
--- clang-tools-extra/trunk/clangd/ClangdServer.cpp (original)
+++ clang-tools-extra/trunk/clangd/ClangdServer.cpp Tue Jan 23 07:07:52 2018
@@ -32,6 +32,18 @@ using namespace clang::clangd;
namespace {
+tooling::CompileCommand getCompileCommand(GlobalCompilationDatabase &CDB,
+ PathRef File, PathRef ResourceDir) {
+ llvm::Optional<tooling::CompileCommand> C = CDB.getCompileCommand(File);
+ if (!C) // FIXME: Suppress diagnostics? Let the user know?
+ C = CDB.getFallbackCommand(File);
+
+ // Inject the resource dir.
+ // FIXME: Don't overwrite it if it's already there.
+ C->CommandLine.push_back("-resource-dir=" + ResourceDir.str());
+ return std::move(*C);
+}
+
std::string getStandardResourceDir() {
static int Dummy; // Just an address in this process.
return CompilerInvocation::GetResourcesPath("clangd", (void *)&Dummy);
@@ -175,11 +187,12 @@ std::future<Context> ClangdServer::addDo
DocVersion Version = DraftMgr.updateDraft(File, Contents);
auto TaggedFS = FSProvider.getTaggedFileSystem(File);
- std::shared_ptr<CppFile> Resources = Units.getOrCreateFile(
- File, ResourceDir, CDB, StorePreamblesInMemory, PCHs);
+ std::shared_ptr<CppFile> Resources =
+ Units.getOrCreateFile(File, ResourceDir, StorePreamblesInMemory, PCHs);
return scheduleReparseAndDiags(std::move(Ctx), File,
VersionedDraft{Version, Contents.str()},
- std::move(Resources), std::move(TaggedFS));
+ std::move(Resources), std::move(TaggedFS),
+ /*AllowCachedCompileFlags=*/true);
}
std::future<Context> ClangdServer::removeDocument(Context Ctx, PathRef File) {
@@ -194,15 +207,11 @@ std::future<Context> ClangdServer::force
"forceReparse() was called for non-added document");
auto TaggedFS = FSProvider.getTaggedFileSystem(File);
- auto Recreated = Units.recreateFileIfCompileCommandChanged(
- File, ResourceDir, CDB, StorePreamblesInMemory, PCHs);
-
- // Note that std::future from this cleanup action is ignored.
- scheduleCancelRebuild(Ctx.clone(), std::move(Recreated.RemovedFile));
- // Schedule a reparse.
- return scheduleReparseAndDiags(std::move(Ctx), File, std::move(FileContents),
- std::move(Recreated.FileInCollection),
- std::move(TaggedFS));
+ std::shared_ptr<CppFile> Resources =
+ Units.getOrCreateFile(File, ResourceDir, StorePreamblesInMemory, PCHs);
+ return scheduleReparseAndDiags(std::move(Ctx), File, FileContents,
+ std::move(Resources), std::move(TaggedFS),
+ /*AllowCachedCompileFlags=*/false);
}
std::future<std::pair<Context, Tagged<CompletionList>>>
@@ -268,20 +277,24 @@ void ClangdServer::codeComplete(
Path FileStr = File;
// Copy PCHs to avoid accessing this->PCHs concurrently
std::shared_ptr<PCHContainerOperations> PCHs = this->PCHs;
+
+ assert(Resources->getLastCommand() &&
+ "CppFile is in inconsistent state, missing CompileCommand");
+ tooling::CompileCommand CompileCommand = *Resources->getLastCommand();
+
// A task that will be run asynchronously.
auto Task =
// 'mutable' to reassign Preamble variable.
[FileStr, Preamble, Resources, Contents, Pos, CodeCompleteOpts, TaggedFS,
- PCHs](Context Ctx, CallbackType Callback) mutable {
+ PCHs, CompileCommand](Context Ctx, CallbackType Callback) mutable {
if (!Preamble) {
// Maybe we built some preamble before processing this request.
Preamble = Resources->getPossiblyStalePreamble();
}
// FIXME(ibiryukov): even if Preamble is non-null, we may want to check
// both the old and the new version in case only one of them matches.
-
CompletionList Result = clangd::codeComplete(
- Ctx, FileStr, Resources->getCompileCommand(),
+ Ctx, FileStr, CompileCommand,
Preamble ? &Preamble->Preamble : nullptr, Contents, Pos,
TaggedFS.Value, PCHs, CodeCompleteOpts);
@@ -319,9 +332,12 @@ ClangdServer::signatureHelp(const Contex
"signatureHelp is called for non-added document",
llvm::errc::invalid_argument);
+ assert(Resources->getLastCommand() &&
+ "CppFile is in inconsistent state, missing CompileCommand");
+
auto Preamble = Resources->getPossiblyStalePreamble();
auto Result =
- clangd::signatureHelp(Ctx, File, Resources->getCompileCommand(),
+ clangd::signatureHelp(Ctx, File, *Resources->getLastCommand(),
Preamble ? &Preamble->Preamble : nullptr,
*OverridenContents, Pos, TaggedFS.Value, PCHs);
return make_tagged(std::move(Result), TaggedFS.Tag);
@@ -555,12 +571,20 @@ ClangdServer::findDocumentHighlights(con
std::future<Context> ClangdServer::scheduleReparseAndDiags(
Context Ctx, PathRef File, VersionedDraft Contents,
std::shared_ptr<CppFile> Resources,
- Tagged<IntrusiveRefCntPtr<vfs::FileSystem>> TaggedFS) {
+ Tagged<IntrusiveRefCntPtr<vfs::FileSystem>> TaggedFS,
+ bool AllowCachedCompileFlags) {
+ llvm::Optional<tooling::CompileCommand> ReusedCommand;
+ if (AllowCachedCompileFlags)
+ ReusedCommand = Resources->getLastCommand();
+ tooling::CompileCommand Command =
+ ReusedCommand ? std::move(*ReusedCommand)
+ : getCompileCommand(CDB, File, ResourceDir);
+ ParseInputs Inputs = {std::move(Command), std::move(TaggedFS.Value),
+ *std::move(Contents.Draft)};
assert(Contents.Draft && "Draft must have contents");
UniqueFunction<llvm::Optional<std::vector<DiagWithFixIts>>(const Context &)>
- DeferredRebuild =
- Resources->deferRebuild(*Contents.Draft, TaggedFS.Value);
+ DeferredRebuild = Resources->deferRebuild(std::move(Inputs));
std::promise<Context> DonePromise;
std::future<Context> DoneFuture = DonePromise.get_future();
Modified: clang-tools-extra/trunk/clangd/ClangdServer.h
URL: http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/clangd/ClangdServer.h?rev=323204&r1=323203&r2=323204&view=diff
==============================================================================
--- clang-tools-extra/trunk/clangd/ClangdServer.h (original)
+++ clang-tools-extra/trunk/clangd/ClangdServer.h Tue Jan 23 07:07:52 2018
@@ -331,7 +331,8 @@ private:
std::future<Context>
scheduleReparseAndDiags(Context Ctx, PathRef File, VersionedDraft Contents,
std::shared_ptr<CppFile> Resources,
- Tagged<IntrusiveRefCntPtr<vfs::FileSystem>> TaggedFS);
+ Tagged<IntrusiveRefCntPtr<vfs::FileSystem>> TaggedFS,
+ bool AllowCachedCompileFlags);
std::future<Context>
scheduleCancelRebuild(Context Ctx, std::shared_ptr<CppFile> Resources);
Modified: clang-tools-extra/trunk/clangd/ClangdUnit.cpp
URL: http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/clangd/ClangdUnit.cpp?rev=323204&r1=323203&r2=323204&view=diff
==============================================================================
--- clang-tools-extra/trunk/clangd/ClangdUnit.cpp (original)
+++ clang-tools-extra/trunk/clangd/ClangdUnit.cpp Tue Jan 23 07:07:52 2018
@@ -273,7 +273,6 @@ SourceLocation getMacroArgExpandedLocati
return Mgr.getMacroArgExpandedLocation(InputLoc);
}
-
} // namespace
void ParsedAST::ensurePreambleDeclsDeserialized() {
@@ -359,27 +358,22 @@ ParsedASTWrapper::ParsedASTWrapper(llvm:
: AST(std::move(AST)) {}
std::shared_ptr<CppFile>
-CppFile::Create(PathRef FileName, tooling::CompileCommand Command,
- bool StorePreamblesInMemory,
+CppFile::Create(PathRef FileName, bool StorePreamblesInMemory,
std::shared_ptr<PCHContainerOperations> PCHs,
ASTParsedCallback ASTCallback) {
- return std::shared_ptr<CppFile>(
- new CppFile(FileName, std::move(Command), StorePreamblesInMemory,
- std::move(PCHs), std::move(ASTCallback)));
+ return std::shared_ptr<CppFile>(new CppFile(FileName, StorePreamblesInMemory,
+ std::move(PCHs),
+ std::move(ASTCallback)));
}
-CppFile::CppFile(PathRef FileName, tooling::CompileCommand Command,
- bool StorePreamblesInMemory,
+CppFile::CppFile(PathRef FileName, bool StorePreamblesInMemory,
std::shared_ptr<PCHContainerOperations> PCHs,
ASTParsedCallback ASTCallback)
- : FileName(FileName), Command(std::move(Command)),
- StorePreamblesInMemory(StorePreamblesInMemory), RebuildCounter(0),
- RebuildInProgress(false), PCHs(std::move(PCHs)),
+ : FileName(FileName), StorePreamblesInMemory(StorePreamblesInMemory),
+ RebuildCounter(0), RebuildInProgress(false), PCHs(std::move(PCHs)),
ASTCallback(std::move(ASTCallback)) {
// FIXME(ibiryukov): we should pass a proper Context here.
- log(Context::empty(), "Opened file " + FileName + " with command [" +
- this->Command.Directory + "] " +
- llvm::join(this->Command.CommandLine, " "));
+ log(Context::empty(), "Created CppFile for " + FileName);
std::lock_guard<std::mutex> Lock(Mutex);
LatestAvailablePreamble = nullptr;
@@ -431,14 +425,12 @@ UniqueFunction<void()> CppFile::deferCan
}
llvm::Optional<std::vector<DiagWithFixIts>>
-CppFile::rebuild(const Context &Ctx, StringRef NewContents,
- IntrusiveRefCntPtr<vfs::FileSystem> VFS) {
- return deferRebuild(NewContents, std::move(VFS))(Ctx);
+CppFile::rebuild(const Context &Ctx, ParseInputs &&Inputs) {
+ return deferRebuild(std::move(Inputs))(Ctx);
}
UniqueFunction<llvm::Optional<std::vector<DiagWithFixIts>>(const Context &)>
-CppFile::deferRebuild(StringRef NewContents,
- IntrusiveRefCntPtr<vfs::FileSystem> VFS) {
+CppFile::deferRebuild(ParseInputs &&Inputs) {
std::shared_ptr<const PreambleData> OldPreamble;
std::shared_ptr<PCHContainerOperations> PCHs;
unsigned RequestRebuildCounter;
@@ -463,6 +455,7 @@ CppFile::deferRebuild(StringRef NewConte
this->ASTPromise = std::promise<std::shared_ptr<ParsedASTWrapper>>();
this->ASTFuture = this->ASTPromise.get_future();
}
+ this->LastCommand = Inputs.CompileCommand;
} // unlock Mutex.
// Notify about changes to RebuildCounter.
RebuildCond.notify_all();
@@ -473,10 +466,15 @@ CppFile::deferRebuild(StringRef NewConte
// Don't let this CppFile die before rebuild is finished.
std::shared_ptr<CppFile> That = shared_from_this();
auto FinishRebuild =
- [OldPreamble, VFS, RequestRebuildCounter, PCHs,
- That](std::string NewContents,
+ [OldPreamble, RequestRebuildCounter, PCHs,
+ That](ParseInputs Inputs,
const Context &Ctx) mutable /* to allow changing OldPreamble. */
-> llvm::Optional<std::vector<DiagWithFixIts>> {
+ log(Context::empty(),
+ "Rebuilding file " + That->FileName + " with command [" +
+ Inputs.CompileCommand.Directory + "] " +
+ llvm::join(Inputs.CompileCommand.CommandLine, " "));
+
// Only one execution of this method is possible at a time.
// RebuildGuard will wait for any ongoing rebuilds to finish and will put us
// into a state for doing a rebuild.
@@ -485,10 +483,10 @@ CppFile::deferRebuild(StringRef NewConte
return llvm::None;
std::vector<const char *> ArgStrs;
- for (const auto &S : That->Command.CommandLine)
+ for (const auto &S : Inputs.CompileCommand.CommandLine)
ArgStrs.push_back(S.c_str());
- VFS->setCurrentWorkingDirectory(That->Command.Directory);
+ Inputs.FS->setCurrentWorkingDirectory(Inputs.CompileCommand.Directory);
std::unique_ptr<CompilerInvocation> CI;
{
@@ -498,15 +496,15 @@ CppFile::deferRebuild(StringRef NewConte
IntrusiveRefCntPtr<DiagnosticsEngine> CommandLineDiagsEngine =
CompilerInstance::createDiagnostics(new DiagnosticOptions,
&IgnoreDiagnostics, false);
- CI =
- createInvocationFromCommandLine(ArgStrs, CommandLineDiagsEngine, VFS);
+ CI = createInvocationFromCommandLine(ArgStrs, CommandLineDiagsEngine,
+ Inputs.FS);
// createInvocationFromCommandLine sets DisableFree.
CI->getFrontendOpts().DisableFree = false;
}
assert(CI && "Couldn't create CompilerInvocation");
std::unique_ptr<llvm::MemoryBuffer> ContentsBuffer =
- llvm::MemoryBuffer::getMemBufferCopy(NewContents, That->FileName);
+ llvm::MemoryBuffer::getMemBufferCopy(Inputs.Contents, That->FileName);
// A helper function to rebuild the preamble or reuse the existing one. Does
// not mutate any fields of CppFile, only does the actual computation.
@@ -515,8 +513,9 @@ CppFile::deferRebuild(StringRef NewConte
[&]() mutable -> std::shared_ptr<const PreambleData> {
auto Bounds =
ComputePreambleBounds(*CI->getLangOpts(), ContentsBuffer.get(), 0);
- if (OldPreamble && OldPreamble->Preamble.CanReuse(
- *CI, ContentsBuffer.get(), Bounds, VFS.get())) {
+ if (OldPreamble &&
+ OldPreamble->Preamble.CanReuse(*CI, ContentsBuffer.get(), Bounds,
+ Inputs.FS.get())) {
log(Ctx, "Reusing preamble for file " + Twine(That->FileName));
return OldPreamble;
}
@@ -541,7 +540,8 @@ CppFile::deferRebuild(StringRef NewConte
CppFilePreambleCallbacks SerializedDeclsCollector;
auto BuiltPreamble = PrecompiledPreamble::Build(
- *CI, ContentsBuffer.get(), Bounds, *PreambleDiagsEngine, VFS, PCHs,
+ *CI, ContentsBuffer.get(), Bounds, *PreambleDiagsEngine, Inputs.FS,
+ PCHs,
/*StoreInMemory=*/That->StorePreamblesInMemory,
SerializedDeclsCollector);
@@ -590,7 +590,7 @@ CppFile::deferRebuild(StringRef NewConte
trace::Span Tracer(Ctx, "Build");
SPAN_ATTACH(Tracer, "File", That->FileName);
NewAST = ParsedAST::Build(Ctx, std::move(CI), std::move(NewPreamble),
- std::move(ContentsBuffer), PCHs, VFS);
+ std::move(ContentsBuffer), PCHs, Inputs.FS);
}
if (NewAST) {
@@ -617,7 +617,7 @@ CppFile::deferRebuild(StringRef NewConte
return Diagnostics;
};
- return BindWithForward(FinishRebuild, NewContents.str());
+ return BindWithForward(FinishRebuild, std::move(Inputs));
}
std::shared_future<std::shared_ptr<const PreambleData>>
@@ -636,8 +636,9 @@ std::shared_future<std::shared_ptr<Parse
return ASTFuture;
}
-tooling::CompileCommand const &CppFile::getCompileCommand() const {
- return Command;
+llvm::Optional<tooling::CompileCommand> CppFile::getLastCommand() const {
+ std::lock_guard<std::mutex> Lock(Mutex);
+ return LastCommand;
}
CppFile::RebuildGuard::RebuildGuard(CppFile &File,
Modified: clang-tools-extra/trunk/clangd/ClangdUnit.h
URL: http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/clangd/ClangdUnit.h?rev=323204&r1=323203&r2=323204&view=diff
==============================================================================
--- clang-tools-extra/trunk/clangd/ClangdUnit.h (original)
+++ clang-tools-extra/trunk/clangd/ClangdUnit.h Tue Jan 23 07:07:52 2018
@@ -58,6 +58,13 @@ struct PreambleData {
std::vector<DiagWithFixIts> Diags;
};
+/// Information required to run clang, e.g. to parse AST or do code completion.
+struct ParseInputs {
+ tooling::CompileCommand CompileCommand;
+ IntrusiveRefCntPtr<vfs::FileSystem> FS;
+ std::string Contents;
+};
+
/// Stores and provides access to parsed AST.
class ParsedAST {
public:
@@ -147,14 +154,12 @@ public:
// We only allow to create CppFile as shared_ptr, because a future returned by
// deferRebuild will hold references to it.
static std::shared_ptr<CppFile>
- Create(PathRef FileName, tooling::CompileCommand Command,
- bool StorePreamblesInMemory,
+ Create(PathRef FileName, bool StorePreamblesInMemory,
std::shared_ptr<PCHContainerOperations> PCHs,
ASTParsedCallback ASTCallback);
private:
- CppFile(PathRef FileName, tooling::CompileCommand Command,
- bool StorePreamblesInMemory,
+ CppFile(PathRef FileName, bool StorePreamblesInMemory,
std::shared_ptr<PCHContainerOperations> PCHs,
ASTParsedCallback ASTCallback);
@@ -177,9 +182,8 @@ public:
/// Returns a list of diagnostics or a llvm::None, if another rebuild was
/// requested in parallel (effectively cancelling this rebuild) before
/// diagnostics were produced.
- llvm::Optional<std::vector<DiagWithFixIts>>
- rebuild(const Context &Ctx, StringRef NewContents,
- IntrusiveRefCntPtr<vfs::FileSystem> VFS);
+ llvm::Optional<std::vector<DiagWithFixIts>> rebuild(const Context &Ctx,
+ ParseInputs &&Inputs);
/// Schedule a rebuild and return a deferred computation that will finish the
/// rebuild, that can be called on a different thread.
@@ -196,7 +200,7 @@ public:
/// reparse, or None, if another deferRebuild was called before this
/// rebuild was finished.
UniqueFunction<llvm::Optional<std::vector<DiagWithFixIts>>(const Context &)>
- deferRebuild(StringRef NewContents, IntrusiveRefCntPtr<vfs::FileSystem> VFS);
+ deferRebuild(ParseInputs &&Inputs);
/// Returns a future to get the most fresh PreambleData for a file. The
/// future will wait until the Preamble is rebuilt.
@@ -212,8 +216,13 @@ public:
/// always be non-null.
std::shared_future<std::shared_ptr<ParsedASTWrapper>> getAST() const;
- /// Get CompileCommand used to build this CppFile.
- tooling::CompileCommand const &getCompileCommand() const;
+ /// Get the latest CompileCommand used to build this CppFile. Returns
+ /// llvm::None before first call to rebuild() or after calls to
+ /// cancelRebuild().
+ // In practice we always call rebuild() when adding a CppFile to the
+ // CppFileCollection, and only `cancelRebuild()` after removing it. This means
+ // files in the CppFileCollection always have a compile command available.
+ llvm::Optional<tooling::CompileCommand> getLastCommand() const;
private:
/// A helper guard that manages the state of CppFile during rebuild.
@@ -231,7 +240,6 @@ private:
};
Path FileName;
- tooling::CompileCommand Command;
bool StorePreamblesInMemory;
/// Mutex protects all fields, declared below it, FileName and Command are not
@@ -243,6 +251,7 @@ private:
bool RebuildInProgress;
/// Condition variable to indicate changes to RebuildInProgress.
std::condition_variable RebuildCond;
+ llvm::Optional<tooling::CompileCommand> LastCommand;
/// Promise and future for the latests AST. Fulfilled during rebuild.
/// We use std::shared_ptr here because MVSC fails to compile non-copyable
Modified: clang-tools-extra/trunk/clangd/ClangdUnitStore.cpp
URL: http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/clangd/ClangdUnitStore.cpp?rev=323204&r1=323203&r2=323204&view=diff
==============================================================================
--- clang-tools-extra/trunk/clangd/ClangdUnitStore.cpp (original)
+++ clang-tools-extra/trunk/clangd/ClangdUnitStore.cpp Tue Jan 23 07:07:52 2018
@@ -25,53 +25,3 @@ std::shared_ptr<CppFile> CppFileCollecti
OpenedFiles.erase(It);
return Result;
}
-
-CppFileCollection::RecreateResult
-CppFileCollection::recreateFileIfCompileCommandChanged(
- PathRef File, PathRef ResourceDir, GlobalCompilationDatabase &CDB,
- bool StorePreamblesInMemory, std::shared_ptr<PCHContainerOperations> PCHs) {
- auto NewCommand = getCompileCommand(CDB, File, ResourceDir);
-
- std::lock_guard<std::mutex> Lock(Mutex);
-
- RecreateResult Result;
-
- auto It = OpenedFiles.find(File);
- if (It == OpenedFiles.end()) {
- It = OpenedFiles
- .try_emplace(File, CppFile::Create(File, std::move(NewCommand),
- StorePreamblesInMemory,
- std::move(PCHs), ASTCallback))
- .first;
- } else if (!compileCommandsAreEqual(It->second->getCompileCommand(),
- NewCommand)) {
- Result.RemovedFile = std::move(It->second);
- It->second =
- CppFile::Create(File, std::move(NewCommand), StorePreamblesInMemory,
- std::move(PCHs), ASTCallback);
- }
- Result.FileInCollection = It->second;
- return Result;
-}
-
-tooling::CompileCommand
-CppFileCollection::getCompileCommand(GlobalCompilationDatabase &CDB,
- PathRef File, PathRef ResourceDir) {
- llvm::Optional<tooling::CompileCommand> C = CDB.getCompileCommand(File);
- if (!C) // FIXME: Suppress diagnostics? Let the user know?
- C = CDB.getFallbackCommand(File);
-
- // Inject the resource dir.
- // FIXME: Don't overwrite it if it's already there.
- C->CommandLine.push_back("-resource-dir=" + ResourceDir.str());
- return std::move(*C);
-}
-
-bool CppFileCollection::compileCommandsAreEqual(
- tooling::CompileCommand const &LHS, tooling::CompileCommand const &RHS) {
- // tooling::CompileCommand.Output is ignored, it's not relevant for clangd.
- return LHS.Directory == RHS.Directory &&
- LHS.CommandLine.size() == RHS.CommandLine.size() &&
- std::equal(LHS.CommandLine.begin(), LHS.CommandLine.end(),
- RHS.CommandLine.begin());
-}
Modified: clang-tools-extra/trunk/clangd/ClangdUnitStore.h
URL: http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/clangd/ClangdUnitStore.h?rev=323204&r1=323203&r2=323204&view=diff
==============================================================================
--- clang-tools-extra/trunk/clangd/ClangdUnitStore.h (original)
+++ clang-tools-extra/trunk/clangd/ClangdUnitStore.h Tue Jan 23 07:07:52 2018
@@ -32,42 +32,19 @@ public:
std::shared_ptr<CppFile>
getOrCreateFile(PathRef File, PathRef ResourceDir,
- GlobalCompilationDatabase &CDB, bool StorePreamblesInMemory,
+ bool StorePreamblesInMemory,
std::shared_ptr<PCHContainerOperations> PCHs) {
std::lock_guard<std::mutex> Lock(Mutex);
-
auto It = OpenedFiles.find(File);
if (It == OpenedFiles.end()) {
- auto Command = getCompileCommand(CDB, File, ResourceDir);
-
It = OpenedFiles
- .try_emplace(File, CppFile::Create(File, std::move(Command),
- StorePreamblesInMemory,
+ .try_emplace(File, CppFile::Create(File, StorePreamblesInMemory,
std::move(PCHs), ASTCallback))
.first;
}
return It->second;
}
- struct RecreateResult {
- /// A CppFile, stored in this CppFileCollection for the corresponding
- /// filepath after calling recreateFileIfCompileCommandChanged.
- std::shared_ptr<CppFile> FileInCollection;
- /// If a new CppFile had to be created to account for changed
- /// CompileCommand, a previous CppFile instance will be returned in this
- /// field.
- std::shared_ptr<CppFile> RemovedFile;
- };
-
- /// Similar to getOrCreateFile, but will replace a current CppFile for \p File
- /// with a new one if CompileCommand, provided by \p CDB has changed.
- /// If a currently stored CppFile had to be replaced, the previous instance
- /// will be returned in RecreateResult.RemovedFile.
- RecreateResult recreateFileIfCompileCommandChanged(
- PathRef File, PathRef ResourceDir, GlobalCompilationDatabase &CDB,
- bool StorePreamblesInMemory,
- std::shared_ptr<PCHContainerOperations> PCHs);
-
std::shared_ptr<CppFile> getFile(PathRef File) {
std::lock_guard<std::mutex> Lock(Mutex);
@@ -82,12 +59,6 @@ public:
std::shared_ptr<CppFile> removeIfPresent(PathRef File);
private:
- tooling::CompileCommand getCompileCommand(GlobalCompilationDatabase &CDB,
- PathRef File, PathRef ResourceDir);
-
- bool compileCommandsAreEqual(tooling::CompileCommand const &LHS,
- tooling::CompileCommand const &RHS);
-
std::mutex Mutex;
llvm::StringMap<std::shared_ptr<CppFile>> OpenedFiles;
ASTParsedCallback ASTCallback;
More information about the cfe-commits
mailing list