[lldb] Remove modern-type-lookup

[teemperor]

Summary

As discussed on the mailing list [1] we have to make a decision for how to proceed with the modern-type-lookup.

This patch removes modern-type-lookup from LLDB. This just removes all the code behind the modern-type-lookup
setting but it does *not* remove any code from Clang (i.e., the ExternalASTMerger and the clang-import-test stay around
for now).

The motivation for this is that I don't think that the current approach of implementing modern-type-lookup
will work out. Especially creating a completely new lookup system behind some setting that is never turned on by anyone
and then one day make one big switch to the new system seems wrong. It doesn't fit into the way LLVM is developed and has
so far made the transition work much more complicated than it has to be.

A lot of the benefits that were supposed to come with the modern-type-lookup are related to having a better organization
in the way types move across LLDB and having less dependencies on unrelated LLDB code. By just looking at the current code (mostly
the ClangASTImporter) I think we can reach the same goals by just incrementally cleaning up, documenting, refactoring
and actually testing the existing code we have.

[1] http://lists.llvm.org/pipermail/lldb-dev/2019-December/015831.html

[teemperor]

@martong I added you as a reviewer because I assume you were interested in that development. I'm curious what you think should happen to the clang-import-test. We could either rewrite the tests as unit tests in the ASTImporterTest you guys are already using or we move the necessary parts of the ExternalASTMerger into the clang-import-test (which will mostly likely just be the lookup code). I leave it up to you guys to decide what should happen with that testing code.

[teemperor]

I'm landing this now as I started the cleanup work for the current lookup code and the modern-type-lookup code is blocking that refactoring.

[martong]

I'm curious what you think should happen to the clang-import-test. We could either rewrite the tests as unit tests in the ASTImporterTest you guys are already using or we move the necessary parts of the ExternalASTMerger into the clang-import-test

Raphael, I think there is no point to keep the clang-import-test and the ExternalASTMerger in Clang if we remove the only user of these things.
So, in my opinion the best would be on a long-term if we could cover these tests with unit tests in ASTImporterTest.
On the other hand, I understand that rewriting these tests could be quite a work, so perhaps we should gradually add the new unit tests and once we are ready then we could remove entirely the clang-import-test and the ExternalASTMerger.
Also, some of the tests are already covered by the existing unit tests, e.g. switch-stmt with ImportSwitch.

lldb/include/lldb/Symbol/ClangASTContext.h

 #include <map>
 #include <memory>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "clang/AST/ASTContext.h"
-#include "clang/AST/ExternalASTMerger.h"
 #include "clang/AST/TemplateBase.h"
 #include "llvm/ADT/APSInt.h"
 #include "llvm/ADT/SmallVector.h"
 
 #include "lldb/Core/ClangForward.h"
 #include "lldb/Expression/ExpressionVariable.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Symbol/TypeSystem.h"
#endif
   GetCanonicalQualType(lldb::opaque_compiler_type_t type) {
     if (type)
       return clang::QualType::getFromOpaquePtr(type).getCanonicalType();
     return clang::QualType();
   }
 
   clang::DeclarationName
   GetDeclarationName(const char *name, const CompilerType &function_clang_type);
-  
-  virtual const clang::ExternalASTMerger::OriginMap &GetOriginMap() {
-    return m_origins;
-  }
 protected:
   const clang::ClassTemplateSpecializationDecl *
   GetAsTemplateSpecialization(lldb::opaque_compiler_type_t type);
 
   // Classes that inherit from ClangASTContext can see and modify these
   std::string m_target_triple;
   std::unique_ptr<clang::ASTContext> m_ast_up;
   std::unique_ptr<clang::LangOptions> m_language_options_up;
   std::unique_ptr<clang::FileManager> m_file_manager_up;
   std::unique_ptr<clang::SourceManager> m_source_manager_up;
   std::unique_ptr<clang::DiagnosticsEngine> m_diagnostics_engine_up;
   std::unique_ptr<clang::DiagnosticConsumer> m_diagnostic_consumer_up;
   std::shared_ptr<clang::TargetOptions> m_target_options_rp;
   std::unique_ptr<clang::TargetInfo> m_target_info_up;
   std::unique_ptr<clang::IdentifierTable> m_identifier_table_up;
   std::unique_ptr<clang::SelectorTable> m_selector_table_up;
   std::unique_ptr<clang::Builtin::Context> m_builtins_up;
   std::unique_ptr<DWARFASTParserClang> m_dwarf_ast_parser_up;
   std::unique_ptr<PDBASTParser> m_pdb_ast_parser_up;
   std::unique_ptr<ClangASTSource> m_scratch_ast_source_up;
   std::unique_ptr<clang::MangleContext> m_mangle_ctx_up;
   CompleteTagDeclCallback m_callback_tag_decl = nullptr;
   CompleteObjCInterfaceDeclCallback m_callback_objc_decl = nullptr;
   void *m_callback_baton = nullptr;
-  clang::ExternalASTMerger::OriginMap m_origins;
   uint32_t m_pointer_byte_size = 0;
   bool m_ast_owned = false;
   /// The sema associated that is currently used to build this ASTContext.
   /// May be null if we are already done parsing this ASTContext or the
   /// ASTContext wasn't created by parsing source code.
   clang::Sema *m_sema = nullptr;
 
 private:
FunctionCaller *GetFunctionCaller(const CompilerType &return_type,
                                     const Address &function_address,
                                     const ValueList &arg_value_list,
                                     const char *name) override;
 
   UtilityFunction *GetUtilityFunction(const char *text,
                                       const char *name) override;
 
   PersistentExpressionState *GetPersistentExpressionState() override;
