blob: 0d6bdb75b5ac74e41fdaa268da34cd905ec2593d (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
|
//===- IncludeFixerPlugin.cpp - clang-include-fixer as a clang plugin -----===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "../IncludeFixer.h"
#include "../YamlSymbolIndex.h"
#include "clang/Frontend/CompilerInstance.h"
#include "clang/Frontend/FrontendPluginRegistry.h"
#include "clang/Parse/ParseAST.h"
#include "clang/Sema/Sema.h"
#include "llvm/Support/Path.h"
namespace clang {
namespace include_fixer {
/// The core include fixer plugin action. This just provides the AST consumer
/// and command line flag parsing for using include fixer as a clang plugin.
class ClangIncludeFixerPluginAction : public PluginASTAction {
/// ASTConsumer to keep the symbol index alive. We don't really need an
/// ASTConsumer for this plugin (everything is funneled on the side through
/// Sema) but we have to keep the symbol index alive until sema is done.
struct ASTConsumerManagerWrapper : public ASTConsumer {
ASTConsumerManagerWrapper(std::shared_ptr<SymbolIndexManager> SIM)
: SymbolIndexMgr(std::move(SIM)) {}
std::shared_ptr<SymbolIndexManager> SymbolIndexMgr;
};
public:
explicit ClangIncludeFixerPluginAction()
: SymbolIndexMgr(std::make_shared<SymbolIndexManager>()),
SemaSource(new IncludeFixerSemaSource(*SymbolIndexMgr,
/*MinimizeIncludePaths=*/true,
/*GenerateDiagnostics=*/true)) {}
std::unique_ptr<clang::ASTConsumer>
CreateASTConsumer(clang::CompilerInstance &CI, StringRef InFile) override {
CI.setExternalSemaSource(SemaSource);
SemaSource->setFilePath(InFile);
SemaSource->setCompilerInstance(&CI);
return llvm::make_unique<ASTConsumerManagerWrapper>(SymbolIndexMgr);
}
void ExecuteAction() override {} // Do nothing.
bool ParseArgs(const CompilerInstance &CI,
const std::vector<std::string> &Args) override {
StringRef DB = "yaml";
StringRef Input;
// Parse the extra command line args.
// FIXME: This is very limited at the moment.
for (StringRef Arg : Args) {
if (Arg.startswith("-db="))
DB = Arg.substr(strlen("-db="));
else if (Arg.startswith("-input="))
Input = Arg.substr(strlen("-input="));
}
std::string InputFile = CI.getFrontendOpts().Inputs[0].getFile();
auto CreateYamlIdx = [=]() -> std::unique_ptr<include_fixer::SymbolIndex> {
llvm::ErrorOr<std::unique_ptr<include_fixer::YamlSymbolIndex>> SymbolIdx(
nullptr);
if (DB == "yaml") {
if (!Input.empty()) {
SymbolIdx = include_fixer::YamlSymbolIndex::createFromFile(Input);
} else {
// If we don't have any input file, look in the directory of the first
// file and its parents.
SmallString<128> AbsolutePath(tooling::getAbsolutePath(InputFile));
StringRef Directory = llvm::sys::path::parent_path(AbsolutePath);
SymbolIdx = include_fixer::YamlSymbolIndex::createFromDirectory(
Directory, "find_all_symbols_db.yaml");
}
}
return std::move(*SymbolIdx);
};
SymbolIndexMgr->addSymbolIndex(std::move(CreateYamlIdx));
return true;
}
private:
std::shared_ptr<SymbolIndexManager> SymbolIndexMgr;
IntrusiveRefCntPtr<IncludeFixerSemaSource> SemaSource;
};
} // namespace include_fixer
} // namespace clang
// This anchor is used to force the linker to link in the generated object file
// and thus register the include fixer plugin.
volatile int ClangIncludeFixerPluginAnchorSource = 0;
static clang::FrontendPluginRegistry::Add<
clang::include_fixer::ClangIncludeFixerPluginAction>
X("clang-include-fixer", "clang-include-fixer");
|
