Zengtudor/ccls
1
0
Fork 0
mirror of https://github.com/MaskRay/ccls.git synced 2024-11-30 03:17:08 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Remove ASTUnit from indexer and clean up

Browse Source
This commit is contained in:
Fangrui Song 2018-08-30 00:29:08 -07:00
parent 5cc3006a3a
commit 407c7cc29d
9 changed files with 65 additions and 149 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
index_tests/_empty_test.cc
View File

@ -1,10 +1,4 @@
/*
OUTPUT:
{
"includes": [],
"skipped_ranges": [],
"usr2func": [],
"usr2type": [],
"usr2var": []
}
{}
*/

42
src/clang_complete.cc
View File

@ -21,7 +21,6 @@ limitations under the License.
#include "platform.h"
#include <clang/Frontend/CompilerInstance.h>
#include <clang/Frontend/FrontendDiagnostic.h>
#include <clang/Lex/PreprocessorOptions.h>
#include <clang/Sema/CodeCompleteConsumer.h>
#include <llvm/ADT/Twine.h>
@ -397,10 +396,6 @@ public:
}
}
void ProcessOverloadCandidates(Sema &S, unsigned CurrentArg,
OverloadCandidate *Candidates,
unsigned NumCandidates) override {}
CodeCompletionAllocator &getAllocator() override { return *Alloc; }
CodeCompletionTUInfo &getCodeCompletionTUInfo() override { return CCTUInfo; }
@ -484,29 +479,9 @@ public:
}
};
std::unique_ptr<CompilerInvocation>
buildCompilerInvocation(const std::vector<std::string> &args,
IntrusiveRefCntPtr<vfs::FileSystem> VFS) {
std::vector<const char *> cargs;
for (auto &arg : args)
cargs.push_back(arg.c_str());
IntrusiveRefCntPtr<DiagnosticsEngine> Diags(
CompilerInstance::createDiagnostics(new DiagnosticOptions));
std::unique_ptr<CompilerInvocation> CI =
createInvocationFromCommandLine(cargs, Diags, VFS);
if (CI) {
CI->getFrontendOpts().DisableFree = false;
CI->getLangOpts()->CommentOpts.ParseAllComments = true;
CI->getLangOpts()->SpellChecking = false;
}
return CI;
}
std::unique_ptr<CompilerInstance>
BuildCompilerInstance(CompletionSession &session,
std::unique_ptr<CompilerInvocation> CI,
DiagnosticConsumer &DC,
const WorkingFiles::Snapshot &snapshot,
std::unique_ptr<CompilerInstance> BuildCompilerInstance(
CompletionSession &session, std::unique_ptr<CompilerInvocation> CI,
DiagnosticConsumer &DC, const WorkingFiles::Snapshot &snapshot,
std::vector<std::unique_ptr<llvm::MemoryBuffer>> &Bufs) {
for (auto &file : snapshot.files) {
Bufs.push_back(llvm::MemoryBuffer::getMemBuffer(file.content));
@ -570,7 +545,7 @@ void CompletionPreloadMain(ClangCompleteManager *completion_manager) {
LOG_S(INFO) << "create completion session for " << session->file.filename;
if (std::unique_ptr<CompilerInvocation> CI =
buildCompilerInvocation(args, session->FS))
BuildCompilerInvocation(args, session->FS))
session->BuildPreamble(*CI);
}
}
@ -595,10 +570,12 @@ void CompletionQueryMain(ClangCompleteManager *completion_manager) {
true /*create_if_needed*/);
std::unique_ptr<CompilerInvocation> CI =
buildCompilerInvocation(session->file.args, session->FS);
BuildCompilerInvocation(session->file.args, session->FS);
if (!CI)
continue;
CI->getDiagnosticOpts().IgnoreWarnings = true;
clang::CodeCompleteOptions CCOpts;
CCOpts.IncludeBriefComments = true;
#if LLVM_VERSION_MAJOR >= 7
CCOpts.IncludeFixIts = true;
#endif
@ -608,6 +585,8 @@ void CompletionQueryMain(ClangCompleteManager *completion_manager) {
FOpts.CodeCompletionAt.FileName = session->file.filename;
FOpts.CodeCompletionAt.Line = request->position.line + 1;
FOpts.CodeCompletionAt.Column = request->position.character + 1;
FOpts.SkipFunctionBodies = true;
CI->getLangOpts()->CommentOpts.ParseAllComments = true;
StoreDiags DC;
WorkingFiles::Snapshot snapshot =
@ -641,7 +620,7 @@ void DiagnosticQueryMain(ClangCompleteManager *manager) {
path, true /*mark_as_completion*/, true /*create_if_needed*/);
std::unique_ptr<CompilerInvocation> CI =
buildCompilerInvocation(session->file.args, session->FS);
BuildCompilerInvocation(session->file.args, session->FS);
if (!CI)
continue;
StoreDiags DC;
@ -701,6 +680,7 @@ void CompletionSession::BuildPreamble(CompilerInvocation &CI) {
if (OldP && OldP->Preamble.CanReuse(CI, Buf.get(), Bounds, FS.get()))
return;
CI.getFrontendOpts().SkipFunctionBodies = true;
CI.getLangOpts()->CommentOpts.ParseAllComments = true;
#if LLVM_VERSION_MAJOR >= 7
CI.getPreprocessorOpts().WriteCommentListToPCH = false;
#endif

17
src/clang_tu.cc
View File

@ -63,3 +63,20 @@ Range FromTokenRange(const SourceManager &SM, const LangOptions &LangOpts,
return FromCharSourceRange(SM, LangOpts, CharSourceRange::getTokenRange(R),
UniqueID);
}
std::unique_ptr<CompilerInvocation>
BuildCompilerInvocation(const std::vector<std::string> &args,
IntrusiveRefCntPtr<vfs::FileSystem> VFS) {
std::vector<const char *> cargs;
for (auto &arg : args)
cargs.push_back(arg.c_str());
IntrusiveRefCntPtr<DiagnosticsEngine> Diags(
CompilerInstance::createDiagnostics(new DiagnosticOptions));
std::unique_ptr<CompilerInvocation> CI =
createInvocationFromCommandLine(cargs, Diags, VFS);
if (CI) {
CI->getFrontendOpts().DisableFree = false;
CI->getLangOpts()->SpellChecking = false;
}
return CI;
}

5
src/clang_tu.h
View File

@ -18,6 +18,7 @@ limitations under the License.
#include <clang/Basic/LangOptions.h>
#include <clang/Basic/SourceManager.h>
#include <clang/Frontend/CompilerInstance.h>
#include <stdlib.h>
@ -33,3 +34,7 @@ Range FromCharRange(const clang::SourceManager &SM,
Range FromTokenRange(const clang::SourceManager &SM,
const clang::LangOptions &LangOpts, clang::SourceRange R,
llvm::sys::fs::UniqueID *UniqueID = nullptr);
std::unique_ptr<clang::CompilerInvocation>
BuildCompilerInvocation(const std::vector<std::string> &args,
llvm::IntrusiveRefCntPtr<clang::vfs::FileSystem> VFS);

87
src/indexer.cc
View File

@ -22,8 +22,6 @@ limitations under the License.
using ccls::Intern;
#include <clang/AST/AST.h>
#include <clang/Frontend/ASTUnit.h>
#include <clang/Frontend/CompilerInstance.h>
#include <clang/Frontend/FrontendAction.h>
#include <clang/Index/IndexDataConsumer.h>
#include <clang/Index/IndexingAction.h>
@ -57,13 +55,10 @@ struct IndexParam {
};
std::unordered_map<const Decl *, DeclInfo> Decl2Info;
ASTUnit &Unit;
ASTContext *Ctx;
FileConsumer *file_consumer = nullptr;
IndexParam(ASTUnit &Unit, FileConsumer *file_consumer)
: Unit(Unit), file_consumer(file_consumer) {}
IndexParam(FileConsumer *file_consumer) : file_consumer(file_consumer) {}
IndexFile *ConsumeFile(const FileEntry &File) {
IndexFile *db = file_consumer->TryConsumeFile(File, &file_contents);
@ -1173,21 +1168,15 @@ Index(VFS *vfs, const std::string &opt_wdir, const std::string &file,
if (!g_config->index.enabled)
return {};
std::vector<const char *> Args;
for (auto &arg : args)
Args.push_back(arg.c_str());
auto PCHCO = std::make_shared<PCHContainerOperations>();
IntrusiveRefCntPtr<DiagnosticsEngine> Diags(
CompilerInstance::createDiagnostics(new DiagnosticOptions));
std::shared_ptr<CompilerInvocation> CI =
createInvocationFromCommandLine(Args, Diags);
auto PCH = std::make_shared<PCHContainerOperations>();
llvm::IntrusiveRefCntPtr<vfs::FileSystem> FS = vfs::getRealFileSystem();
std::shared_ptr<CompilerInvocation> CI = BuildCompilerInvocation(args, FS);
if (!CI)
return {};
// -fparse-all-comments enables documentation in the indexer and in
// code completion.
if (g_config->index.comments > 1)
CI->getLangOpts()->CommentOpts.ParseAllComments = true;
CI->getLangOpts()->SpellChecking = false;
{
// FileSystemOptions& FSOpts = CI->getFileSystemOpts();
// if (FSOpts.WorkingDir.empty())
@ -1200,20 +1189,18 @@ Index(VFS *vfs, const std::string &opt_wdir, const std::string &file,
// HSOpts.ResourceDir = g_config->clang.resourceDir;
}
std::vector<std::unique_ptr<llvm::MemoryBuffer>> BufOwner;
for (auto &c : file_contents) {
std::unique_ptr<llvm::MemoryBuffer> MB =
llvm::MemoryBuffer::getMemBufferCopy(c.content, c.path);
CI->getPreprocessorOpts().addRemappedFile(c.path, MB.get());
BufOwner.push_back(std::move(MB));
}
auto Unit = ASTUnit::create(CI, Diags, true, true);
if (!Unit)
DiagnosticConsumer DC;
auto Clang = std::make_unique<CompilerInstance>(PCH);
Clang->setInvocation(std::move(CI));
Clang->setVirtualFileSystem(FS);
Clang->createDiagnostics(&DC, false);
Clang->setTarget(TargetInfo::CreateTargetInfo(
Clang->getDiagnostics(), Clang->getInvocation().TargetOpts));
if (!Clang->hasTarget())
return {};
FileConsumer file_consumer(vfs, file);
IndexParam param(*Unit, &file_consumer);
IndexParam param(&file_consumer);
auto DataConsumer = std::make_shared<IndexDataConsumer>(param);
index::IndexingOptions IndexOpts;
@ -1224,36 +1211,30 @@ Index(VFS *vfs, const std::string &opt_wdir, const std::string &file,
IndexOpts.IndexImplicitInstantiation = true;
#endif
std::unique_ptr<FrontendAction> IndexAction = createIndexingAction(
std::unique_ptr<FrontendAction> Action = createIndexingAction(
DataConsumer, IndexOpts, std::make_unique<IndexFrontendAction>(param));
DiagnosticErrorTrap DiagTrap(*Diags);
bool ok = false;
{
llvm::CrashRecoveryContext CRC;
auto compile = [&]() {
ASTUnit::LoadFromCompilerInvocationAction(
std::move(CI), PCHCO, Diags, IndexAction.get(), Unit.get(),
/*Persistent=*/true, /*ResourceDir=*/"",
/*OnlyLocalDecls=*/true,
/*CaptureDiagnostics=*/true, 0, false, false,
/*UserFilesAreVolatile=*/true);
auto parse = [&]() {
if (!Action->BeginSourceFile(*Clang, Clang->getFrontendOpts().Inputs[0]))
return;
if (!Action->Execute())
return;
Action->EndSourceFile();
ok = true;
};
if (!CRC.RunSafely(compile)) {
if (!CRC.RunSafely(parse)) {
LOG_S(ERROR) << "clang crashed for " << file;
return {};
}
if (!Unit) {
}
if (!ok) {
LOG_S(ERROR) << "failed to index " << file;
return {};
}
const SourceManager &SM = Unit->getSourceManager();
const FileEntry *FE = SM.getFileEntryForID(SM.getMainFileID());
IndexFile *main_file = param.ConsumeFile(*FE);
std::unordered_map<std::string, int> inc_to_line;
if (main_file)
for (auto &inc : main_file->includes)
inc_to_line[inc.resolved_path] = inc.line;
auto result = param.file_consumer->TakeLocalState();
for (std::unique_ptr<IndexFile> &entry : result) {
entry->import_file = file;
@ -1276,22 +1257,6 @@ Index(VFS *vfs, const std::string &opt_wdir, const std::string &file,
for (auto &it : entry->usr2var)
Uniquify(it.second.uses);
if (main_file) {
// If there are errors, show at least one at the include position.
auto it = inc_to_line.find(entry->path);
if (it != inc_to_line.end()) {
int line = it->second;
for (auto ls_diagnostic : entry->diagnostics_) {
if (ls_diagnostic.severity != lsDiagnosticSeverity::Error)
continue;
ls_diagnostic.range =
lsRange{lsPosition{line, 10}, lsPosition{line, 10}};
main_file->diagnostics_.push_back(ls_diagnostic);
break;
}
}
}
// Update file contents and modification time.
entry->last_write_time = param.file2write_time[entry->path];

2
src/indexer.h
View File

@ -263,8 +263,6 @@ struct IndexFile {
std::unordered_map<Usr, IndexType> usr2type;
std::unordered_map<Usr, IndexVar> usr2var;
// Diagnostics found when indexing this file. Not serialized.
std::vector<lsDiagnostic> diagnostics_;
// File contents at the time of index. Not serialized.
std::string file_contents;

6
src/pipeline.cc
View File

@ -255,12 +255,6 @@ bool Indexer_Parse(DiagnosticsPublisher *diag_pub, WorkingFiles *working_files,
}
for (std::unique_ptr<IndexFile> &curr : indexes) {
// Only emit diagnostics for non-interactive sessions, which makes it easier
// to identify indexing problems. For interactive sessions, diagnostics are
// handled by code completion.
if (!request.is_interactive)
diag_pub->Publish(working_files, curr->path, curr->diagnostics_);
std::string path = curr->path;
if (!(vfs->Stamp(path, curr->last_write_time) || path == path_to_index))
continue;

3
src/project.cc
View File

@ -128,9 +128,6 @@ struct ProjectProcessor {
args.push_back("-resource-dir=" + g_config->clang.resourceDir);
args.push_back("-working-directory=" + entry.directory);
// There could be a clang version mismatch between what the project uses and
// what ccls uses. Make sure we do not emit warnings for mismatched options.
args.push_back("-Wno-unknown-warning-option");
if (!command_set.insert(hash).second) {
entry.args = std::move(args);

34
src/test.cc
View File

@ -307,42 +307,8 @@ bool RunIndexTests(const std::string &filter_path, bool enable_update) {
const std::string &expected_path = entry.first;
std::string expected_output = text_replacer.Apply(entry.second);
// FIXME: promote to utils, find and remove duplicates (ie,
// ccls_call_tree.cc, maybe something in project.cc).
auto basename = [](const std::string &path) -> std::string {
size_t last_index = path.find_last_of('/');
if (last_index == std::string::npos)
return path;
return path.substr(last_index + 1);
};
// Get output from index operation.
IndexFile *db = FindDbForPathEnding(expected_path, dbs);
if (db && !db->diagnostics_.empty()) {
printf("For %s\n", path.c_str());
for (const lsDiagnostic &diagnostic : db->diagnostics_) {
printf(" ");
if (diagnostic.severity)
switch (*diagnostic.severity) {
case lsDiagnosticSeverity::Error:
printf("error ");
break;
case lsDiagnosticSeverity::Warning:
printf("warning ");
break;
case lsDiagnosticSeverity::Information:
printf("information ");
break;
case lsDiagnosticSeverity::Hint:
printf("hint ");
break;
}
printf("%s:%s-%s:%s\n", basename(db->path).c_str(),
diagnostic.range.start.ToString().c_str(),
diagnostic.range.end.ToString().c_str(),
diagnostic.message.c_str());
}
}
std::string actual_output = "{}";
if (db) {
VerifySerializeToFrom(db);