-  
-  clang::ExternalASTMerger &GetMergerUnchecked();
-  
-  const clang::ExternalASTMerger::OriginMap &GetOriginMap() override {
-    return GetMergerUnchecked().GetOrigins();
-  }
 private:
   lldb::TargetWP m_target_wp;
   std::unique_ptr<PersistentExpressionState>
       m_persistent_variables; // These are the persistent variables associated
                               // with this process for the expression parser
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_ClangASTContext_h_

lldb/include/lldb/Target/Target.h

public:
   const ProcessLaunchInfo &GetProcessLaunchInfo();
 
   void SetProcessLaunchInfo(const ProcessLaunchInfo &launch_info);
 
   bool GetInjectLocalVariables(ExecutionContext *exe_ctx) const;
 
   void SetInjectLocalVariables(ExecutionContext *exe_ctx, bool b);
 
-  bool GetUseModernTypeLookup() const;
-
   void SetRequireHardwareBreakpoints(bool b);
 
   bool GetRequireHardwareBreakpoints() const;
 
 private:
   // Callbacks for m_launch_info.
   static void Arg0ValueChangedCallback(void *target_property_ptr,
                                        OptionValue *);

lldb/packages/Python/lldbsuite/test/functionalities/modern-type-lookup/basic-objc/Makefile

-OBJC_SOURCES := main.m
-LD_EXTRAS := -lobjc -framework Foundation
-
-include Makefile.rules

lldb/packages/Python/lldbsuite/test/functionalities/modern-type-lookup/basic-objc/TestBasicObjcModernTypeLookup.py

-import lldb
-from lldbsuite.test.decorators import *
-from lldbsuite.test.lldbtest import *
-from lldbsuite.test import lldbutil
-
-class TestBasicObjcModernTypeLookup(TestBase):
-  mydir = TestBase.compute_mydir(__file__)
-
-  @skipUnlessDarwin
-  def test(self):
-    self.build()
-    # Activate modern-type-lookup.
-    # FIXME: This has to happen before we create any target otherwise we crash...
-    self.runCmd("settings set target.experimental.use-modern-type-lookup true")
-    (target, process, thread, main_breakpoint) = lldbutil.run_to_source_breakpoint(self,
-          "break here", lldb.SBFileSpec("main.m"))
-    self.expect("expr 1", substrs=["(int) ", " = 1"])
-    self.expect("expr (int)[Foo bar:22]", substrs=["(int) ", " = 44"])

lldb/packages/Python/lldbsuite/test/functionalities/modern-type-lookup/basic-objc/main.m

-#import <Foundation/Foundation.h>
-
-@interface Foo : NSObject
-+(int) bar: (int) string;
-@end
-
-@implementation Foo
-+(int) bar: (int) x
-{
-  return x + x;
-}
-@end
-
-int main() {
-  NSLog(@"Hello World");
-  return 0; // break here
-}

lldb/packages/Python/lldbsuite/test/functionalities/modern-type-lookup/basic/Makefile

-CXX_SOURCES := main.cpp
-include Makefile.rules

lldb/packages/Python/lldbsuite/test/functionalities/modern-type-lookup/basic/TestBasicModernTypeLookup.py

-from lldbsuite.test.decorators import *
-from lldbsuite.test.lldbtest import *
-from lldbsuite.test import lldbutil
-
-class BasicModernTypeLookup(TestBase):
-
-    mydir = TestBase.compute_mydir(__file__)
-
-    def test(self):
-        self.build()
-
-        # Activate modern-type-lookup.
-        self.runCmd("settings set target.experimental.use-modern-type-lookup true")
-
-        lldbutil.run_to_source_breakpoint(self,
-            "// Set break point at this line.", lldb.SBFileSpec("main.cpp"))
-
-        # Test a few simple expressions that should still work with modern-type-lookup.
-        self.expect("expr 1", substrs=["(int) ", " = 1\n"])
-        self.expect("expr f.x", substrs=["(int) ", " = 44\n"])
-        self.expect("expr f", substrs=["(Foo) ", "x = 44"])

lldb/packages/Python/lldbsuite/test/functionalities/modern-type-lookup/basic/main.cpp

-struct Foo { int x; };
-
-int main(int argc, char **argv) {
-  Foo f;
-  f.x = 44;
-  return f.x; // Set break point at this line.
-}

lldb/packages/Python/lldbsuite/test/functionalities/modern-type-lookup/libcxx/Makefile

-CXX_SOURCES := main.cpp
-USE_LIBCPP := 1
-include Makefile.rules

lldb/packages/Python/lldbsuite/test/functionalities/modern-type-lookup/libcxx/TestLibCxxModernTypeLookup.py

-from lldbsuite.test.decorators import *
-from lldbsuite.test.lldbtest import *
-from lldbsuite.test import lldbutil
-
-class LibcxxModernTypeLookup(TestBase):
-
-    mydir = TestBase.compute_mydir(__file__)
-
-    @add_test_categories(["libc++"])
-    def test(self):
-        self.build()
-
-        # Activate modern-type-lookup.
-        self.runCmd("settings set target.experimental.use-modern-type-lookup true")
-
-        lldbutil.run_to_source_breakpoint(self,
-            "// Set break point at this line.", lldb.SBFileSpec("main.cpp"))
-
-        # Test a few simple expressions that should still work with modern-type-lookup.
-        self.expect("expr pair", substrs=["(std::", "pair<int, long", "= (first = 1, second = 2)"])
-        self.expect("expr foo", substrs=["(std::", "string", "\"bar\""])
-        self.expect("expr map", substrs=["(std::", "map", "first = 1, second = 2"])
-        self.expect("expr umap", substrs=["(std::", "unordered_map", "first = 1, second = 2"])

lldb/packages/Python/lldbsuite/test/functionalities/modern-type-lookup/libcxx/main.cpp

