lldb/unittests/Expression/ClangExpressionDeclMapTest.cpp

   1 //===-- ClangExpressionDeclMapTest.cpp ------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.h"
  10 #include "Plugins/ExpressionParser/Clang/ClangUtil.h"
  11 #include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
  12 #include "TestingSupport/SubsystemRAII.h"
  13 #include "TestingSupport/Symbol/ClangTestUtils.h"
  14 #include "lldb/Host/FileSystem.h"
  15 #include "lldb/Host/HostInfo.h"
  16 #include "lldb/lldb-defines.h"
  17 #include "gtest/gtest.h"
  18
  19 using namespace lldb_private;
  20 using namespace lldb;
  21
  22 namespace {
  23 struct FakeClangExpressionDeclMap : public ClangExpressionDeclMap {
  24   FakeClangExpressionDeclMap(const std::shared_ptr<ClangASTImporter> &importer)
  25       : ClangExpressionDeclMap(false, nullptr, lldb::TargetSP(), importer,
  26                                nullptr) {
  27     m_scratch_context = clang_utils::createAST();
  28   }
  29   std::unique_ptr<TypeSystemClang> m_scratch_context;
  30   /// Adds a persistent decl that can be found by the ClangExpressionDeclMap
  31   /// via GetPersistentDecl.
  32   void AddPersistentDeclForTest(clang::NamedDecl *d) {
  33     // The declaration needs to have '$' prefix in its name like every
  34     // persistent declaration and must be inside the scratch AST context.
  35     assert(d);
  36     assert(d->getName().startswith("$"));
  37     assert(&d->getASTContext() == &m_scratch_context->getASTContext());
  38     m_persistent_decls[d->getName()] = d;
  39   }
  40
  41 protected:
  42   // ClangExpressionDeclMap hooks.
  43
  44   clang::NamedDecl *GetPersistentDecl(ConstString name) override {
  45     // ClangExpressionDeclMap wants to know if there is a persistent decl
  46     // with the given name. Check the
  47     return m_persistent_decls.lookup(name.GetStringRef());
  48   }
  49
  50 private:
  51   /// The persistent decls in this test with their names as keys.
  52   llvm::DenseMap<llvm::StringRef, clang::NamedDecl *> m_persistent_decls;
  53 };
  54 } // namespace
  55
  56 namespace {
  57 struct ClangExpressionDeclMapTest : public testing::Test {
  58   SubsystemRAII<FileSystem, HostInfo> subsystems;
  59
  60   /// The ClangASTImporter used during the test.
  61   std::shared_ptr<ClangASTImporter> importer;
  62   /// The ExpressionDeclMap for the current test case.
  63   std::unique_ptr<FakeClangExpressionDeclMap> decl_map;
  64
  65   /// The target AST that lookup results should be imported to.
  66   std::unique_ptr<TypeSystemClang> target_ast;
  67
  68   void SetUp() override {
  69     importer = std::make_shared<ClangASTImporter>();
  70     decl_map = std::make_unique<FakeClangExpressionDeclMap>(importer);
  71     target_ast = clang_utils::createAST();
  72     decl_map->InstallASTContext(*target_ast);
  73   }
  74
  75   void TearDown() override {
  76     importer.reset();
  77     decl_map.reset();
  78     target_ast.reset();
  79   }
  80 };
  81 } // namespace
  82
  83 TEST_F(ClangExpressionDeclMapTest, TestUnknownIdentifierLookup) {
  84   // Tests looking up an identifier that can't be found anywhere.
  85
  86   // Setup a NameSearchContext for 'foo'.
  87   llvm::SmallVector<clang::NamedDecl *, 16> decls;
  88   clang::DeclarationName name =
  89       clang_utils::getDeclarationName(*target_ast, "foo");
  90   const clang::DeclContext *dc = target_ast->GetTranslationUnitDecl();
  91   NameSearchContext search(*target_ast, decls, name, dc);
  92
  93   decl_map->FindExternalVisibleDecls(search);
  94
  95   // This shouldn't exist so we should get no lookups.
  96   EXPECT_EQ(0U, decls.size());
  97 }
  98
  99 TEST_F(ClangExpressionDeclMapTest, TestPersistentDeclLookup) {
 100   // Tests looking up a persistent decl from the scratch AST context.
 101
 102   // Create a '$persistent_class' record and add it as a persistent variable
 103   // to the scratch AST context.
 104   llvm::StringRef decl_name = "$persistent_class";
 105   CompilerType persistent_type =
 106       clang_utils::createRecord(*decl_map->m_scratch_context, decl_name);
 107   decl_map->AddPersistentDeclForTest(ClangUtil::GetAsTagDecl(persistent_type));
 108
 109   // Setup a NameSearchContext for $persistent_class;
 110   llvm::SmallVector<clang::NamedDecl *, 16> decls;
 111   clang::DeclarationName name =
 112       clang_utils::getDeclarationName(*target_ast, decl_name);
 113   const clang::DeclContext *dc = target_ast->GetTranslationUnitDecl();
 114   NameSearchContext search(*target_ast, decls, name, dc);
 115
 116   // Search and check that we found $persistent_class.
 117   decl_map->FindExternalVisibleDecls(search);
 118   EXPECT_EQ(1U, decls.size());
 119   EXPECT_EQ(decl_name, decls.front()->getQualifiedNameAsString());
 120   auto *record = llvm::cast<clang::RecordDecl>(decls.front());
 121   // The class was minimally imported from the scratch AST context.
 122   EXPECT_TRUE(record->hasExternalLexicalStorage());
 123 }