[Symbol] Decouple clang from DeclVendor

[xiaobai]

Summary

This removes DeclVendor's dependency on clang (and ClangASTContext).
DeclVendor has no need to know about specific TypeSystems.

[jingham]

LGTM

lldb/include/lldb/Symbol/ClangASTContext.h

public:
 
   CompilerType DeclGetFunctionReturnType(void *opaque_decl) override;
 
   size_t DeclGetFunctionNumArguments(void *opaque_decl) override;
 
   CompilerType DeclGetFunctionArgumentType(void *opaque_decl,
                                            size_t arg_idx) override;
 
+  CompilerType GetTypeForDecl(void *opaque_decl) override;
+
   // CompilerDeclContext override functions
 
   std::vector<CompilerDecl>
   DeclContextFindDeclByName(void *opaque_decl_ctx, ConstString name,
                             const bool ignore_using_decls) override;
 
   bool DeclContextIsStructUnionOrClass(void *opaque_decl_ctx) override;
 

lldb/include/lldb/Symbol/DeclVendor.h

 //===-- DeclVendor.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_DeclVendor_h_
 #define liblldb_DeclVendor_h_
 
-#include "lldb/Core/ClangForward.h"
 #include "lldb/lldb-defines.h"
 
 #include <vector>
 
 namespace lldb_private {
 
 // The Decl vendor class is intended as a generic interface to search for named
 // declarations that are not necessarily backed by a specific symbol file.
public:
   ///     The maximum number of Decls to return.  UINT32_MAX means "as
   ///     many as possible."
   ///
   /// \return
   ///     The number of Decls added to decls; will not exceed
   ///     max_matches.
   virtual uint32_t FindDecls(ConstString name, bool append,
                              uint32_t max_matches,
-                             std::vector<clang::NamedDecl *> &decls) = 0;
+                             std::vector<CompilerDecl> &decls) = 0;
 
   /// Look up the types that the DeclVendor currently knows about matching a
   /// given name.
   ///
   /// \param[in] name
   ///     The name to look for.
   ///
   /// \param[in] max_matches

lldb/include/lldb/Symbol/TypeSystem.h

public:
 
   virtual CompilerType DeclGetFunctionReturnType(void *opaque_decl);
 
   virtual size_t DeclGetFunctionNumArguments(void *opaque_decl);
 
   virtual CompilerType DeclGetFunctionArgumentType(void *opaque_decl,
                                                    size_t arg_idx);
 
+  virtual CompilerType GetTypeForDecl(void *opaque_decl) = 0;
+
   // CompilerDeclContext functions
 
   virtual std::vector<CompilerDecl>
   DeclContextFindDeclByName(void *opaque_decl_ctx, ConstString name,
                             const bool ignore_imported_decls);
 
   virtual bool DeclContextIsStructUnionOrClass(void *opaque_decl_ctx) = 0;
 