-#include <utility>
-#include <string>
-#include <map>
-#include <unordered_map>
-
-int main(int argc, char **argv) {
-  std::pair<int, long> pair = std::make_pair<int, float>(1, 2L);
-  std::string foo = "bar";
-  std::map<int, int> map;
-  map[1] = 2;
-  std::unordered_map<int, int> umap;
-  umap[1] = 2;
-  return pair.first; // Set break point at this line.
-}

lldb/packages/Python/lldbsuite/test/functionalities/modern-type-lookup/objc-modules/Makefile

-OBJC_SOURCES := main.m
-LD_EXTRAS := -lobjc -framework Foundation
-
-include Makefile.rules

lldb/packages/Python/lldbsuite/test/functionalities/modern-type-lookup/objc-modules/TestObjModulesModernTypeLookup.py

-import lldb
-from lldbsuite.test.decorators import *
-from lldbsuite.test.lldbtest import *
-from lldbsuite.test import lldbutil
-
-class TestObjcModulesModernTypeLookup(TestBase):
-  mydir = TestBase.compute_mydir(__file__)
-
-  @skipUnlessDarwin
-  # gmodules causes this to crash as we seem to get a NSURL type from the debug information.
-  @skipIf(debug_info="gmodules")
-  def test(self):
-    self.build()
-    # Activate modern-type-lookup.
-    # FIXME: This has to happen before we create any target otherwise we crash...
-    self.runCmd("settings set target.experimental.use-modern-type-lookup true")
-    (target, process, thread, main_breakpoint) = lldbutil.run_to_source_breakpoint(self,
-          "break here", lldb.SBFileSpec("main.m"))
-    self.expect("expr @import Foundation")
-    self.expect(
-            "p *[NSURL URLWithString:@\"http://lldb.llvm.org\"]",
-            VARIABLES_DISPLAYED_CORRECTLY,
-            substrs=[
-                "NSURL",
-                "isa",
-                "_urlString"])

lldb/packages/Python/lldbsuite/test/functionalities/modern-type-lookup/objc-modules/main.m

-#import <Foundation/Foundation.h>
-
-int main() {
-  NSLog(@"Hello World");
-  return 0; // break here
-}

lldb/source/Plugins/ExpressionParser/Clang/ClangASTSource.h

 #define liblldb_ClangASTSource_h_
 
 #include <set>
 
 #include "lldb/Symbol/ClangASTImporter.h"
 #include "lldb/Symbol/ClangExternalASTSourceCommon.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Target/Target.h"
-#include "clang/AST/ExternalASTMerger.h"
 #include "clang/Basic/IdentifierTable.h"
 
 #include "llvm/ADT/SmallSet.h"
 
 namespace lldb_private {
 
 /// \class ClangASTSource ClangASTSource.h "lldb/Expression/ClangASTSource.h"
 /// Provider for named objects defined in the debug info for Clang
public:
   ///
   /// \param[in] src_decl
   ///     The Decl to copy.
   ///
   /// \return
   ///     A copy of the Decl in m_ast_context, or NULL if the copy failed.
   clang::Decl *CopyDecl(clang::Decl *src_decl);
 
-  /// Copies a single Type to the target of the given ExternalASTMerger.
-  ///
-  /// \param[in] src_context
-  ///     The ASTContext containing the type.
-  ///
-  /// \param[in] merger
-  ///     The merger to use.  This isn't just *m_merger_up because it might be
-  ///     the persistent AST context's merger.
-  ///
-  /// \param[in] type
-  ///     The type to copy.
-  ///
-  /// \return
-  ///     A copy of the Type in the merger's target context.
-  clang::QualType CopyTypeWithMerger(clang::ASTContext &src_context,
-                                     clang::ExternalASTMerger &merger,
-                                     clang::QualType type);
-
   /// Determined the origin of a single Decl, if it can be found.
   ///
   /// \param[in] decl
   ///     The Decl whose origin is to be found.
   ///
   /// \param[out] original_decl
   ///     A pointer whose target is filled in with the original Decl.
   ///
   /// \param[in] original_ctx
   ///     A pointer whose target is filled in with the original's ASTContext.
   ///
   /// \return
   ///     True if lookup succeeded; false otherwise.
   ClangASTImporter::DeclOrigin GetDeclOrigin(const clang::Decl *decl);
 
-  /// Returns m_merger_up.  Only call this if the target is configured to use
-  /// modern lookup,
-  clang::ExternalASTMerger &GetMergerUnchecked();
-
-  /// Returns true if there is a merger.  This only occurs if the target is
-  /// using modern lookup.
-  bool HasMerger() { return (bool)m_merger_up; }
-
 protected:
   bool FindObjCMethodDeclsWithOrigin(
       unsigned int current_id, NameSearchContext &context,
       clang::ObjCInterfaceDecl *original_interface_decl, const char *log_info);
 
   friend struct NameSearchContext;
 
   bool m_import_in_progress;
   bool m_lookups_enabled;
 
   /// The target to use in finding variables and types.
   const lldb::TargetSP m_target;
   /// The AST context requests are coming in for.
   clang::ASTContext *m_ast_context;
   /// The ClangASTContext for m_ast_context.
   ClangASTContext *m_clang_ast_context;
   /// The file manager paired with the AST context.
   clang::FileManager *m_file_manager;
   /// The target's AST importer.
   lldb::ClangASTImporterSP m_ast_importer_sp;
-  /// The ExternalASTMerger for this parse.
-  std::unique_ptr<clang::ExternalASTMerger> m_merger_up;
   std::set<const clang::Decl *> m_active_lexical_decls;
   std::set<const char *> m_active_lookups;
 };
 
 /// \class NameSearchContext ClangASTSource.h
 /// "lldb/Expression/ClangASTSource.h" Container for all objects relevant to a
 /// single name lookup
 ///

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

