mirror of
https://github.com/Gericom/teak-llvm.git
synced 2025-06-23 13:35:42 -04:00
54058b5055
Summary:
There are certain cases when normal C/C++ lookup (localUncachedLookup)
does not find AST nodes. E.g.:
Example 1:
template <class T>
struct X {
friend void foo(); // this is never found in the DC of the TU.
};
Example 2:
// The fwd decl to Foo is not found in the lookupPtr of the DC of the
// translation unit decl.
struct A { struct Foo *p; };
In these cases we create a new node instead of returning with the old one.
To fix it we create a new lookup table which holds every node and we are
not interested in any C++ specific visibility considerations.
Simply, we must know if there is an existing Decl in a given DC.
Reviewers: a_sidorin, a.sidorin
Subscribers: mgorny, rnkovacs, dkrupp, Szelethus, cfe-commits
Differential Revision: https://reviews.llvm.org/D53708
llvm-svn: 349351
114 lines
4.1 KiB
C++
114 lines
4.1 KiB
C++
//===-- ASTMerge.cpp - AST Merging Frontend Action --------------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
#include "clang/Frontend/ASTUnit.h"
|
|
#include "clang/AST/ASTContext.h"
|
|
#include "clang/AST/ASTDiagnostic.h"
|
|
#include "clang/AST/ASTImporter.h"
|
|
#include "clang/AST/ASTImporterLookupTable.h"
|
|
#include "clang/Basic/Diagnostic.h"
|
|
#include "clang/Frontend/CompilerInstance.h"
|
|
#include "clang/Frontend/FrontendActions.h"
|
|
|
|
using namespace clang;
|
|
|
|
std::unique_ptr<ASTConsumer>
|
|
ASTMergeAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
|
|
return AdaptedAction->CreateASTConsumer(CI, InFile);
|
|
}
|
|
|
|
bool ASTMergeAction::BeginSourceFileAction(CompilerInstance &CI) {
|
|
// FIXME: This is a hack. We need a better way to communicate the
|
|
// AST file, compiler instance, and file name than member variables
|
|
// of FrontendAction.
|
|
AdaptedAction->setCurrentInput(getCurrentInput(), takeCurrentASTUnit());
|
|
AdaptedAction->setCompilerInstance(&CI);
|
|
return AdaptedAction->BeginSourceFileAction(CI);
|
|
}
|
|
|
|
void ASTMergeAction::ExecuteAction() {
|
|
CompilerInstance &CI = getCompilerInstance();
|
|
CI.getDiagnostics().getClient()->BeginSourceFile(
|
|
CI.getASTContext().getLangOpts());
|
|
CI.getDiagnostics().SetArgToStringFn(&FormatASTNodeDiagnosticArgument,
|
|
&CI.getASTContext());
|
|
IntrusiveRefCntPtr<DiagnosticIDs>
|
|
DiagIDs(CI.getDiagnostics().getDiagnosticIDs());
|
|
ASTImporterLookupTable LookupTable(
|
|
*CI.getASTContext().getTranslationUnitDecl());
|
|
for (unsigned I = 0, N = ASTFiles.size(); I != N; ++I) {
|
|
IntrusiveRefCntPtr<DiagnosticsEngine>
|
|
Diags(new DiagnosticsEngine(DiagIDs, &CI.getDiagnosticOpts(),
|
|
new ForwardingDiagnosticConsumer(
|
|
*CI.getDiagnostics().getClient()),
|
|
/*ShouldOwnClient=*/true));
|
|
std::unique_ptr<ASTUnit> Unit = ASTUnit::LoadFromASTFile(
|
|
ASTFiles[I], CI.getPCHContainerReader(), ASTUnit::LoadEverything, Diags,
|
|
CI.getFileSystemOpts(), false);
|
|
|
|
if (!Unit)
|
|
continue;
|
|
|
|
ASTImporter Importer(CI.getASTContext(), CI.getFileManager(),
|
|
Unit->getASTContext(), Unit->getFileManager(),
|
|
/*MinimalImport=*/false, &LookupTable);
|
|
|
|
TranslationUnitDecl *TU = Unit->getASTContext().getTranslationUnitDecl();
|
|
for (auto *D : TU->decls()) {
|
|
// Don't re-import __va_list_tag, __builtin_va_list.
|
|
if (const auto *ND = dyn_cast<NamedDecl>(D))
|
|
if (IdentifierInfo *II = ND->getIdentifier())
|
|
if (II->isStr("__va_list_tag") || II->isStr("__builtin_va_list"))
|
|
continue;
|
|
|
|
Decl *ToD = Importer.Import(D);
|
|
|
|
if (ToD) {
|
|
DeclGroupRef DGR(ToD);
|
|
CI.getASTConsumer().HandleTopLevelDecl(DGR);
|
|
}
|
|
}
|
|
}
|
|
|
|
AdaptedAction->ExecuteAction();
|
|
CI.getDiagnostics().getClient()->EndSourceFile();
|
|
}
|
|
|
|
void ASTMergeAction::EndSourceFileAction() {
|
|
return AdaptedAction->EndSourceFileAction();
|
|
}
|
|
|
|
ASTMergeAction::ASTMergeAction(std::unique_ptr<FrontendAction> adaptedAction,
|
|
ArrayRef<std::string> ASTFiles)
|
|
: AdaptedAction(std::move(adaptedAction)), ASTFiles(ASTFiles.begin(), ASTFiles.end()) {
|
|
assert(AdaptedAction && "ASTMergeAction needs an action to adapt");
|
|
}
|
|
|
|
ASTMergeAction::~ASTMergeAction() {
|
|
}
|
|
|
|
bool ASTMergeAction::usesPreprocessorOnly() const {
|
|
return AdaptedAction->usesPreprocessorOnly();
|
|
}
|
|
|
|
TranslationUnitKind ASTMergeAction::getTranslationUnitKind() {
|
|
return AdaptedAction->getTranslationUnitKind();
|
|
}
|
|
|
|
bool ASTMergeAction::hasPCHSupport() const {
|
|
return AdaptedAction->hasPCHSupport();
|
|
}
|
|
|
|
bool ASTMergeAction::hasASTFileSupport() const {
|
|
return AdaptedAction->hasASTFileSupport();
|
|
}
|
|
|
|
bool ASTMergeAction::hasCodeCompletionSupport() const {
|
|
return AdaptedAction->hasCodeCompletionSupport();
|
|
}
|