Reuse the SelectorTable from Clang's Preprocessor

[teemperor]

Summary

At the moment we create our own SelectorTable even though the Preprocessor always
creates one for us that we can (and should) reuse.

[vsk]

LGTM. This is NFC, it seems. There's a FIXME in Preprocessor.h about the lifetime of SelectorTable eventually not being tied to Preprocessor, but this is correct for now.

[teemperor]

Yeah, but the FIXME has been around for like a decade, so I think that bug has survived long enough to be promoted to a feature :).

source/Plugins/ExpressionParser/Clang/ClangExpressionParser.h

 
 private:
   std::unique_ptr<llvm::LLVMContext>
       m_llvm_context; ///< The LLVM context to generate IR into
   std::unique_ptr<clang::FileManager>
       m_file_manager; ///< The Clang file manager object used by the compiler
   std::unique_ptr<clang::CompilerInstance>
       m_compiler; ///< The Clang compiler used to parse expressions into IR
-  std::unique_ptr<clang::SelectorTable>
-      m_selector_table; ///< Selector table for Objective-C methods
   std::unique_ptr<clang::CodeGenerator>
       m_code_generator; ///< The Clang object that generates IR
 
   class LLDBPreprocessorCallbacks;
   LLDBPreprocessorCallbacks *m_pp_callbacks; ///< Called when the preprocessor
                                              ///encounters module imports
   std::unique_ptr<ClangASTContext> m_ast_context;
 };
 }
 
 #endif // liblldb_ClangExpressionParser_h_

source/Plugins/ExpressionParser/Clang/ClangExpressionParser.cpp

std::unique_ptr<PPCallbacks> pp_callbacks(
         new LLDBPreprocessorCallbacks(*decl_vendor, *clang_persistent_vars));
     m_pp_callbacks =
         static_cast<LLDBPreprocessorCallbacks *>(pp_callbacks.get());
     m_compiler->getPreprocessor().addPPCallbacks(std::move(pp_callbacks));
   }
 
   // 8. Most of this we get from the CompilerInstance, but we also want to give
   // the context an ExternalASTSource.
-  m_selector_table.reset(new SelectorTable());
-
   // We enable all builtin functions beside the builtins from libc/libm (e.g.
   // 'fopen'). Those libc functions are already correctly handled by LLDB, and
   // additionally enabling them as expandable builtins is breaking Clang.
   m_compiler->getLangOpts().NoBuiltin = true;
 
   auto &PP = m_compiler->getPreprocessor();
   auto &builtin_context = PP.getBuiltinInfo();
   builtin_context.initializeBuiltins(PP.getIdentifierTable(),
                                      m_compiler->getLangOpts());
 
   std::unique_ptr<clang::ASTContext> ast_context(
       new ASTContext(m_compiler->getLangOpts(), m_compiler->getSourceManager(),
                      m_compiler->getPreprocessor().getIdentifierTable(),
-                     *m_selector_table.get(), builtin_context));
+                     PP.getSelectorTable(), builtin_context));
 
   ast_context->InitBuiltinTypes(m_compiler->getTarget());
 
   ClangExpressionHelper *type_system_helper =
       dyn_cast<ClangExpressionHelper>(m_expr.GetTypeSystemHelper());
   ClangExpressionDeclMap *decl_map = type_system_helper->DeclMap();
 
   if (decl_map) {