lldb/source/Symbol/ClangASTImporter.cpp

//===-- ClangASTImporter.cpp ------------------------------------*- C++ -*-===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//

#include "clang/AST/Decl.h"
#include "clang/AST/DeclCXX.h"
#include "clang/AST/DeclObjC.h"
#include "llvm/Support/raw_ostream.h"
#include "lldb/Core/Log.h"
#include "lldb/Core/Module.h"
#include "lldb/Symbol/ClangASTContext.h"
#include "lldb/Symbol/ClangASTImporter.h"
#include "lldb/Symbol/ClangExternalASTSourceCommon.h"
#include "lldb/Utility/LLDBAssert.h"

using namespace lldb_private;
using namespace clang;

ClangASTMetrics::Counters ClangASTMetrics::global_counters = { 0, 0, 0, 0, 0, 0 };
ClangASTMetrics::Counters ClangASTMetrics::local_counters = { 0, 0, 0, 0, 0, 0 };

void ClangASTMetrics::DumpCounters (Log *log, ClangASTMetrics::Counters &counters)
{
    log->Printf("  Number of visible Decl queries by name     : %" PRIu64, counters.m_visible_query_count);
    log->Printf("  Number of lexical Decl queries             : %" PRIu64, counters.m_lexical_query_count);
    log->Printf("  Number of imports initiated by LLDB        : %" PRIu64, counters.m_lldb_import_count);
    log->Printf("  Number of imports conducted by Clang       : %" PRIu64, counters.m_clang_import_count);
    log->Printf("  Number of Decls completed                  : %" PRIu64, counters.m_decls_completed_count);
    log->Printf("  Number of records laid out                 : %" PRIu64, counters.m_record_layout_count);
}

void ClangASTMetrics::DumpCounters (Log *log)
{
    if (!log)
        return;
    
    log->Printf("== ClangASTMetrics output ==");
    log->Printf("-- Global metrics --");
    DumpCounters (log, global_counters);
    log->Printf("-- Local metrics --");
    DumpCounters (log, local_counters);
}

clang::QualType
ClangASTImporter::CopyType (clang::ASTContext *dst_ast,
                            clang::ASTContext *src_ast,
                            clang::QualType type)
{
    MinionSP minion_sp (GetMinion(dst_ast, src_ast));
    
    if (minion_sp)
        return minion_sp->Import(type);
    
    return QualType();
}

lldb::opaque_compiler_type_t
ClangASTImporter::CopyType (clang::ASTContext *dst_ast,
                            clang::ASTContext *src_ast,
                            lldb::opaque_compiler_type_t type)
{
    return CopyType (dst_ast, src_ast, QualType::getFromOpaquePtr(type)).getAsOpaquePtr();
}

CompilerType
ClangASTImporter::CopyType (ClangASTContext &dst_ast,
                            const CompilerType &src_type)
{
    clang::ASTContext *dst_clang_ast = dst_ast.getASTContext();
    if (dst_clang_ast)
    {
        ClangASTContext *src_ast = llvm::dyn_cast_or_null<ClangASTContext>(src_type.GetTypeSystem());
        if (src_ast)
        {
            clang::ASTContext *src_clang_ast = src_ast->getASTContext();
            if (src_clang_ast)
            {
                lldb::opaque_compiler_type_t dst_clang_type = CopyType(dst_clang_ast,
                                                                       src_clang_ast,
                                                                       src_type.GetOpaqueQualType());

                if (dst_clang_type)
                    return CompilerType(&dst_ast, dst_clang_type);
            }
        }
    }
    return CompilerType();
}

clang::Decl *
ClangASTImporter::CopyDecl (clang::ASTContext *dst_ast,
                            clang::ASTContext *src_ast,
                            clang::Decl *decl)
{
    MinionSP minion_sp;
    
    minion_sp = GetMinion(dst_ast, src_ast);
    
    if (minion_sp)
    {
        clang::Decl *result = minion_sp->Import(decl);
        
        if (!result)
        {
            Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));

            if (log)
            {
                lldb::user_id_t user_id = LLDB_INVALID_UID;
                ClangASTMetadata *metadata = GetDeclMetadata(decl);
                if (metadata)
                    user_id = metadata->GetUserID();
                
                if (NamedDecl *named_decl = dyn_cast<NamedDecl>(decl))
                    log->Printf("  [ClangASTImporter] WARNING: Failed to import a %s '%s', metadata 0x%" PRIx64,
                                decl->getDeclKindName(),
                                named_decl->getNameAsString().c_str(),
                                user_id);
                else
                    log->Printf("  [ClangASTImporter] WARNING: Failed to import a %s, metadata 0x%" PRIx64,
                                decl->getDeclKindName(),
                                user_id);
            }
        }
        
        return result;
    }
    
    return nullptr;
}

