[lldb][NFC] Add unit test for persistent variable lookup with ClangExpressionDeclMap
This adds a unit test for looking up persistent declarations in the scratch AST
context. Also adds the `GetPersistentDecl` hook to the ClangExpressionDeclMap
that this unit test can emulate looking up persistent variables without having
a lldb_private::Target.
diff --git a/lldb/unittests/Expression/ClangExpressionDeclMapTest.cpp b/lldb/unittests/Expression/ClangExpressionDeclMapTest.cpp
index 2d93a61..6fac1684 100644
--- a/lldb/unittests/Expression/ClangExpressionDeclMapTest.cpp
+++ b/lldb/unittests/Expression/ClangExpressionDeclMapTest.cpp
@@ -11,12 +11,51 @@
#include "lldb/Host/FileSystem.h"
#include "lldb/Host/HostInfo.h"
#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/ClangUtil.h"
#include "lldb/lldb-defines.h"
#include "gtest/gtest.h"
using namespace lldb_private;
using namespace lldb;
+static std::unique_ptr<ClangASTContext> createAST() {
+ return std::make_unique<ClangASTContext>(HostInfo::GetTargetTriple());
+}
+
+namespace {
+struct FakeClangExpressionDeclMap : public ClangExpressionDeclMap {
+ FakeClangExpressionDeclMap(const ClangASTImporterSP &importer)
+ : ClangExpressionDeclMap(false, nullptr, lldb::TargetSP(), importer,
+ nullptr) {
+ m_scratch_context = createAST();
+ }
+ std::unique_ptr<ClangASTContext> m_scratch_context;
+ /// Adds a persistent decl that can be found by the ClangExpressionDeclMap
+ /// via GetPersistentDecl.
+ void AddPersistentDeclForTest(clang::NamedDecl *d) {
+ // The declaration needs to have '$' prefix in its name like every
+ // persistent declaration and must be inside the scratch AST context.
+ assert(d);
+ assert(d->getName().startswith("$"));
+ assert(&d->getASTContext() == m_scratch_context->getASTContext());
+ m_persistent_decls[d->getName()] = d;
+ }
+
+protected:
+ // ClangExpressionDeclMap hooks.
+
+ clang::NamedDecl *GetPersistentDecl(ConstString name) override {
+ // ClangExpressionDeclMap wants to know if there is a persistent decl
+ // with the given name. Check the
+ return m_persistent_decls.lookup(name.GetStringRef());
+ }
+
+private:
+ /// The persistent decls in this test with their names as keys.
+ llvm::DenseMap<llvm::StringRef, clang::NamedDecl *> m_persistent_decls;
+};
+} // namespace
+
namespace {
struct ClangExpressionDeclMapTest : public testing::Test {
static void SetUpTestCase() {
@@ -28,8 +67,25 @@
FileSystem::Terminate();
}
- std::unique_ptr<ClangASTContext> createAST() {
- return std::make_unique<ClangASTContext>(HostInfo::GetTargetTriple());
+ /// The ClangASTImporter used during the test.
+ ClangASTImporterSP importer;
+ /// The ExpressionDeclMap for the current test case.
+ std::unique_ptr<FakeClangExpressionDeclMap> decl_map;
+
+ /// The target AST that lookup results should be imported to.
+ std::unique_ptr<ClangASTContext> target_ast;
+
+ void SetUp() override {
+ importer = std::make_shared<ClangASTImporter>();
+ decl_map = std::make_unique<FakeClangExpressionDeclMap>(importer);
+ target_ast = createAST();
+ decl_map->InstallASTContext(*target_ast, *target_ast->getFileManager());
+ }
+
+ void TearDown() override {
+ importer.reset();
+ decl_map.reset();
+ target_ast.reset();
}
clang::DeclarationName getDeclarationName(ClangASTContext &ast,
@@ -37,23 +93,54 @@
clang::IdentifierInfo &II = ast.getIdentifierTable()->get(name);
return ast.getASTContext()->DeclarationNames.getIdentifier(&II);
}
+
+ CompilerType createRecord(ClangASTContext &ast, llvm::StringRef name) {
+ CompilerType t = ast.CreateRecordType(ast.getASTContext()->getTranslationUnitDecl(),
+ lldb::AccessType::eAccessPublic, name, 0,
+ lldb::LanguageType::eLanguageTypeC);
+ ClangASTContext::StartTagDeclarationDefinition(t);
+ ClangASTContext::CompleteTagDeclarationDefinition(t);
+ return t;
+ }
};
} // namespace
-TEST_F(ClangExpressionDeclMapTest, TestIdentifierLookupInEmptyTU) {
- ClangASTImporterSP importer = std::make_shared<ClangASTImporter>();
- ClangExpressionDeclMap map(false, nullptr, lldb::TargetSP(), importer,
- nullptr);
+TEST_F(ClangExpressionDeclMapTest, TestUnknownIdentifierLookup) {
+ // Tests looking up an identifier that can't be found anywhere.
- std::unique_ptr<ClangASTContext> ast = createAST();
- map.InstallASTContext(*ast, *ast->getFileManager());
-
+ // Setup a NameSearchContext for 'foo'.
llvm::SmallVector<clang::NamedDecl *, 16> decls;
- clang::DeclarationName name = getDeclarationName(*ast, "does_no_exist");
- const clang::DeclContext *dc = ast->GetTranslationUnitDecl();
+ clang::DeclarationName name = getDeclarationName(*target_ast, "foo");
+ const clang::DeclContext *dc = target_ast->GetTranslationUnitDecl();
+ NameSearchContext search(*decl_map, decls, name, dc);
- NameSearchContext search(map, decls, name, dc);
- map.FindExternalVisibleDecls(search);
+ decl_map->FindExternalVisibleDecls(search);
+ // This shouldn't exist so we should get no lookups.
EXPECT_EQ(0U, decls.size());
}
+
+TEST_F(ClangExpressionDeclMapTest, TestPersistentDeclLookup) {
+ // Tests looking up a persistent decl from the scratch AST context.
+
+ // Create a '$persistent_class' record and add it as a persistent variable
+ // to the scratch AST context.
+ llvm::StringRef decl_name = "$persistent_class";
+ CompilerType persistent_type =
+ createRecord(*decl_map->m_scratch_context, decl_name);
+ decl_map->AddPersistentDeclForTest(ClangUtil::GetAsTagDecl(persistent_type));
+
+ // Setup a NameSearchContext for $persistent_class;
+ llvm::SmallVector<clang::NamedDecl *, 16> decls;
+ clang::DeclarationName name = getDeclarationName(*target_ast, decl_name);
+ const clang::DeclContext *dc = target_ast->GetTranslationUnitDecl();
+ NameSearchContext search(*decl_map, decls, name, dc);
+
+ // Search and check that we found $persistent_class.
+ decl_map->FindExternalVisibleDecls(search);
+ EXPECT_EQ(1U, decls.size());
+ EXPECT_EQ(decl_name, decls.front()->getQualifiedNameAsString());
+ auto *record = llvm::cast<clang::RecordDecl>(decls.front());
+ // The class was minimally imported from the scratch AST context.
+ EXPECT_TRUE(record->hasExternalLexicalStorage());
+}