llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangASTSource.cpp

//===-- ClangASTSource.cpp ------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#include "ClangASTSource.h"

#include "ClangDeclVendor.h"
#include "ClangModulesDeclVendor.h"

#include "lldb/Core/Module.h"
#include "lldb/Core/ModuleList.h"
#include "lldb/Symbol/CompilerDeclContext.h"
#include "lldb/Symbol/Function.h"
#include "lldb/Symbol/SymbolFile.h"
#include "lldb/Symbol/TaggedASTType.h"
#include "lldb/Target/Target.h"
#include "lldb/Utility/LLDBLog.h"
#include "lldb/Utility/Log.h"
#include "clang/AST/ASTContext.h"
#include "clang/Basic/SourceManager.h"

#include "Plugins/ExpressionParser/Clang/ClangUtil.h"
#include "Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h"
#include "Plugins/TypeSystem/Clang/TypeSystemClang.h"

#include <memory>
#include <vector>

usingnamespaceclang;
usingnamespacelldb_private;

// Scoped class that will remove an active lexical decl from the set when it
// goes out of scope.
namespace {
class ScopedLexicalDeclEraser { … };
}

ClangASTSource::ClangASTSource(
    const lldb::TargetSP &target,
    const std::shared_ptr<ClangASTImporter> &importer)
    : … { … }

void ClangASTSource::InstallASTContext(TypeSystemClang &clang_ast_context) { … }

ClangASTSource::~ClangASTSource() { … }

void ClangASTSource::StartTranslationUnit(ASTConsumer *Consumer) { … }

// The core lookup interface.
bool ClangASTSource::FindExternalVisibleDeclsByName(
    const DeclContext *decl_ctx, DeclarationName clang_decl_name) { … }

TagDecl *ClangASTSource::FindCompleteType(const TagDecl *decl) { … }

void ClangASTSource::CompleteType(TagDecl *tag_decl) { … }

void ClangASTSource::CompleteType(clang::ObjCInterfaceDecl *interface_decl) { … }

clang::ObjCInterfaceDecl *ClangASTSource::GetCompleteObjCInterface(
    const clang::ObjCInterfaceDecl *interface_decl) { … }

void ClangASTSource::FindExternalLexicalDecls(
    const DeclContext *decl_context,
    llvm::function_ref<bool(Decl::Kind)> predicate,
    llvm::SmallVectorImpl<Decl *> &decls) { … }

void ClangASTSource::FindExternalVisibleDecls(NameSearchContext &context) { … }

clang::Sema *ClangASTSource::getSema() { … }

bool ClangASTSource::IgnoreName(const ConstString name,
                                bool ignore_all_dollar_names) { … }

void ClangASTSource::FindExternalVisibleDecls(
    NameSearchContext &context, lldb::ModuleSP module_sp,
    CompilerDeclContext &namespace_decl) { … }

void ClangASTSource::FillNamespaceMap(
    NameSearchContext &context, lldb::ModuleSP module_sp,
    const CompilerDeclContext &namespace_decl) { … }

bool ClangASTSource::FindObjCMethodDeclsWithOrigin(
    NameSearchContext &context, ObjCInterfaceDecl *original_interface_decl,
    const char *log_info) { … }

void ClangASTSource::FindDeclInModules(NameSearchContext &context,
                                       ConstString name) { … }

void ClangASTSource::FindDeclInObjCRuntime(NameSearchContext &context,
                                           ConstString name) { … }

void ClangASTSource::FindObjCMethodDecls(NameSearchContext &context) { … }

bool ClangASTSource::FindObjCPropertyAndIvarDeclsWithOrigin(
    NameSearchContext &context,
    DeclFromUser<const ObjCInterfaceDecl> &origin_iface_decl) { … }

void ClangASTSource::FindObjCPropertyAndIvarDecls(NameSearchContext &context) { … }

void ClangASTSource::LookupInNamespace(NameSearchContext &context) { … }

bool ClangASTSource::layoutRecordType(
    const RecordDecl *record, uint64_t &size, uint64_t &alignment,
    llvm::DenseMap<const clang::FieldDecl *, uint64_t> &field_offsets,
    llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
        &base_offsets,
    llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
        &virtual_base_offsets) { … }

void ClangASTSource::CompleteNamespaceMap(
    ClangASTImporter::NamespaceMapSP &namespace_map, ConstString name,
    ClangASTImporter::NamespaceMapSP &parent_map) const { … }

NamespaceDecl *ClangASTSource::AddNamespace(
    NameSearchContext &context,
    ClangASTImporter::NamespaceMapSP &namespace_decls) { … }

clang::Decl *ClangASTSource::CopyDecl(Decl *src_decl) { … }

ClangASTImporter::DeclOrigin ClangASTSource::GetDeclOrigin(const clang::Decl *decl) { … }

CompilerType ClangASTSource::GuardedCopyType(const CompilerType &src_type) { … }

std::shared_ptr<ClangModulesDeclVendor>
ClangASTSource::GetClangModulesDeclVendor() { … }