class DeclContextOverride
{
private:
    struct Backup
    {
        clang::DeclContext *decl_context;
        clang::DeclContext *lexical_decl_context;
    };
    
    std::map<clang::Decl *, Backup> m_backups;
    
    void OverrideOne(clang::Decl *decl)
    {
        if (m_backups.find(decl) != m_backups.end())
        {
            return;
        }
            
        m_backups[decl] = { decl->getDeclContext(), decl->getLexicalDeclContext() };
        
        decl->setDeclContext(decl->getASTContext().getTranslationUnitDecl());
        decl->setLexicalDeclContext(decl->getASTContext().getTranslationUnitDecl());
    }
    
    bool ChainPassesThrough(clang::Decl *decl,
                            clang::DeclContext *base,
                            clang::DeclContext *(clang::Decl::*contextFromDecl)(),
                            clang::DeclContext *(clang::DeclContext::*contextFromContext)())
    {
        for (DeclContext *decl_ctx = (decl->*contextFromDecl)();
             decl_ctx;
             decl_ctx = (decl_ctx->*contextFromContext)())
        {
            if (decl_ctx == base)
            {
                return true;
            }
        }
        
        return false;
    }
    
    clang::Decl *GetEscapedChild(clang::Decl *decl, clang::DeclContext *base = nullptr)
    {
        if (base)
        {
            // decl's DeclContext chains must pass through base.
            
            if (!ChainPassesThrough(decl, base, &clang::Decl::getDeclContext, &clang::DeclContext::getParent) ||
                !ChainPassesThrough(decl, base, &clang::Decl::getLexicalDeclContext, &clang::DeclContext::getLexicalParent))
            {
                return decl;
            }
        }
        else
        {
            base = clang::dyn_cast<clang::DeclContext>(decl);
            
            if (!base)
            {
                return nullptr;
            }
        }
        
        if (clang::DeclContext *context = clang::dyn_cast<clang::DeclContext>(decl))
        {
            for (clang::Decl *decl : context->decls())
            {
                if (clang::Decl *escaped_child = GetEscapedChild(decl))
                {
                    return escaped_child;
                }
            }
        }
        
        return nullptr;
    }
    
    void Override(clang::Decl *decl)
    {
        if (clang::Decl *escaped_child = GetEscapedChild(decl))
        {
            Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
            
            if (log)
                log->Printf("    [ClangASTImporter] DeclContextOverride couldn't override (%sDecl*)%p - its child (%sDecl*)%p escapes",
                            decl->getDeclKindName(), static_cast<void*>(decl),
                            escaped_child->getDeclKindName(), static_cast<void*>(escaped_child));
            lldbassert(0 && "Couldn't override!");
        }
        
        OverrideOne(decl);
    }
    
public:
    DeclContextOverride()
    {
    }
    
    void OverrideAllDeclsFromContainingFunction(clang::Decl *decl)
    {
        for (DeclContext *decl_context = decl->getLexicalDeclContext();
             decl_context;
             decl_context = decl_context->getLexicalParent())
        {
            DeclContext *redecl_context = decl_context->getRedeclContext();
            
            if (llvm::isa<FunctionDecl>(redecl_context) &&
                llvm::isa<TranslationUnitDecl>(redecl_context->getLexicalParent()))
            {
                for (clang::Decl *child_decl : decl_context->decls())
                {
                    Override(child_decl);
                }
            }
        }
    }
    
    ~DeclContextOverride()
    {
        for (const std::pair<clang::Decl *, Backup> &backup : m_backups)
        {
            backup.first->setDeclContext(backup.second.decl_context);
            backup.first->setLexicalDeclContext(backup.second.lexical_decl_context);
        }
    }
};

