void EmptyStructToInt::HandleTranslationUnit(ASTContext &Ctx)
{
CollectionVisitor->TraverseDecl(Ctx.getTranslationUnitDecl());
doAnalysis();
if (QueryInstanceOnly)
return;
if (TransformationCounter > ValidInstanceNum) {
TransError = TransMaxInstanceError;
return;
}
Ctx.getDiagnostics().setSuppressAllDiagnostics(false);
removeRecordDecls();
RewriteVisitor->TraverseDecl(Ctx.getTranslationUnitDecl());
// sanity check that we actually
// have done some text modifications.
// It could be false due to invalid code being transformed.
if (!Rewritten) {
TransError = TransNoTextModificationError;
return;
}
if (Ctx.getDiagnostics().hasErrorOccurred() ||
Ctx.getDiagnostics().hasFatalErrorOccurred())
TransError = TransInternalError;
}
void KeyPathValidationConsumer::HandleTranslationUnit(ASTContext &Context) {
cacheNSTypes();
ValueForKeyVisitor(this, Compiler).TraverseDecl(Context.getTranslationUnitDecl());
KeyPathsAffectingVisitor(this, Compiler).TraverseDecl(Context.getTranslationUnitDecl());
FBBinderVisitor(this, Compiler).TraverseDecl(Context.getTranslationUnitDecl());
}
void ReduceClassTemplateParameter::HandleTranslationUnit(ASTContext &Ctx)
{
if (TransformationManager::isCLangOpt() ||
TransformationManager::isOpenCLLangOpt()) {
ValidInstanceNum = 0;
}
else {
CollectionVisitor->TraverseDecl(Ctx.getTranslationUnitDecl());
}
if (QueryInstanceOnly)
return;
if (TransformationCounter > ValidInstanceNum) {
TransError = TransMaxInstanceError;
return;
}
TransAssert(TheClassTemplateDecl && "NULL TheClassTemplateDecl!");
TransAssert(ArgRewriteVisitor && "NULL ArgRewriteVisitor!");
Ctx.getDiagnostics().setSuppressAllDiagnostics(false);
removeParameterFromDecl();
removeParameterFromMethods();
removeParameterFromPartialSpecs();
ArgRewriteVisitor->TraverseDecl(Ctx.getTranslationUnitDecl());
if (Ctx.getDiagnostics().hasErrorOccurred() ||
Ctx.getDiagnostics().hasFatalErrorOccurred())
TransError = TransInternalError;
}
void TemplateNonTypeArgToInt::HandleTranslationUnit(ASTContext &Ctx)
{
if (TransformationManager::isCLangOpt() ||
TransformationManager::isOpenCLLangOpt()) {
ValidInstanceNum = 0;
}
else {
ArgCollector->TraverseDecl(Ctx.getTranslationUnitDecl());
CollectionVisitor->TraverseDecl(Ctx.getTranslationUnitDecl());
}
if (QueryInstanceOnly)
return;
if (TransformationCounter > ValidInstanceNum) {
TransError = TransMaxInstanceError;
return;
}
Ctx.getDiagnostics().setSuppressAllDiagnostics(false);
if (TheExpr) {
RewriteHelper->replaceExpr(TheExpr, IntString);
}
else if (TheValueDecl) {
RewriteHelper->replaceValueDecl(TheValueDecl,
"int " + TheValueDecl->getNameAsString());
}
else {
TransAssert(0 && "No valid targets!");
}
if (Ctx.getDiagnostics().hasErrorOccurred() ||
Ctx.getDiagnostics().hasFatalErrorOccurred())
TransError = TransInternalError;
}
void LocalToGlobal::HandleTranslationUnit(ASTContext &Ctx)
{
if (TransformationManager::isOpenCLLangOpt()) {
ValidInstanceNum = 0;
}
else {
FunctionVisitor->TraverseDecl(Ctx.getTranslationUnitDecl());
}
if (QueryInstanceOnly)
return;
if (TransformationCounter > ValidInstanceNum) {
TransError = TransMaxInstanceError;
return;
}
TransAssert(TransformationASTVisitor && "NULL TransformationASTVisitor!");
Ctx.getDiagnostics().setSuppressAllDiagnostics(false);
TransAssert(TheFuncDecl && "NULL TheFuncDecl!");
TransAssert(TheVarDecl && "NULL TheVarDecl!");
TransformationASTVisitor->TraverseDecl(Ctx.getTranslationUnitDecl());
if (Ctx.getDiagnostics().hasErrorOccurred() ||
Ctx.getDiagnostics().hasFatalErrorOccurred())
TransError = TransInternalError;
}
void InstantiateTemplateParam::HandleTranslationUnit(ASTContext &Ctx)
{
if (TransformationManager::isCLangOpt() ||
TransformationManager::isOpenCLLangOpt()) {
ValidInstanceNum = 0;
}
else {
CollectionVisitor->TraverseDecl(Ctx.getTranslationUnitDecl());
}
if (QueryInstanceOnly)
return;
if (TransformationCounter > ValidInstanceNum) {
TransError = TransMaxInstanceError;
return;
}
Ctx.getDiagnostics().setSuppressAllDiagnostics(false);
TransAssert(TheParameter && "NULL TheParameter!");
TransAssert((TheInstantiationString != "") && "Invalid InstantiationString!");
TransAssert(ParamRewriteVisitor && "NULL ParamRewriteVisitor!");
ParamRewriteVisitor->TraverseDecl(Ctx.getTranslationUnitDecl());
removeTemplateKeyword();
addForwardDecl();
if (Ctx.getDiagnostics().hasErrorOccurred() ||
Ctx.getDiagnostics().hasFatalErrorOccurred())
TransError = TransInternalError;
}
void RemoveUnusedFunction::HandleTranslationUnit(ASTContext &Ctx)
{
VisitorWrapper->TraverseDecl(Ctx.getTranslationUnitDecl());
// visit using decls declared outsided function-scope
UsingDeclVisitor Visitor(NULL, this);
Visitor.TraverseDecl(Ctx.getTranslationUnitDecl());
SpecializationVisitor SpecVisitor(this);
SpecVisitor.TraverseDecl(Ctx.getTranslationUnitDecl());
AnalysisVisitor->TraverseDecl(Ctx.getTranslationUnitDecl());
if (QueryInstanceOnly)
return;
if (TransformationCounter > ValidInstanceNum) {
TransError = TransMaxInstanceError;
return;
}
if (ToCounter > ValidInstanceNum) {
TransError = TransToCounterTooBigError;
return;
}
Ctx.getDiagnostics().setSuppressAllDiagnostics(false);
doRewriting();
if (Ctx.getDiagnostics().hasErrorOccurred() ||
Ctx.getDiagnostics().hasFatalErrorOccurred())
TransError = TransInternalError;
}
void ReducePointerLevel::HandleTranslationUnit(ASTContext &Ctx)
{
CollectionVisitor->TraverseDecl(Ctx.getTranslationUnitDecl());
doAnalysis();
if (QueryInstanceOnly)
return;
if (TransformationCounter > ValidInstanceNum) {
TransError = TransMaxInstanceError;
return;
}
TransAssert(CollectionVisitor && "NULL CollectionVisitor!");
TransAssert(RewriteVisitor && "NULL CollectionVisitor!");
Ctx.getDiagnostics().setSuppressAllDiagnostics(false);
TransAssert(TheDecl && "NULL TheDecl!");
setRecordDecl();
RewriteVisitor->TraverseDecl(Ctx.getTranslationUnitDecl());
if (Ctx.getDiagnostics().hasErrorOccurred() ||
Ctx.getDiagnostics().hasFatalErrorOccurred())
TransError = TransInternalError;
}
void RemoveBaseClass::HandleTranslationUnit(ASTContext &Ctx)
{
if (TransformationManager::isCLangOpt() ||
TransformationManager::isOpenCLLangOpt()) {
ValidInstanceNum = 0;
}
else {
CollectionVisitor->TraverseDecl(Ctx.getTranslationUnitDecl());
}
if (QueryInstanceOnly)
return;
if (TransformationCounter > ValidInstanceNum) {
TransError = TransMaxInstanceError;
return;
}
TransAssert(TheBaseClass && "TheBaseClass is NULL!");
TransAssert(TheDerivedClass && "TheDerivedClass is NULL!");
Ctx.getDiagnostics().setSuppressAllDiagnostics(false);
RewriteVisitor =
new RemoveBaseClassRewriteVisitor(&TheRewriter, RewriteHelper,
TheBaseClass->getCanonicalDecl(),
TheDerivedClass->getNameAsString());
TransAssert(RewriteVisitor && "NULL RewriteVisitor!");
RewriteVisitor->TraverseDecl(Ctx.getTranslationUnitDecl());
doRewrite();
if (Ctx.getDiagnostics().hasErrorOccurred() ||
Ctx.getDiagnostics().hasFatalErrorOccurred())
TransError = TransInternalError;
}
void ReplaceSimpleTypedef::HandleTranslationUnit(ASTContext &Ctx)
{
CollectionVisitor->TraverseDecl(Ctx.getTranslationUnitDecl());
if (QueryInstanceOnly)
return;
if (TransformationCounter > ValidInstanceNum) {
TransError = TransMaxInstanceError;
return;
}
Ctx.getDiagnostics().setSuppressAllDiagnostics(false);
TransAssert(TheTypedefDecl && "NULL TheTypedefDecl!");
RewriteVisitor->TraverseDecl(Ctx.getTranslationUnitDecl());
removeTypedefs();
if (!Rewritten) {
TransError = TransNoTextModificationError;
return;
}
if (Ctx.getDiagnostics().hasErrorOccurred() ||
Ctx.getDiagnostics().hasFatalErrorOccurred())
TransError = TransInternalError;
}
void TemplateArgToInt::HandleTranslationUnit(ASTContext &Ctx)
{
const LangOptions &LO = Ctx.getLangOpts();
if (LO.C99 || LO.OpenCL) {
ValidInstanceNum = 0;
}
else {
CollectionVisitor->TraverseDecl(Ctx.getTranslationUnitDecl());
GlobalParamFilter->TraverseDecl(Ctx.getTranslationUnitDecl());
ArgCollector->TraverseDecl(Ctx.getTranslationUnitDecl());
}
if (QueryInstanceOnly)
return;
if (TransformationCounter > ValidInstanceNum) {
TransError = TransMaxInstanceError;
return;
}
Ctx.getDiagnostics().setSuppressAllDiagnostics(false);
rewriteTemplateArgument();
if (Ctx.getDiagnostics().hasErrorOccurred() ||
Ctx.getDiagnostics().hasFatalErrorOccurred())
TransError = TransInternalError;
}
void ReplaceClassWithBaseTemplateSpec::HandleTranslationUnit(ASTContext &Ctx)
{
if (TransformationManager::isCLangOpt() ||
TransformationManager::isOpenCLLangOpt()) {
ValidInstanceNum = 0;
}
else {
CollectionVisitor->TraverseDecl(Ctx.getTranslationUnitDecl());
}
if (QueryInstanceOnly)
return;
if (TransformationCounter > ValidInstanceNum) {
TransError = TransMaxInstanceError;
return;
}
TransAssert(TheCXXRecord && "TheCXXRecord is NULL!");
Ctx.getDiagnostics().setSuppressAllDiagnostics(false);
TransAssert(RewriteVisitor && "NULL RewriteVisitor!");
RewriteVisitor->TraverseDecl(Ctx.getTranslationUnitDecl());
removeBaseSpecifier();
if (Ctx.getDiagnostics().hasErrorOccurred() ||
Ctx.getDiagnostics().hasFatalErrorOccurred())
TransError = TransInternalError;
}
void CallExprToValue::HandleTranslationUnit(ASTContext &Ctx)
{
CollectionVisitor->TraverseDecl(Ctx.getTranslationUnitDecl());
if (QueryInstanceOnly)
return;
if (TransformationCounter > ValidInstanceNum) {
TransError = TransMaxInstanceError;
return;
}
TransAssert(TheCallExpr && "NULL TheCallExpr!");
TransAssert(CurrentFD && "NULL CurrentFD");
Ctx.getDiagnostics().setSuppressAllDiagnostics(false);
NameQueryWrap->TraverseDecl(Ctx.getTranslationUnitDecl());
NamePostfix = NameQueryWrap->getMaxNamePostfix() + 1;
replaceCallExpr();
if (Ctx.getDiagnostics().hasErrorOccurred() ||
Ctx.getDiagnostics().hasFatalErrorOccurred())
TransError = TransInternalError;
}
virtual void HandleTranslationUnit(ASTContext& context) {
// Resolve all string class names to clang NamedDecls.
m_resolveVisitor.TraverseDecl(context.getTranslationUnitDecl());
// Visit all declarations.
m_generator.preVisit();
m_generator.TraverseDecl(context.getTranslationUnitDecl());
m_generator.emitScanMethods();
}
void BlinkGCPluginConsumer::HandleTranslationUnit(ASTContext& context) {
// Don't run the plugin if the compilation unit is already invalid.
if (diagnostic_.hasErrorOccurred())
return;
ParseFunctionTemplates(context.getTranslationUnitDecl());
CollectVisitor visitor;
visitor.TraverseDecl(context.getTranslationUnitDecl());
if (options_.dump_graph) {
std::error_code err;
// TODO: Make createDefaultOutputFile or a shorter createOutputFile work.
json_ = JsonWriter::from(instance_.createOutputFile(
"", // OutputPath
err, // Errors
true, // Binary
true, // RemoveFileOnSignal
instance_.getFrontendOpts().OutputFile, // BaseInput
"graph.json", // Extension
false, // UseTemporary
false, // CreateMissingDirectories
0, // ResultPathName
0)); // TempPathName
if (!err && json_) {
json_->OpenList();
} else {
json_ = 0;
llvm::errs()
<< "[blink-gc] "
<< "Failed to create an output file for the object graph.\n";
}
}
for (CollectVisitor::RecordVector::iterator it =
visitor.record_decls().begin();
it != visitor.record_decls().end();
++it) {
CheckRecord(cache_.Lookup(*it));
}
for (CollectVisitor::MethodVector::iterator it =
visitor.trace_decls().begin();
it != visitor.trace_decls().end();
++it) {
CheckTracingMethod(*it);
}
if (json_) {
json_->CloseList();
delete json_;
json_ = 0;
}
}
// This gets called only when the full TU is completely parsed.
void HandleTranslationUnit(ASTContext &Context) {
llvm::errs() << "********* The whole TU *************\n";
Context.getTranslationUnitDecl()->dump();
llvm::errs() << "****** going over the decls stored in it:\n";
for (auto *D : Context.getTranslationUnitDecl()->decls()) {
llvm::errs() << "Decl in the TU:\n";
D->dump();
llvm::errs() << "Its start location is: '"
<< D->getLocStart().printToString(Context.getSourceManager())
<< "'\n";
}
}
void RemoveUnusedOuterClass::HandleTranslationUnit(ASTContext &Ctx)
{
const LangOptions &LO = Ctx.getLangOpts();
if (LO.C99 || LO.OpenCL) {
ValidInstanceNum = 0;
}
else {
CollectionVisitor->TraverseDecl(Ctx.getTranslationUnitDecl());
analyzeCXXRDSet();
}
if (QueryInstanceOnly)
return;
if (TransformationCounter > ValidInstanceNum) {
TransError = TransMaxInstanceError;
return;
}
Ctx.getDiagnostics().setSuppressAllDiagnostics(false);
removeOuterClass();
if (Ctx.getDiagnostics().hasErrorOccurred() ||
Ctx.getDiagnostics().hasFatalErrorOccurred())
TransError = TransInternalError;
}
void CallGraph::addTU(ASTContext& Ctx) {
DeclContext *DC = Ctx.getTranslationUnitDecl();
for (DeclContext::decl_iterator I = DC->decls_begin(), E = DC->decls_end();
I != E; ++I) {
if (FunctionDecl *FD = dyn_cast<FunctionDecl>(*I)) {
if (FD->doesThisDeclarationHaveABody()) {
// Set caller's ASTContext.
Entity Ent = Entity::get(FD, Prog);
CallGraphNode *Node = getOrInsertFunction(Ent);
CallerCtx[Node] = &Ctx;
// If this function has external linkage, anything could call it.
if (FD->isGlobal())
ExternalCallingNode->addCallee(idx::ASTLocation(), Node);
// Set root node to 'main' function.
if (FD->getNameAsString() == "main")
Root = Node;
CGBuilder builder(*this, FD, Ent, Node);
builder.Visit(FD->getBody());
}
}
}
}
void RemoveDecl::HandleTranslationUnit(ASTContext &Ctx)
{
auto CollectionVisitor = RemoveDeclVisitor(this);
CollectionVisitor.TraverseDecl(Ctx.getTranslationUnitDecl());
if (QueryInstanceOnly)
return;
if (TransformationCounter > ValidInstanceNum) {
TransError = TransMaxInstanceError;
return;
}
Ctx.getDiagnostics().setSuppressAllDiagnostics(false);
TransAssert(Decls.size() && "NULL TheDecl!");
Decl* D = nullptr;
if (ToCounter < TransformationCounter) {
D = Decls[TransformationCounter-1];
RewriteHelper->removeDecl(D);
//std::string s;
//auto R = D->getSourceRange();
//RewriteHelper->getStringBetweenLocs(s, R.getBegin(), R.getEnd());
}
else {
for (int i = ToCounter; i >= TransformationCounter; --i) {
D = Decls[i];
RewriteHelper->removeDecl(D);
}
}
if (Ctx.getDiagnostics().hasErrorOccurred() ||
Ctx.getDiagnostics().hasFatalErrorOccurred())
TransError = TransInternalError;
}
void RemoveCtorInitializer::HandleTranslationUnit(ASTContext &Ctx)
{
if (TransformationManager::isCLangOpt() ||
TransformationManager::isOpenCLLangOpt()) {
ValidInstanceNum = 0;
}
else {
CollectionVisitor->TraverseDecl(Ctx.getTranslationUnitDecl());
}
if (QueryInstanceOnly)
return;
if (TransformationCounter > ValidInstanceNum) {
TransError = TransMaxInstanceError;
return;
}
TransAssert(TheCtorDecl && "TheCtorDecl is NULL!");
TransAssert(TheInitializer && "TheInitializer is NULL!");
Ctx.getDiagnostics().setSuppressAllDiagnostics(false);
RewriteHelper->removeCXXCtorInitializer(TheInitializer, TheIndex,
getNumCtorWrittenInitializers(*TheCtorDecl));
if (Ctx.getDiagnostics().hasErrorOccurred() ||
Ctx.getDiagnostics().hasFatalErrorOccurred())
TransError = TransInternalError;
}
void HandleTranslationUnit(ASTContext &Context) override {
const auto &SourceMgr = Context.getSourceManager();
std::vector<SourceLocation> RenamingCandidates;
std::vector<SourceLocation> NewCandidates;
for (const auto &USR : USRs) {
NewCandidates = getLocationsOfUSR(USR, Context.getTranslationUnitDecl());
RenamingCandidates.insert(RenamingCandidates.end(), NewCandidates.begin(),
NewCandidates.end());
NewCandidates.clear();
}
auto PrevNameLen = PrevName.length();
if (PrintLocations)
for (const auto &Loc : RenamingCandidates) {
FullSourceLoc FullLoc(Loc, SourceMgr);
errs() << "clang-rename: renamed at: " << SourceMgr.getFilename(Loc)
<< ":" << FullLoc.getSpellingLineNumber() << ":"
<< FullLoc.getSpellingColumnNumber() << "\n";
Replaces.insert(tooling::Replacement(SourceMgr, Loc, PrevNameLen,
NewName));
}
else
for (const auto &Loc : RenamingCandidates)
Replaces.insert(tooling::Replacement(SourceMgr, Loc, PrevNameLen,
NewName));
}
bool SerializationTest::Serialize(llvm::sys::Path& Filename,
llvm::sys::Path& FNameDeclPrint,
ASTContext &Ctx) {
{
// Pretty-print the decls to a temp file.
std::string Err;
llvm::raw_fd_ostream DeclPP(FNameDeclPrint.c_str(), true, Err);
assert (Err.empty() && "Could not open file for printing out decls.");
llvm::OwningPtr<ASTConsumer> FilePrinter(CreateASTPrinter(&DeclPP));
TranslationUnitDecl *TUD = Ctx.getTranslationUnitDecl();
for (DeclContext::decl_iterator I = TUD->decls_begin(Ctx),
E = TUD->decls_end(Ctx);
I != E; ++I)
FilePrinter->HandleTopLevelDecl(DeclGroupRef(*I));
}
// Serialize the translation unit.
// Reserve 256K for bitstream buffer.
std::vector<unsigned char> Buffer;
Buffer.reserve(256*1024);
Ctx.EmitASTBitcodeBuffer(Buffer);
// Write the bits to disk.
if (FILE* fp = fopen(Filename.c_str(),"wb")) {
fwrite((char*)&Buffer.front(), sizeof(char), Buffer.size(), fp);
fclose(fp);
return true;
}
return false;
}
void BinOpSimplification::HandleTranslationUnit(ASTContext &Ctx)
{
if (QueryInstanceOnly)
return;
if (TransformationCounter > ValidInstanceNum) {
TransError = TransMaxInstanceError;
return;
}
Ctx.getDiagnostics().setSuppressAllDiagnostics(false);
TransAssert(TheFuncDecl && "NULL TheFuncDecl!");
TransAssert(TheStmt && "NULL TheStmt!");
TransAssert(TheBinOp && "NULL TheBinOp");
NameQueryWrap->TraverseDecl(Ctx.getTranslationUnitDecl());
addNewTmpVariable();
addNewAssignStmt();
replaceBinOp();
if (Ctx.getDiagnostics().hasErrorOccurred() ||
Ctx.getDiagnostics().hasFatalErrorOccurred())
TransError = TransInternalError;
}
void RemoveUnresolvedBase::HandleTranslationUnit(ASTContext &Ctx)
{
if (TransformationManager::isCLangOpt()) {
ValidInstanceNum = 0;
}
else {
CollectionVisitor->TraverseDecl(Ctx.getTranslationUnitDecl());
}
if (QueryInstanceOnly)
return;
if (TransformationCounter > ValidInstanceNum) {
TransError = TransMaxInstanceError;
return;
}
TransAssert(TheDerivedClass && "NULL TheDerivedClass!");
TransAssert(TheBaseSpecifier && "NULL TheBaseSpecifier!");
Ctx.getDiagnostics().setSuppressAllDiagnostics(false);
removeBaseSpecifier();
if (Ctx.getDiagnostics().hasErrorOccurred() ||
Ctx.getDiagnostics().hasFatalErrorOccurred())
TransError = TransInternalError;
}
void ReplaceDependentName::HandleTranslationUnit(ASTContext &Ctx)
{
if (TransformationManager::isCLangOpt() ||
TransformationManager::isOpenCLLangOpt()) {
ValidInstanceNum = 0;
}
else {
CollectionVisitor->TraverseDecl(Ctx.getTranslationUnitDecl());
}
if (QueryInstanceOnly)
return;
if (TransformationCounter > ValidInstanceNum) {
TransError = TransMaxInstanceError;
return;
}
Ctx.getDiagnostics().setSuppressAllDiagnostics(false);
rewriteDependentName();
if (Ctx.getDiagnostics().hasErrorOccurred() ||
Ctx.getDiagnostics().hasFatalErrorOccurred())
TransError = TransInternalError;
}
void HandleOneRename(ASTContext &Context, const std::string &NewName,
const std::string &PrevName,
const std::vector<std::string> &USRs) {
const SourceManager &SourceMgr = Context.getSourceManager();
SymbolOccurrences Occurrences = tooling::getOccurrencesOfUSRs(
USRs, PrevName, Context.getTranslationUnitDecl());
if (PrintLocations) {
for (const auto &Occurrence : Occurrences) {
FullSourceLoc FullLoc(Occurrence.getNameRanges()[0].getBegin(),
SourceMgr);
errs() << "clang-rename: renamed at: " << SourceMgr.getFilename(FullLoc)
<< ":" << FullLoc.getSpellingLineNumber() << ":"
<< FullLoc.getSpellingColumnNumber() << "\n";
}
}
// FIXME: Support multi-piece names.
// FIXME: better error handling (propagate error out).
StringRef NewNameRef = NewName;
Expected<std::vector<AtomicChange>> Change =
createRenameReplacements(Occurrences, SourceMgr, NewNameRef);
if (!Change) {
llvm::errs() << "Failed to create renaming replacements for '" << PrevName
<< "'! " << llvm::toString(Change.takeError()) << "\n";
return;
}
convertChangesToFileReplacements(*Change, &FileToReplaces);
}
void TeslaConsumer::HandleTranslationUnit(ASTContext &Context) {
TeslaVisitor Visitor(InFile, &Context);
if (!Visitor.TraverseDecl(Context.getTranslationUnitDecl()))
panic("error analysing '" + InFile + "'");
string ErrorInfo;
llvm::raw_fd_ostream Out(OutFile.str().c_str(), ErrorInfo);
if (Out.has_error())
panic("unable to open '" + OutFile + "': " + ErrorInfo);
ManifestFile Result;
for (const AutomatonDescription *A : Visitor.GetAutomata())
*Result.add_automaton() = *A;
for (const Usage *U : Visitor.RootAutomata())
*Result.add_root() = *U;
string ProtobufText;
if (UseTextFormat)
google::protobuf::TextFormat::PrintToString(Result, &ProtobufText);
else
Result.SerializeToString(&ProtobufText);
Out << ProtobufText;
}
void RecyclerCheckerConsumer::HandleTranslationUnit(ASTContext& context)
{
MainVisitor mainVisitor(_compilerInstance, context, _fix);
mainVisitor.TraverseDecl(context.getTranslationUnitDecl());
mainVisitor.Inspect();
mainVisitor.ApplyFix();
}
void HandleTranslationUnit(ASTContext &Context) override {
for (unsigned I = 0; I < NewNames.size(); ++I) {
// FIXME: Apply AtomicChanges directly once the refactoring APIs are
// ready.
auto AtomicChanges = tooling::createRenameAtomicChanges(
USRList[I], NewNames[I], Context.getTranslationUnitDecl());
convertChangesToFileReplacements(AtomicChanges, &FileToReplaces);
}
}
// this method is called to analyze the entire AST
void HandleTranslationUnit(ASTContext &Ctx) {
// the visitor functions will be invoked by this
//llvm::errs() << "handling translation unit\n";
TraverseDecl(Ctx.getTranslationUnitDecl());
//llvm::errs() << "DONE VISITING\n";
OutputAnnotation();
//llvm::errs() << "DONE ANNOTATING\n";
}