private:
   std::set<const clang::Decl *> &m_active_lexical_decls;
   const clang::Decl *m_decl;
 };
 }
 
 ClangASTSource::ClangASTSource(const lldb::TargetSP &target)
     : m_import_in_progress(false), m_lookups_enabled(false), m_target(target),
       m_ast_context(nullptr), m_active_lexical_decls(), m_active_lookups() {
-  if (!target->GetUseModernTypeLookup()) {
-    m_ast_importer_sp = m_target->GetClangASTImporter();
-  }
-}
 
 void ClangASTSource::InstallASTContext(ClangASTContext &clang_ast_context,
                                        clang::FileManager &file_manager,
                                        bool is_shared_context) {
   m_ast_context = clang_ast_context.getASTContext();
   m_clang_ast_context = &clang_ast_context;
   m_file_manager = &file_manager;
-  if (m_target->GetUseModernTypeLookup()) {
-    // Configure the ExternalASTMerger.  The merger needs to be able to import
-    // types from any source that we would do lookups in, which includes the
-    // persistent AST context as well as the modules and Objective-C runtime
-    // AST contexts.
-
-    lldbassert(!m_merger_up);
-    clang::ExternalASTMerger::ImporterTarget target = {*m_ast_context,
-                                                       file_manager};
-    std::vector<clang::ExternalASTMerger::ImporterSource> sources;
-    for (lldb::ModuleSP module_sp : m_target->GetImages().Modules()) {
-      auto type_system_or_err =
-          module_sp->GetTypeSystemForLanguage(lldb::eLanguageTypeC);
-      if (auto err = type_system_or_err.takeError()) {
-        LLDB_LOG_ERROR(
-            lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_EXPRESSIONS),
-            std::move(err), "Failed to get ClangASTContext");
-      } else if (auto *module_ast_ctx = llvm::cast_or_null<ClangASTContext>(
-                     &type_system_or_err.get())) {
-        lldbassert(module_ast_ctx->getASTContext());
-        lldbassert(module_ast_ctx->getFileManager());
-        sources.emplace_back(*module_ast_ctx->getASTContext(),
-                             *module_ast_ctx->getFileManager(),
-                             module_ast_ctx->GetOriginMap());
-      }
-    }
-
-    do {
-      lldb::ProcessSP process(m_target->GetProcessSP());
-
-      if (!process)
-        break;
-
-      ObjCLanguageRuntime *language_runtime(ObjCLanguageRuntime::Get(*process));
-
-      if (!language_runtime)
-        break;
-
-      if (auto *runtime_decl_vendor = llvm::dyn_cast_or_null<ClangDeclVendor>(
-              language_runtime->GetDeclVendor())) {
-        sources.push_back(runtime_decl_vendor->GetImporterSource());
-      }
-    } while (false);
-
-    do {
-      auto *modules_decl_vendor = m_target->GetClangModulesDeclVendor();
-
-      if (!modules_decl_vendor)
-        break;
-
-      sources.push_back(modules_decl_vendor->GetImporterSource());
-    } while (false);
-
-    if (!is_shared_context) {
-      // Update the scratch AST context's merger to reflect any new sources we
-      // might have come across since the last time an expression was parsed.
-
-      if (auto *clang_ast_context = ClangASTContext::GetScratch(*m_target)) {
-
-        auto scratch_ast_context =
-            static_cast<ClangASTContextForExpressions *>(clang_ast_context);
-
-        scratch_ast_context->GetMergerUnchecked().AddSources(sources);
-
-        sources.push_back({*scratch_ast_context->getASTContext(),
-                           *scratch_ast_context->getFileManager(),
-                           scratch_ast_context->GetOriginMap()});
-      }
-    }
-
-    m_merger_up =
-        std::make_unique<clang::ExternalASTMerger>(target, sources);
-  } else {
-    m_ast_importer_sp->InstallMapCompleter(m_ast_context, *this);
-  }
-}
 
 ClangASTSource::~ClangASTSource() {
   if (m_ast_importer_sp)
     m_ast_importer_sp->ForgetDestination(m_ast_context);
 
   // We are in the process of destruction, don't create clang ast context on
   // demand by passing false to
   // Target::GetScratchClangASTContext(create_on_demand).
void ClangASTSource::CompleteType(TagDecl *tag_decl) {
 
   auto iter = m_active_lexical_decls.find(tag_decl);
   if (iter != m_active_lexical_decls.end())
     return;
   m_active_lexical_decls.insert(tag_decl);
   ScopedLexicalDeclEraser eraser(m_active_lexical_decls, tag_decl);
 
   if (!m_ast_importer_sp) {
-    if (HasMerger()) {
-      GetMergerUnchecked().CompleteType(tag_decl);
-    }
     return;
   }
 
   if (!m_ast_importer_sp->CompleteTagDecl(tag_decl)) {
     // We couldn't complete the type.  Maybe there's a definition somewhere
     // else that can be completed.
 
     LLDB_LOGF(log,
LLDB_LOGF(log,
             "    [CompleteObjCInterfaceDecl] on (ASTContext*)%p Completing "
             "an ObjCInterfaceDecl named %s",
             static_cast<void *>(m_ast_context),
             interface_decl->getName().str().c_str());
   LLDB_LOG(log, "      [COID] Before:\n{0}",
            ClangUtil::DumpDecl(interface_decl));
 
   if (!m_ast_importer_sp) {
-    if (HasMerger()) {
-      ObjCInterfaceDecl *complete_iface_decl =
-        GetCompleteObjCInterface(interface_decl);
-
-      if (complete_iface_decl && (complete_iface_decl != interface_decl)) {
-        m_merger_up->ForceRecordOrigin(interface_decl, {complete_iface_decl, &complete_iface_decl->getASTContext()});
-      }
-
-      GetMergerUnchecked().CompleteType(interface_decl);
-    } else {
-      lldbassert(0 && "No mechanism for completing a type!");
-    }
     return;
   }
 
   ClangASTImporter::DeclOrigin original = m_ast_importer_sp->GetDeclOrigin(interface_decl);
 
   if (original.Valid()) {
     if (ObjCInterfaceDecl *original_iface_decl =
             dyn_cast<ObjCInterfaceDecl>(original.decl)) {
clang::ObjCInterfaceDecl *ClangASTSource::GetCompleteObjCInterface(
   return complete_iface_decl;
 }
 
 void ClangASTSource::FindExternalLexicalDecls(
     const DeclContext *decl_context,
     llvm::function_ref<bool(Decl::Kind)> predicate,
     llvm::SmallVectorImpl<Decl *> &decls) {
 
-  if (HasMerger()) {
-    if (auto *interface_decl = dyn_cast<ObjCInterfaceDecl>(decl_context)) {
-      ObjCInterfaceDecl *complete_iface_decl =
-         GetCompleteObjCInterface(interface_decl);
-
-      if (complete_iface_decl && (complete_iface_decl != interface_decl)) {
-        m_merger_up->ForceRecordOrigin(interface_decl, {complete_iface_decl, &complete_iface_decl->getASTContext()});
-      }
-    }
-    return GetMergerUnchecked().FindExternalLexicalDecls(decl_context,
-                                                         predicate,
-                                                         decls);
-  } else if (!m_ast_importer_sp)
+  if (!m_ast_importer_sp)
     return;
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
   const Decl *context_decl = dyn_cast<Decl>(decl_context);
 
   if (!context_decl)
     return;
if (log) {
     else
       LLDB_LOGF(log,
                 "ClangASTSource::FindExternalVisibleDecls[%u] on "
                 "(ASTContext*)%p for '%s' in a '%s'",
                 current_id, static_cast<void *>(m_ast_context),
                 name.GetCString(), context.m_decl_context->getDeclKindName());
   }
 
-  if (HasMerger() && !isa<TranslationUnitDecl>(context.m_decl_context)
-      /* possibly handle NamespaceDecls here? */) {
-    if (auto *interface_decl =
-    dyn_cast<ObjCInterfaceDecl>(context.m_decl_context)) {
-      ObjCInterfaceDecl *complete_iface_decl =
-      GetCompleteObjCInterface(interface_decl);
-
-      if (complete_iface_decl && (complete_iface_decl != interface_decl)) {
-        GetMergerUnchecked().ForceRecordOrigin(
-            interface_decl,
-            {complete_iface_decl, &complete_iface_decl->getASTContext()});
-      }
-    }
-
-    GetMergerUnchecked().FindExternalVisibleDeclsByName(context.m_decl_context,
-                                                context.m_decl_name);
-    return; // otherwise we may need to fall back
-  }
-
   context.m_namespace_map = std::make_shared<ClangASTImporter::NamespaceMap>();
 
   if (const NamespaceDecl *namespace_context =
           dyn_cast<NamespaceDecl>(context.m_decl_context)) {
     ClangASTImporter::NamespaceMapSP namespace_map =  m_ast_importer_sp ?
         m_ast_importer_sp->GetNamespaceMap(namespace_context) : nullptr;
 
     if (log && log->GetVerbose())
       LLDB_LOGF(log, "  CAS::FEVD[%u] Inspecting namespace map %p (%d entries)",
                 current_id, static_cast<void *>(namespace_map.get()),
                 static_cast<int>(namespace_map->size()));
 
     if (!namespace_map)
       return;
 
     for (ClangASTImporter::NamespaceMap::iterator i = namespace_map->begin(),
                                                   e = namespace_map->end();
          i != e; ++i) {
       LLDB_LOGF(log, "  CAS::FEVD[%u] Searching namespace %s in module %s",
                 current_id, i->second.GetName().AsCString(),
                 i->first->GetFileSpec().GetFilename().GetCString());
 
       FindExternalVisibleDecls(context, i->first, i->second, current_id);
     }
-  } else if (isa<ObjCInterfaceDecl>(context.m_decl_context) && !HasMerger()) {
+  } else if (isa<ObjCInterfaceDecl>(context.m_decl_context)) {
     FindObjCPropertyAndIvarDecls(context);
   } else if (!isa<TranslationUnitDecl>(context.m_decl_context)) {
     // we shouldn't be getting FindExternalVisibleDecls calls for these
     return;
   } else {
     CompilerDeclContext namespace_decl;
 
     LLDB_LOGF(log, "  CAS::FEVD[%u] Searching the root namespace", current_id);
if (SymbolFile *symbol_file = module_sp->GetSymbolFile()) {
             std::pair<lldb::ModuleSP, CompilerDeclContext>(
                 module_sp, found_namespace_decl));
 
         LLDB_LOGF(log, "  CAS::FEVD[%u] Found namespace %s in module %s",
                   current_id, name.GetCString(),
                   module_sp->GetFileSpec().GetFilename().GetCString());
       }
     }
-  } else if (!HasMerger()) {
+  } else {
     const ModuleList &target_images = m_target->GetImages();
     std::lock_guard<std::recursive_mutex> guard(target_images.GetMutex());
 
     for (size_t i = 0, e = target_images.GetSize(); i < e; ++i) {
       lldb::ModuleSP image = target_images.GetModuleAtIndexUnlocked(i);
 
       if (!image)
         continue;
bool ClangASTSource::FindObjCMethodDeclsWithOrigin(
   }
 
   return true;
 }
 
 void ClangASTSource::FindObjCMethodDecls(NameSearchContext &context) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
-  if (HasMerger()) {
-    if (auto *interface_decl = dyn_cast<ObjCInterfaceDecl>(context.m_decl_context)) {
-      ObjCInterfaceDecl *complete_iface_decl =
-          GetCompleteObjCInterface(interface_decl);
-
-      if (complete_iface_decl && (complete_iface_decl != context.m_decl_context)) {
-        m_merger_up->ForceRecordOrigin(interface_decl, {complete_iface_decl, &complete_iface_decl->getASTContext()});
-      }
-    }
-
-    GetMergerUnchecked().FindExternalVisibleDeclsByName(context.m_decl_context,
-                                                        context.m_decl_name);
-    return;
-  }
-
   static unsigned int invocation_id = 0;
   unsigned int current_id = invocation_id++;
 
   const DeclarationName &decl_name(context.m_decl_name);
   const DeclContext *decl_ctx(context.m_decl_context);
 
   const ObjCInterfaceDecl *interface_decl =
       dyn_cast<ObjCInterfaceDecl>(decl_ctx);
NamespaceDecl *ClangASTSource::AddNamespace(
   context.m_decls.push_back(copied_namespace_decl);
 
   m_ast_importer_sp->RegisterNamespaceMap(copied_namespace_decl,
                                           namespace_decls);
 
   return dyn_cast<NamespaceDecl>(copied_decl);
 }
 
-clang::QualType ClangASTSource::CopyTypeWithMerger(
-    clang::ASTContext &from_context,
-    clang::ExternalASTMerger &merger,
-    clang::QualType type) {
-  if (!merger.HasImporterForOrigin(from_context)) {
-    lldbassert(0 && "Couldn't find the importer for a source context!");
-    return QualType();
-  }
-
-  if (llvm::Expected<QualType> type_or_error =
-          merger.ImporterForOrigin(from_context).Import(type)) {
-    return *type_or_error;
-  } else {
-    Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS);
-    LLDB_LOG_ERROR(log, type_or_error.takeError(), "Couldn't import type: {0}");
-    return QualType();
-  }
-}
-
 clang::Decl *ClangASTSource::CopyDecl(Decl *src_decl) {
   clang::ASTContext &from_context = src_decl->getASTContext();
   if (m_ast_importer_sp) {
     return m_ast_importer_sp->CopyDecl(m_ast_context, &from_context, src_decl);
-  } else if (m_merger_up) {
-    if (!m_merger_up->HasImporterForOrigin(from_context)) {
-      lldbassert(0 && "Couldn't find the importer for a source context!");
-      return nullptr;
-    }
-
-    if (llvm::Expected<Decl *> decl_or_error =
-            m_merger_up->ImporterForOrigin(from_context).Import(src_decl)) {
-      return *decl_or_error;
-    } else {
-      Log *log =
-          lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS);
-      LLDB_LOG_ERROR(log, decl_or_error.takeError(),
-                     "Couldn't import decl: {0}");
-      return nullptr;
-    }
   } else {
     lldbassert(0 && "No mechanism for copying a decl!");
     return nullptr;
   }
 }
 
 ClangASTImporter::DeclOrigin ClangASTSource::GetDeclOrigin(const clang::Decl *decl) {
   if (m_ast_importer_sp) {
     return m_ast_importer_sp->GetDeclOrigin(decl);
-  } else if (m_merger_up) {
-    return ClangASTImporter::DeclOrigin(); // Implement this correctly in ExternalASTMerger
   } else {
     // this can happen early enough that no ExternalASTSource is installed.
     return ClangASTImporter::DeclOrigin();
   }
 }
 
-clang::ExternalASTMerger &ClangASTSource::GetMergerUnchecked() {
-  lldbassert(m_merger_up != nullptr);
-  return *m_merger_up;
-}
-
 CompilerType ClangASTSource::GuardedCopyType(const CompilerType &src_type) {
   ClangASTContext *src_ast =
       llvm::dyn_cast_or_null<ClangASTContext>(src_type.GetTypeSystem());
   if (src_ast == nullptr)
     return CompilerType();
 
   SetImportInProgress(true);
 
   QualType copied_qual_type;
 
   if (m_ast_importer_sp) {
     copied_qual_type = ClangUtil::GetQualType(
         m_ast_importer_sp->CopyType(*m_clang_ast_context, src_type));
-  } else if (m_merger_up) {
-    copied_qual_type =
-        CopyTypeWithMerger(*src_ast->getASTContext(), *m_merger_up,
-                 ClangUtil::GetQualType(src_type));
   } else {
     lldbassert(0 && "No mechanism for copying a type!");
     return CompilerType();
   }
 
   SetImportInProgress(false);
 
   if (copied_qual_type.getAsOpaquePtr() &&

lldb/source/Plugins/ExpressionParser/Clang/ClangDeclVendor.h

 //===-- ClangDeclVendor.h ---------------------------------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_ClangDeclVendor_h_
 #define liblldb_ClangDeclVendor_h_
 
 #include "lldb/Core/ClangForward.h"
 #include "lldb/Symbol/DeclVendor.h"
 
-#include "clang/AST/ExternalASTMerger.h"
-
 namespace lldb_private {
 
 // A clang specialized extension to DeclVendor.
 class ClangDeclVendor : public DeclVendor {
 public:
   ClangDeclVendor(DeclVendorKind kind) : DeclVendor(kind) {}
 
   virtual ~ClangDeclVendor() {}
 
-  /// Interface for ExternalASTMerger. Returns an ImporterSource allowing type
-  /// completion.
-  ///
-  /// \return
-  ///     An ImporterSource for this ClangDeclVendor.
-  virtual clang::ExternalASTMerger::ImporterSource GetImporterSource() = 0;
-
   uint32_t FindDecls(ConstString name, bool append, uint32_t max_matches,
                      std::vector<CompilerDecl> &decls) override;
 
   virtual uint32_t FindDecls(ConstString name, bool append,
                              uint32_t max_matches,
                              std::vector<clang::NamedDecl *> &decls) = 0;
 
   static bool classof(const DeclVendor *vendor) {

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp

if (target) {
       ret.byte_order = target->GetArchitecture().GetByteOrder();
       ret.address_byte_size = target->GetArchitecture().GetAddressByteSize();
     }
   }
 
   return ret;
 }
 
-static clang::QualType ExportAllDeclaredTypes(
-    clang::ExternalASTMerger &parent_merger, clang::ExternalASTMerger &merger,
-    clang::ASTContext &source, clang::FileManager &source_file_manager,
-    const clang::ExternalASTMerger::OriginMap &source_origin_map,
-    clang::FileID file, clang::QualType root) {
-  // Mark the source as temporary to make sure all declarations from the
-  // AST are exported. Also add the parent_merger as the merger into the
-  // source AST so that the merger can track back any declarations from
-  // the persistent ASTs we used as sources.
-  clang::ExternalASTMerger::ImporterSource importer_source(
-      source, source_file_manager, source_origin_map, /*Temporary*/ true,
-      &parent_merger);
-  merger.AddSources(importer_source);
-  clang::ASTImporter &exporter = merger.ImporterForOrigin(source);
-  llvm::Expected<clang::QualType> ret_or_error = exporter.Import(root);
-  merger.RemoveSources(importer_source);
-  if (ret_or_error) {
-    return *ret_or_error;
-  } else {
-    Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS);
-    LLDB_LOG_ERROR(log, ret_or_error.takeError(), "Couldn't import type: {0}");
-    return clang::QualType();
-  }
-}
-
 TypeFromUser ClangExpressionDeclMap::DeportType(ClangASTContext &target,
                                                 ClangASTContext &source,
                                                 TypeFromParser parser_type) {
   assert(&target == ClangASTContext::GetScratch(*m_target));
   assert((TypeSystem *)&source == parser_type.GetTypeSystem());
   assert(source.getASTContext() == m_ast_context);
 
   if (m_ast_importer_sp) {
     return TypeFromUser(m_ast_importer_sp->DeportType(target, parser_type));
-  } else if (m_merger_up) {
-    clang::FileID source_file =
-        source.getASTContext()->getSourceManager().getFileID(
-            source.getASTContext()->getTranslationUnitDecl()->getLocation());
-    auto scratch_ast_context = static_cast<ClangASTContextForExpressions *>(
-        ClangASTContext::GetScratch(*m_target));
-    clang::QualType exported_type = ExportAllDeclaredTypes(
-        *m_merger_up.get(), scratch_ast_context->GetMergerUnchecked(),
-        *source.getASTContext(), *source.getFileManager(),
-        m_merger_up->GetOrigins(), source_file,
-        clang::QualType::getFromOpaquePtr(parser_type.GetOpaqueQualType()));
-    return TypeFromUser(exported_type.getAsOpaquePtr(), &target);
   } else {
     lldbassert(0 && "No mechanism for deporting a type!");
     return TypeFromUser();
   }
 }
 
 bool ClangExpressionDeclMap::AddPersistentVariable(const NamedDecl *decl,
                                                    ConstString name,

lldb/source/Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.cpp

public:
   bool AddModulesForCompileUnit(CompileUnit &cu, ModuleVector &exported_modules,
                                 Stream &error_stream) override;
 
   uint32_t FindDecls(ConstString name, bool append, uint32_t max_matches,
                      std::vector<clang::NamedDecl *> &decls) override;
 
   void ForEachMacro(const ModuleVector &modules,
                     std::function<bool(const std::string &)> handler) override;
-
-  clang::ExternalASTMerger::ImporterSource GetImporterSource() override;
 private:
   void
   ReportModuleExportsHelper(std::set<ClangModulesDeclVendor::ModuleID> &exports,
                             clang::Module *module);
 
   void ReportModuleExports(ModuleVector &exports, clang::Module *module);
 
   clang::ModuleLoadResult DoGetModule(clang::ModuleIdPath path,
                                       bool make_visible);
 
   bool m_enabled = false;
 
   llvm::IntrusiveRefCntPtr<clang::DiagnosticsEngine> m_diagnostics_engine;
   std::shared_ptr<clang::CompilerInvocation> m_compiler_invocation;
   std::unique_ptr<clang::CompilerInstance> m_compiler_instance;
   std::unique_ptr<clang::Parser> m_parser;
   size_t m_source_location_index =
       0; // used to give name components fake SourceLocations
 
   typedef std::vector<ConstString> ImportedModule;
   typedef std::map<ImportedModule, clang::Module *> ImportedModuleMap;
   typedef std::set<ModuleID> ImportedModuleSet;
   ImportedModuleMap m_imported_modules;
   ImportedModuleSet m_user_imported_modules;
-  const clang::ExternalASTMerger::OriginMap m_origin_map;
   // We assume that every ASTContext has an ClangASTContext, so we also store
   // a custom ClangASTContext for our internal ASTContext.
   std::unique_ptr<ClangASTContext> m_ast_context;
 };
 } // anonymous namespace
 
 StoringDiagnosticConsumer::StoringDiagnosticConsumer() {
   m_log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS);

 ClangModulesDeclVendorImpl::ClangModulesDeclVendorImpl(
     llvm::IntrusiveRefCntPtr<clang::DiagnosticsEngine> diagnostics_engine,
     std::shared_ptr<clang::CompilerInvocation> compiler_invocation,
     std::unique_ptr<clang::CompilerInstance> compiler_instance,
     std::unique_ptr<clang::Parser> parser)
     : m_diagnostics_engine(std::move(diagnostics_engine)),
       m_compiler_invocation(std::move(compiler_invocation)),
       m_compiler_instance(std::move(compiler_instance)),
-      m_parser(std::move(parser)), m_origin_map() {
+      m_parser(std::move(parser)) {
 
   // Initialize our ClangASTContext.
   m_ast_context.reset(new ClangASTContext(m_compiler_instance->getASTContext()));
 }
 
 void ClangModulesDeclVendorImpl::ReportModuleExportsHelper(
     std::set<ClangModulesDeclVendor::ModuleID> &exports,
     clang::Module *module) {
clang::Module::NameVisibilityKind visibility =
       make_visible ? clang::Module::AllVisible : clang::Module::Hidden;
 
   const bool is_inclusion_directive = false;
 
   return m_compiler_instance->loadModule(path.front().second, path, visibility,
                                          is_inclusion_directive);
 }
 
-clang::ExternalASTMerger::ImporterSource
-ClangModulesDeclVendorImpl::GetImporterSource() {
-  return clang::ExternalASTMerger::ImporterSource(
-      m_compiler_instance->getASTContext(),
-      m_compiler_instance->getFileManager(), m_origin_map);
-}
-
 static const char *ModuleImportBufferName = "LLDBModulesMemoryBuffer";
 
 lldb_private::ClangModulesDeclVendor *
 ClangModulesDeclVendor::Create(Target &target) {
   // FIXME we should insure programmatically that the expression parser's
   // compiler and the modules runtime's
   // compiler are both initialized in the same way – preferably by the same
   // code.

lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCDeclVendor.h

public:
 
   static bool classof(const DeclVendor *vendor) {
     return vendor->GetKind() == eAppleObjCDeclVendor;
   }
 
   uint32_t FindDecls(ConstString name, bool append, uint32_t max_matches,
                      std::vector<clang::NamedDecl *> &decls) override;
 
-  clang::ExternalASTMerger::ImporterSource GetImporterSource() override;
-
   friend class AppleObjCExternalASTSource;
 
 private:
   clang::ObjCInterfaceDecl *GetDeclForISA(ObjCLanguageRuntime::ObjCISA isa);
   bool FinishDecl(clang::ObjCInterfaceDecl *decl);
 
   ObjCLanguageRuntime &m_runtime;
   ClangASTContext m_ast_ctx;

lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCDeclVendor.cpp

do {
 
     decls.push_back(iface_decl);
     ret++;
     break;
   } while (false);
 
   return ret;
 }
-
-clang::ExternalASTMerger::ImporterSource
-AppleObjCDeclVendor::GetImporterSource() {
-  return clang::ExternalASTMerger::ImporterSource(*m_ast_ctx.getASTContext(),
-                                                  *m_ast_ctx.getFileManager(),
-                                                  m_ast_ctx.GetOriginMap());
-}

lldb/source/Symbol/ClangASTContext.cpp

ClangASTContextForExpressions::GetUtilityFunction(const char *text,
 
   return new ClangUtilityFunction(*target_sp.get(), text, name);
 }
 
 PersistentExpressionState *
 ClangASTContextForExpressions::GetPersistentExpressionState() {
   return m_persistent_variables.get();
 }
-
-clang::ExternalASTMerger &
-ClangASTContextForExpressions::GetMergerUnchecked() {
-  lldbassert(m_scratch_ast_source_up != nullptr);
-  return m_scratch_ast_source_up->GetMergerUnchecked();
-}

lldb/source/Target/Target.cpp

const Property *exp_property =
       m_collection_sp->GetPropertyAtIndex(exe_ctx, true, ePropertyExperimental);
   OptionValueProperties *exp_values =
       exp_property->GetValue()->GetAsProperties();
   if (exp_values)
     exp_values->SetPropertyAtIndexAsBoolean(exe_ctx, ePropertyInjectLocalVars,
                                             true);
 }
 
-bool TargetProperties::GetUseModernTypeLookup() const {
-  const Property *exp_property = m_collection_sp->GetPropertyAtIndex(
-      nullptr, false, ePropertyExperimental);
-  OptionValueProperties *exp_values =
-      exp_property->GetValue()->GetAsProperties();
-  if (exp_values)
-    return exp_values->GetPropertyAtIndexAsBoolean(
-        nullptr, ePropertyUseModernTypeLookup, true);
-  else
-    return true;
-}
-
 ArchSpec TargetProperties::GetDefaultArchitecture() const {
   OptionValueArch *value = m_collection_sp->GetPropertyAtIndexAsOptionValueArch(
       nullptr, ePropertyDefaultArch);
   if (value)
     return value->GetCurrentValue();
   return ArchSpec();
 }
 

lldb/source/Target/TargetProperties.td

 include "../../include/lldb/Core/PropertiesBase.td"
 
 let Definition = "experimental" in {
   def InjectLocalVars : Property<"inject-local-vars", "Boolean">,
     Global, DefaultTrue,
     Desc<"If true, inject local variables explicitly into the expression text. This will fix symbol resolution when there are name collisions between ivars and local variables. But it can make expressions run much more slowly.">;
-  def UseModernTypeLookup : Property<"use-modern-type-lookup", "Boolean">,
-    Global, DefaultFalse,
-    Desc<"If true, use Clang's modern type lookup infrastructure.">;
 }
 
 let Definition = "target" in {
   def DefaultArch: Property<"default-arch", "Arch">,
     Global,
     DefaultStringValue<"">,
     Desc<"Default architecture to choose, when there's a choice.">;
   def MoveToNearestCode: Property<"move-to-nearest-code", "Boolean">,