lldb::opaque_compiler_type_t
ClangASTImporter::DeportType (clang::ASTContext *dst_ctx,
                              clang::ASTContext *src_ctx,
                              lldb::opaque_compiler_type_t type)
{
    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
  
    if (log)
        log->Printf("    [ClangASTImporter] DeportType called on (%sType*)0x%llx from (ASTContext*)%p to (ASTContext*)%p",
                    QualType::getFromOpaquePtr(type)->getTypeClassName(), (unsigned long long)type,
                    static_cast<void*>(src_ctx),
                    static_cast<void*>(dst_ctx));

    MinionSP minion_sp (GetMinion (dst_ctx, src_ctx));
    
    if (!minion_sp)
        return nullptr;
    
    std::set<NamedDecl *> decls_to_deport;
    std::set<NamedDecl *> decls_already_deported;
    
    DeclContextOverride decl_context_override;
    
    if (const clang::TagType *tag_type = clang::QualType::getFromOpaquePtr(type)->getAs<TagType>())
    {
        decl_context_override.OverrideAllDeclsFromContainingFunction(tag_type->getDecl());
    }
    
    minion_sp->InitDeportWorkQueues(&decls_to_deport,
                                    &decls_already_deported);
    
    lldb::opaque_compiler_type_t result = CopyType(dst_ctx, src_ctx, type);
    
    minion_sp->ExecuteDeportWorkQueues();
    
    if (!result)
        return nullptr;
    
    return result;

}

clang::Decl *
ClangASTImporter::DeportDecl (clang::ASTContext *dst_ctx,
                              clang::ASTContext *src_ctx,
                              clang::Decl *decl)
{
    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));

    if (log)
        log->Printf("    [ClangASTImporter] DeportDecl called on (%sDecl*)%p from (ASTContext*)%p to (ASTContext*)%p",
                    decl->getDeclKindName(), static_cast<void*>(decl),
                    static_cast<void*>(src_ctx),
                    static_cast<void*>(dst_ctx));

    MinionSP minion_sp (GetMinion (dst_ctx, src_ctx));

    if (!minion_sp)
        return nullptr;

    std::set<NamedDecl *> decls_to_deport;
    std::set<NamedDecl *> decls_already_deported;
    
    DeclContextOverride decl_context_override;
    
    decl_context_override.OverrideAllDeclsFromContainingFunction(decl);

    minion_sp->InitDeportWorkQueues(&decls_to_deport,
                                    &decls_already_deported);

    clang::Decl *result = CopyDecl(dst_ctx, src_ctx, decl);

    minion_sp->ExecuteDeportWorkQueues();

    if (!result)
        return nullptr;

    if (log)
        log->Printf("    [ClangASTImporter] DeportDecl deported (%sDecl*)%p to (%sDecl*)%p",
                    decl->getDeclKindName(), static_cast<void*>(decl),
                    result->getDeclKindName(), static_cast<void*>(result));

    return result;
}

void
ClangASTImporter::CompleteDecl (clang::Decl *decl)
{
    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));

    if (log)
        log->Printf("    [ClangASTImporter] CompleteDecl called on (%sDecl*)%p",
                    decl->getDeclKindName(), static_cast<void*>(decl));

    if (ObjCInterfaceDecl *interface_decl = dyn_cast<ObjCInterfaceDecl>(decl)) 
    {
        if (!interface_decl->getDefinition())
        {
            interface_decl->startDefinition();
            CompleteObjCInterfaceDecl(interface_decl);
        }
    }
    else if (ObjCProtocolDecl *protocol_decl = dyn_cast<ObjCProtocolDecl>(decl)) 
    {
        if (!protocol_decl->getDefinition())
            protocol_decl->startDefinition();
    }
    else if (TagDecl *tag_decl = dyn_cast<TagDecl>(decl)) 
    {
        if (!tag_decl->getDefinition() && !tag_decl->isBeingDefined()) 
        {
            tag_decl->startDefinition();
            CompleteTagDecl(tag_decl);
            tag_decl->setCompleteDefinition(true);
        }
    }
    else
    {
        assert (0 && "CompleteDecl called on a Decl that can't be completed");
    }
}