lldb/source/Plugins/ExpressionParser/Clang/CMakeLists.txt

 if(NOT LLDB_BUILT_STANDALONE)
   set(tablegen_deps intrinsics_gen)
 endif()
 
 add_lldb_library(lldbPluginExpressionParserClang PLUGIN
   ASTDumper.cpp
   ASTResultSynthesizer.cpp
   ASTStructExtractor.cpp
   ASTUtils.cpp
   ClangASTSource.cpp
+  ClangDeclVendor.cpp
   ClangExpressionDeclMap.cpp
   ClangExpressionParser.cpp
   ClangExpressionSourceCode.cpp
   ClangExpressionVariable.cpp
   ClangFunctionCaller.cpp
   ClangHost.cpp
   ClangModulesDeclVendor.cpp
   ClangPersistentVariables.cpp

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

 //===-- ClangASTSource.cpp ---------------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "ClangASTSource.h"
 
 #include "ASTDumper.h"
+#include "ClangDeclVendor.h"
 #include "ClangModulesDeclVendor.h"
 
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleList.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/ClangUtil.h"
 #include "lldb/Symbol/CompilerDeclContext.h"
 #include "lldb/Symbol/Function.h"
if (!context.m_found.type) {
 
         if (!decl_vendor)
           break;
 
         bool append = false;
         uint32_t max_matches = 1;
         std::vector<clang::NamedDecl *> decls;
 
-        if (!decl_vendor->FindDecls(name, append, max_matches, decls))
+        auto *clang_decl_vendor = llvm::cast<ClangDeclVendor>(decl_vendor);
+        if (!clang_decl_vendor->FindDecls(name, append, max_matches, decls))
           break;
 
         if (log) {
           LLDB_LOGF(
               log,
               "  CAS::FEVD[%u] Matching type found for \"%s\" in the runtime",
               current_id, name.GetCString());
         }
do {
     if (!decl_vendor)
       break;
 
     ConstString interface_name(interface_decl->getNameAsString().c_str());
     bool append = false;
     uint32_t max_matches = 1;
     std::vector<clang::NamedDecl *> decls;
 
-    if (!decl_vendor->FindDecls(interface_name, append, max_matches, decls))
+    auto *clang_decl_vendor = llvm::cast<ClangDeclVendor>(decl_vendor);
+    if (!clang_decl_vendor->FindDecls(interface_name, append, max_matches,
+                                      decls))
       break;
 
     ObjCInterfaceDecl *runtime_interface_decl =
         dyn_cast<ObjCInterfaceDecl>(decls[0]);
 
     if (!runtime_interface_decl)
       break;
 
do {
 
     if (!decl_vendor)
       break;
 
     bool append = false;
     uint32_t max_matches = 1;
     std::vector<clang::NamedDecl *> decls;
 
-    if (!decl_vendor->FindDecls(class_name, append, max_matches, decls))
+    auto *clang_decl_vendor = llvm::cast<ClangDeclVendor>(decl_vendor);
+    if (!clang_decl_vendor->FindDecls(class_name, append, max_matches, decls))
       break;
 
     DeclFromUser<const ObjCInterfaceDecl> interface_decl_from_runtime(
         dyn_cast<ObjCInterfaceDecl>(decls[0]));
 
     if (!interface_decl_from_runtime.IsValid())
       break;
 

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) {
     return vendor->GetKind() >= eClangDeclVendor &&
            vendor->GetKind() < eLastClangDeclVendor;
   }
 
 private:
   DISALLOW_COPY_AND_ASSIGN(ClangDeclVendor);
 };
 } // namespace lldb_private
 
 #endif

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

+//===-- ClangDeclVendor.cpp -------------------------------------*- 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "Plugins/ExpressionParser/Clang/ClangDeclVendor.h"
+
+#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Utility/ConstString.h"
+
+using namespace lldb_private;
+
+uint32_t ClangDeclVendor::FindDecls(ConstString name, bool append,
+                                    uint32_t max_matches,
+                                    std::vector<CompilerDecl> &decls) {
+  if (!append)
+    decls.clear();
+
+  std::vector<clang::NamedDecl *> named_decls;
+  uint32_t ret = FindDecls(name, /*append*/ false, max_matches, named_decls);
+  for (auto *named_decl : named_decls) {
+    decls.push_back(CompilerDecl(
+        ClangASTContext::GetASTContext(&named_decl->getASTContext()),
+        named_decl));
+  }
+  return ret;
+}

lldb/source/Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h

 #include <functional>
 #include <map>
 #include <memory>
 #include <unordered_set>
 
 #include "llvm/Support/Casting.h"
 
 #include "lldb/Breakpoint/BreakpointPrecondition.h"
+#include "lldb/Core/ClangForward.h"
 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Core/ThreadSafeDenseMap.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Target/LanguageRuntime.h"
 #include "lldb/lldb-private.h"
 
 class CommandObjectObjC_ClassTable_Dump;

lldb/source/Symbol/ClangASTContext.cpp

bool ClangASTContext::AreTypesSame(CompilerType type1, CompilerType type2,
   if (ignore_qualifiers) {
     type1_qual = type1_qual.getUnqualifiedType();
     type2_qual = type2_qual.getUnqualifiedType();
   }
 
   return ast->getASTContext()->hasSameType(type1_qual, type2_qual);
 }
 
+CompilerType ClangASTContext::GetTypeForDecl(void *opaque_decl) {
+  if (!opaque_decl)
+    return CompilerType();
+
+  clang::Decl *decl = static_cast<clang::Decl *>(opaque_decl);
+  if (auto *named_decl = llvm::dyn_cast<clang::NamedDecl>(decl))
+    return GetTypeForDecl(named_decl);
+  return CompilerType();
+}
+
 CompilerType ClangASTContext::GetTypeForDecl(clang::NamedDecl *decl) {
   if (clang::ObjCInterfaceDecl *interface_decl =
           llvm::dyn_cast<clang::ObjCInterfaceDecl>(decl))
     return GetTypeForDecl(interface_decl);
   if (clang::TagDecl *tag_decl = llvm::dyn_cast<clang::TagDecl>(decl))
     return GetTypeForDecl(tag_decl);
   return CompilerType();
 }

lldb/source/Symbol/DeclVendor.cpp

 //===-- DeclVendor.cpp ------------------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Symbol/DeclVendor.h"
-
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/CompilerDecl.h"
+#include "lldb/Symbol/TypeSystem.h"
 
 #include <vector>
 
 using namespace lldb;
 using namespace lldb_private;
 
 std::vector<CompilerType> DeclVendor::FindTypes(ConstString name,
                                                 uint32_t max_matches) {
   // FIXME: This depends on clang, but should be able to support any
   // TypeSystem.
   std::vector<CompilerType> ret;
-  std::vector<clang::NamedDecl *> decls;
+  std::vector<CompilerDecl> decls;
   if (FindDecls(name, /*append*/ true, max_matches, decls))
-    for (auto *decl : decls)
-      if (auto type = ClangASTContext::GetTypeForDecl(decl))
+    for (auto decl : decls)
+      if (auto type =
+              decl.GetTypeSystem()->GetTypeForDecl(decl.GetOpaqueDecl()))
         ret.push_back(type);
   return ret;
 }