bool
ClangASTImporter::CompleteTagDecl (clang::TagDecl *decl)
{
    ClangASTMetrics::RegisterDeclCompletion();
    
    DeclOrigin decl_origin = GetDeclOrigin(decl);
    
    if (!decl_origin.Valid())
        return false;
    
    if (!ClangASTContext::GetCompleteDecl(decl_origin.ctx, decl_origin.decl))
        return false;
    
    MinionSP minion_sp (GetMinion(&decl->getASTContext(), decl_origin.ctx));
    
    if (minion_sp)
        minion_sp->ImportDefinitionTo(decl, decl_origin.decl);
        
    return true;
}

bool
ClangASTImporter::CompleteTagDeclWithOrigin(clang::TagDecl *decl, clang::TagDecl *origin_decl)
{
    ClangASTMetrics::RegisterDeclCompletion();

    clang::ASTContext *origin_ast_ctx = &origin_decl->getASTContext();
        
    if (!ClangASTContext::GetCompleteDecl(origin_ast_ctx, origin_decl))
        return false;
    
    MinionSP minion_sp (GetMinion(&decl->getASTContext(), origin_ast_ctx));
    
    if (minion_sp)
        minion_sp->ImportDefinitionTo(decl, origin_decl);
        
    ASTContextMetadataSP context_md = GetContextMetadata(&decl->getASTContext());

    OriginMap &origins = context_md->m_origins;

    origins[decl] = DeclOrigin(origin_ast_ctx, origin_decl);
    
    return true;
}

bool
ClangASTImporter::CompleteObjCInterfaceDecl (clang::ObjCInterfaceDecl *interface_decl)
{
    ClangASTMetrics::RegisterDeclCompletion();
    
    DeclOrigin decl_origin = GetDeclOrigin(interface_decl);
    
    if (!decl_origin.Valid())
        return false;
    
    if (!ClangASTContext::GetCompleteDecl(decl_origin.ctx, decl_origin.decl))
        return false;
    
    MinionSP minion_sp (GetMinion(&interface_decl->getASTContext(), decl_origin.ctx));
    
    if (minion_sp)
        minion_sp->ImportDefinitionTo(interface_decl, decl_origin.decl);

    if (ObjCInterfaceDecl *super_class = interface_decl->getSuperClass())
        RequireCompleteType(clang::QualType(super_class->getTypeForDecl(), 0));

    return true;
}

bool
ClangASTImporter::CompleteAndFetchChildren (clang::QualType type)
{
    if (!RequireCompleteType(type))
        return false;

    if (const TagType *tag_type = type->getAs<TagType>())
    {
        TagDecl *tag_decl = tag_type->getDecl();

        DeclOrigin decl_origin = GetDeclOrigin(tag_decl);

        if (!decl_origin.Valid())
            return false;

        MinionSP minion_sp (GetMinion(&tag_decl->getASTContext(), decl_origin.ctx));

        TagDecl *origin_tag_decl = llvm::dyn_cast<TagDecl>(decl_origin.decl);

        for (Decl *origin_child_decl : origin_tag_decl->decls())
        {
            minion_sp->Import(origin_child_decl);
        }

        if (RecordDecl *record_decl = dyn_cast<RecordDecl>(origin_tag_decl))
        {
            record_decl->setHasLoadedFieldsFromExternalStorage(true);
        }

        return true;
    }

    if (const ObjCObjectType *objc_object_type = type->getAs<ObjCObjectType>())
    {
        if (ObjCInterfaceDecl *objc_interface_decl = objc_object_type->getInterface())
        {
            DeclOrigin decl_origin = GetDeclOrigin(objc_interface_decl);

            if (!decl_origin.Valid())
                return false;

            MinionSP minion_sp (GetMinion(&objc_interface_decl->getASTContext(), decl_origin.ctx));

            ObjCInterfaceDecl *origin_interface_decl = llvm::dyn_cast<ObjCInterfaceDecl>(decl_origin.decl);

            for (Decl *origin_child_decl : origin_interface_decl->decls())
            {
                minion_sp->Import(origin_child_decl);
            }

            return true;
        }
        else
        {
            return false;
        }
    }
    
    return true;
}


bool
ClangASTImporter::RequireCompleteType (clang::QualType type)
{
    if (type.isNull())
        return false;
    
    if (const TagType *tag_type = type->getAs<TagType>())
    {
        TagDecl *tag_decl = tag_type->getDecl();

        if (tag_decl->getDefinition() || tag_decl->isBeingDefined())
            return true;

        return CompleteTagDecl(tag_decl);
    }
    if (const ObjCObjectType *objc_object_type = type->getAs<ObjCObjectType>())
    {
        if (ObjCInterfaceDecl *objc_interface_decl = objc_object_type->getInterface())
            return CompleteObjCInterfaceDecl(objc_interface_decl);
        else
            return false;
    }
    if (const ArrayType *array_type = type->getAsArrayTypeUnsafe())
    {
        return RequireCompleteType(array_type->getElementType());
    }
    if (const AtomicType *atomic_type = type->getAs<AtomicType>())
    {
        return RequireCompleteType(atomic_type->getPointeeType());
    }
    
    return true;
}

ClangASTMetadata *
ClangASTImporter::GetDeclMetadata (const clang::Decl *decl)
{
    DeclOrigin decl_origin = GetDeclOrigin(decl);
    
    if (decl_origin.Valid())
        return ClangASTContext::GetMetadata(decl_origin.ctx, decl_origin.decl);
    else
        return ClangASTContext::GetMetadata(&decl->getASTContext(), decl);
}

ClangASTImporter::DeclOrigin
ClangASTImporter::GetDeclOrigin(const clang::Decl *decl)
{
    ASTContextMetadataSP context_md = GetContextMetadata(&decl->getASTContext());
    
    OriginMap &origins = context_md->m_origins;
    
    OriginMap::iterator iter = origins.find(decl);
    
    if (iter != origins.end())
        return iter->second;
    else
        return DeclOrigin();
}

void
ClangASTImporter::SetDeclOrigin (const clang::Decl *decl, clang::Decl *original_decl)
{
    ASTContextMetadataSP context_md = GetContextMetadata(&decl->getASTContext());
    
    OriginMap &origins = context_md->m_origins;
    
    OriginMap::iterator iter = origins.find(decl);
    
    if (iter != origins.end())
    {
        iter->second.decl = original_decl;
        iter->second.ctx = &original_decl->getASTContext();
    }
    else
    {
        origins[decl] = DeclOrigin(&original_decl->getASTContext(), original_decl);
    }
}

void
ClangASTImporter::RegisterNamespaceMap(const clang::NamespaceDecl *decl, 
                                       NamespaceMapSP &namespace_map)
{
    ASTContextMetadataSP context_md = GetContextMetadata(&decl->getASTContext());
    
    context_md->m_namespace_maps[decl] = namespace_map;
}

ClangASTImporter::NamespaceMapSP 
ClangASTImporter::GetNamespaceMap(const clang::NamespaceDecl *decl)
{
    ASTContextMetadataSP context_md = GetContextMetadata(&decl->getASTContext());

    NamespaceMetaMap &namespace_maps = context_md->m_namespace_maps;
    
    NamespaceMetaMap::iterator iter = namespace_maps.find(decl);
    
    if (iter != namespace_maps.end())
        return iter->second;
    else
        return NamespaceMapSP();
}

void 
ClangASTImporter::BuildNamespaceMap(const clang::NamespaceDecl *decl)
{
    assert (decl);
    ASTContextMetadataSP context_md = GetContextMetadata(&decl->getASTContext());

    const DeclContext *parent_context = decl->getDeclContext();
    const NamespaceDecl *parent_namespace = dyn_cast<NamespaceDecl>(parent_context);
    NamespaceMapSP parent_map;
    
    if (parent_namespace)
        parent_map = GetNamespaceMap(parent_namespace);
    
    NamespaceMapSP new_map;
    
    new_map.reset(new NamespaceMap);
 
    if (context_md->m_map_completer)
    {
        std::string namespace_string = decl->getDeclName().getAsString();
    
        context_md->m_map_completer->CompleteNamespaceMap (new_map, ConstString(namespace_string.c_str()), parent_map);
    }
    
    context_md->m_namespace_maps[decl] = new_map;
}

void 
ClangASTImporter::ForgetDestination (clang::ASTContext *dst_ast)
{
    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));

    if (log)
        log->Printf("    [ClangASTImporter] Forgetting destination (ASTContext*)%p",
                    static_cast<void*>(dst_ast));

    m_metadata_map.erase(dst_ast);
}

void
ClangASTImporter::ForgetSource (clang::ASTContext *dst_ast, clang::ASTContext *src_ast)
{
    ASTContextMetadataSP md = MaybeGetContextMetadata (dst_ast);

    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));

    if (log)
        log->Printf("    [ClangASTImporter] Forgetting source->dest (ASTContext*)%p->(ASTContext*)%p",
                    static_cast<void*>(src_ast), static_cast<void*>(dst_ast));

    if (!md)
        return;

    md->m_minions.erase(src_ast);

    for (OriginMap::iterator iter = md->m_origins.begin();
         iter != md->m_origins.end();
         )
    {
        if (iter->second.ctx == src_ast)
            md->m_origins.erase(iter++);
        else
            ++iter;
    }
}

ClangASTImporter::MapCompleter::~MapCompleter ()
{
    return;
}

void
ClangASTImporter::Minion::InitDeportWorkQueues (std::set<clang::NamedDecl *> *decls_to_deport,
                                                std::set<clang::NamedDecl *> *decls_already_deported)
{
    assert(!m_decls_to_deport);
    assert(!m_decls_already_deported);
    
    m_decls_to_deport = decls_to_deport;
    m_decls_already_deported = decls_already_deported;
}

void
ClangASTImporter::Minion::ExecuteDeportWorkQueues ()
{
    assert(m_decls_to_deport);
    assert(m_decls_already_deported);
    
    ASTContextMetadataSP to_context_md = m_master.GetContextMetadata(&getToContext());
        
    while (!m_decls_to_deport->empty())
    {
        NamedDecl *decl = *m_decls_to_deport->begin();
        
        m_decls_already_deported->insert(decl);
        m_decls_to_deport->erase(decl);
        
        DeclOrigin &origin = to_context_md->m_origins[decl];
        UNUSED_IF_ASSERT_DISABLED(origin);
        
        assert (origin.ctx == m_source_ctx);    // otherwise we should never have added this
                                                // because it doesn't need to be deported
        
        Decl *original_decl = to_context_md->m_origins[decl].decl;
        
        ClangASTContext::GetCompleteDecl (m_source_ctx, original_decl);
        
        if (TagDecl *tag_decl = dyn_cast<TagDecl>(decl))
        {
            if (TagDecl *original_tag_decl = dyn_cast<TagDecl>(original_decl))
            {
                if (original_tag_decl->isCompleteDefinition())
                {
                    ImportDefinitionTo(tag_decl, original_tag_decl);
                    tag_decl->setCompleteDefinition(true);
                }
            }
            
            tag_decl->setHasExternalLexicalStorage(false);
            tag_decl->setHasExternalVisibleStorage(false);
        }
        else if (ObjCContainerDecl *container_decl = dyn_cast<ObjCContainerDecl>(decl))
        {
            container_decl->setHasExternalLexicalStorage(false);
            container_decl->setHasExternalVisibleStorage(false);
        }
        
        to_context_md->m_origins.erase(decl);
    }
    
    m_decls_to_deport = nullptr;
    m_decls_already_deported = nullptr;
}

void
ClangASTImporter::Minion::ImportDefinitionTo (clang::Decl *to, clang::Decl *from)
{
    ASTImporter::Imported(from, to);

    /*
    if (to_objc_interface)
        to_objc_interface->startDefinition();
 
    CXXRecordDecl *to_cxx_record = dyn_cast<CXXRecordDecl>(to);
    
    if (to_cxx_record)
        to_cxx_record->startDefinition();
    */

    ImportDefinition(from);
    
    if (clang::TagDecl *to_tag = dyn_cast<clang::TagDecl>(to))
    {
        if (clang::TagDecl *from_tag = dyn_cast<clang::TagDecl>(from))
        {
            to_tag->setCompleteDefinition(from_tag->isCompleteDefinition());
        }
    }
     
    // If we're dealing with an Objective-C class, ensure that the inheritance has
    // been set up correctly.  The ASTImporter may not do this correctly if the 
    // class was originally sourced from symbols.
    
    if (ObjCInterfaceDecl *to_objc_interface = dyn_cast<ObjCInterfaceDecl>(to))
    {
        do
        {
            ObjCInterfaceDecl *to_superclass = to_objc_interface->getSuperClass();

            if (to_superclass)
                break; // we're not going to override it if it's set
            
            ObjCInterfaceDecl *from_objc_interface = dyn_cast<ObjCInterfaceDecl>(from);
            
            if (!from_objc_interface)
                break;
            
            ObjCInterfaceDecl *from_superclass = from_objc_interface->getSuperClass();
            
            if (!from_superclass)
                break;
            
            Decl *imported_from_superclass_decl = Import(from_superclass);
                
            if (!imported_from_superclass_decl)
                break;
                
            ObjCInterfaceDecl *imported_from_superclass = dyn_cast<ObjCInterfaceDecl>(imported_from_superclass_decl);
            
            if (!imported_from_superclass)
                break;
            
            if (!to_objc_interface->hasDefinition())
                to_objc_interface->startDefinition();
            
            to_objc_interface->setSuperClass(
                    m_source_ctx->getTrivialTypeSourceInfo(m_source_ctx->getObjCInterfaceType(imported_from_superclass)));
        }
        while (0);
    }
}

clang::Decl *
ClangASTImporter::Minion::Imported (clang::Decl *from, clang::Decl *to)
{
    ClangASTMetrics::RegisterClangImport();

    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));

    lldb::user_id_t user_id = LLDB_INVALID_UID;
    ClangASTMetadata *metadata = m_master.GetDeclMetadata(from);
    if (metadata)
        user_id = metadata->GetUserID();
    
    if (log)
    {
        if (NamedDecl *from_named_decl = dyn_cast<clang::NamedDecl>(from))
        {
            std::string name_string;
            llvm::raw_string_ostream name_stream(name_string);
            from_named_decl->printName(name_stream);
            name_stream.flush();

            log->Printf("    [ClangASTImporter] Imported (%sDecl*)%p, named %s (from (Decl*)%p), metadata 0x%" PRIx64,
                        from->getDeclKindName(), static_cast<void*>(to),
                        name_string.c_str(), static_cast<void*>(from),
                        user_id);
        }
        else
        {
            log->Printf("    [ClangASTImporter] Imported (%sDecl*)%p (from (Decl*)%p), metadata 0x%" PRIx64,
                        from->getDeclKindName(), static_cast<void*>(to),
                        static_cast<void*>(from), user_id);
        }
    }

    ASTContextMetadataSP to_context_md = m_master.GetContextMetadata(&to->getASTContext());
    ASTContextMetadataSP from_context_md = m_master.MaybeGetContextMetadata(m_source_ctx);

    if (from_context_md)
    {
        OriginMap &origins = from_context_md->m_origins;

        OriginMap::iterator origin_iter = origins.find(from);

        if (origin_iter != origins.end())
        {
            if (to_context_md->m_origins.find(to) == to_context_md->m_origins.end() ||
                user_id != LLDB_INVALID_UID)
            {
                if (origin_iter->second.ctx != &to->getASTContext())
                    to_context_md->m_origins[to] = origin_iter->second;
            }
                
            MinionSP direct_completer = m_master.GetMinion(&to->getASTContext(), origin_iter->second.ctx);

            if (direct_completer.get() != this)
                direct_completer->ASTImporter::Imported(origin_iter->second.decl, to);

            if (log)
                log->Printf("    [ClangASTImporter] Propagated origin (Decl*)%p/(ASTContext*)%p from (ASTContext*)%p to (ASTContext*)%p",
                            static_cast<void*>(origin_iter->second.decl),
                            static_cast<void*>(origin_iter->second.ctx),
                            static_cast<void*>(&from->getASTContext()),
                            static_cast<void*>(&to->getASTContext()));
        }
        else
        {
            if (m_decls_to_deport && m_decls_already_deported)
            {
                if (isa<TagDecl>(to) || isa<ObjCInterfaceDecl>(to))
                {
                    RecordDecl *from_record_decl = dyn_cast<RecordDecl>(from);
                    if (from_record_decl == nullptr || from_record_decl->isInjectedClassName() == false)
                    {
                        NamedDecl *to_named_decl = dyn_cast<NamedDecl>(to);

                        if (!m_decls_already_deported->count(to_named_decl))
                            m_decls_to_deport->insert(to_named_decl);
                    }
                }
            }
            
            if (to_context_md->m_origins.find(to) == to_context_md->m_origins.end() ||
                user_id != LLDB_INVALID_UID)
            {
                to_context_md->m_origins[to] = DeclOrigin(m_source_ctx, from);
            }

            if (log)
                log->Printf("    [ClangASTImporter] Decl has no origin information in (ASTContext*)%p",
                            static_cast<void*>(&from->getASTContext()));
        }

        if (clang::NamespaceDecl *to_namespace = dyn_cast<clang::NamespaceDecl>(to))
        {
            clang::NamespaceDecl *from_namespace = dyn_cast<clang::NamespaceDecl>(from);

            NamespaceMetaMap &namespace_maps = from_context_md->m_namespace_maps;

            NamespaceMetaMap::iterator namespace_map_iter = namespace_maps.find(from_namespace);

            if (namespace_map_iter != namespace_maps.end())
                to_context_md->m_namespace_maps[to_namespace] = namespace_map_iter->second;
        }
    }
    else
    {
        to_context_md->m_origins[to] = DeclOrigin (m_source_ctx, from);

        if (log)
            log->Printf("    [ClangASTImporter] Sourced origin (Decl*)%p/(ASTContext*)%p into (ASTContext*)%p",
                        static_cast<void*>(from),
                        static_cast<void*>(m_source_ctx),
                        static_cast<void*>(&to->getASTContext()));
    }

    if (TagDecl *from_tag_decl = dyn_cast<TagDecl>(from))
    {
        TagDecl *to_tag_decl = dyn_cast<TagDecl>(to);

        to_tag_decl->setHasExternalLexicalStorage();
        to_tag_decl->setMustBuildLookupTable();

        if (log)
            log->Printf("    [ClangASTImporter] To is a TagDecl - attributes %s%s [%s->%s]",
                        (to_tag_decl->hasExternalLexicalStorage() ? " Lexical" : ""),
                        (to_tag_decl->hasExternalVisibleStorage() ? " Visible" : ""),
                        (from_tag_decl->isCompleteDefinition() ? "complete" : "incomplete"),
                        (to_tag_decl->isCompleteDefinition() ? "complete" : "incomplete"));
    }

    if (isa<NamespaceDecl>(from))
    {
        NamespaceDecl *to_namespace_decl = dyn_cast<NamespaceDecl>(to);

        m_master.BuildNamespaceMap(to_namespace_decl);

        to_namespace_decl->setHasExternalVisibleStorage();
    }

    if (isa<ObjCContainerDecl>(from))
    {
        ObjCContainerDecl *to_container_decl = dyn_cast<ObjCContainerDecl>(to);

        to_container_decl->setHasExternalLexicalStorage();
        to_container_decl->setHasExternalVisibleStorage();

        /*to_interface_decl->setExternallyCompleted();*/

        if (log)
        {
            if (ObjCInterfaceDecl *to_interface_decl = llvm::dyn_cast<ObjCInterfaceDecl>(to_container_decl))
            {
                log->Printf("    [ClangASTImporter] To is an ObjCInterfaceDecl - attributes %s%s%s",
                            (to_interface_decl->hasExternalLexicalStorage() ? " Lexical" : ""),
                            (to_interface_decl->hasExternalVisibleStorage() ? " Visible" : ""),
                            (to_interface_decl->hasDefinition() ? " HasDefinition" : ""));
            }
            else
            {
                log->Printf("    [ClangASTImporter] To is an %sDecl - attributes %s%s",
                            ((Decl*)to_container_decl)->getDeclKindName(),
                            (to_container_decl->hasExternalLexicalStorage() ? " Lexical" : ""),
                            (to_container_decl->hasExternalVisibleStorage() ? " Visible" : ""));
            }
        }
    }

    return clang::ASTImporter::Imported(from, to);
}

clang::Decl *ClangASTImporter::Minion::GetOriginalDecl (clang::Decl *To)
{
    ASTContextMetadataSP to_context_md = m_master.GetContextMetadata(&To->getASTContext());
    
    if (!to_context_md)
        return nullptr;
    
    OriginMap::iterator iter = to_context_md->m_origins.find(To);
    
    if (iter == to_context_md->m_origins.end())
        return nullptr;
    
    return const_cast<clang::Decl*>(iter->second.decl);
}