[Symbol] Add DeclVendor::FindTypes

[xiaobai]

Summary

Following up on the plan I outlined in D63622, we can remove the
dependence on clang in all the places where we only want to find the
types from the DeclVendor. This means that currently DeclVendor depends
on clang, but centralizing the dependency makes it easier to refactor
cleanly.

[labath]

Besides picking at code style details, I don't believe I have anything useful to add here. :)

source/Plugins/Language/ObjC/ObjCLanguage.cpp

939–941 ↗

(On Diff #206768)

I don't think using auto is helpful here -- we have many classes to represent "types", and it's not clear that this is talking about CompilerType. If you want to shorten this, I'd suggest folding the FindTypes call into the for loop:
for (const CompilerType &type : decl_vendor->FindTypes(...)).

[xiaobai]

Pavel's suggestion

[jingham]

LGTM

lldb/trunk/include/lldb/Symbol/DeclVendor.h

public:
   ///
   /// \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;
 
+  /// 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
+  //      The maximum number of matches. UINT32_MAX means "as many as possible".
+  ///
+  /// \return
+  ///     The vector of CompilerTypes that was found.
+  std::vector<CompilerType> FindTypes(ConstString name, uint32_t max_matches);
+
   /// Interface for ExternalASTMerger.  Returns an ImporterSource 
   /// allowing type completion.
   ///
   /// \return
   ///     An ImporterSource for this DeclVendor.
   virtual clang::ExternalASTMerger::ImporterSource GetImporterSource() = 0;
 
 private:
   // For DeclVendor only
   DISALLOW_COPY_AND_ASSIGN(DeclVendor);
 };
 
 } // namespace lldb_private
 
 #endif

lldb/trunk/source/API/SBTarget.cpp

for (size_t idx = 0; idx < count; idx++) {
         TypeSP type_sp(
             module_sp->FindFirstType(sc, const_typename, exact_match));
         if (type_sp)
           return LLDB_RECORD_RESULT(SBType(type_sp));
       }
     }
 
     // Didn't find the type in the symbols; Try the loaded language runtimes
-    // FIXME: This depends on clang, but should be able to support any
-    // TypeSystem/compiler.
     if (auto process_sp = target_sp->GetProcessSP()) {
       for (auto *runtime : process_sp->GetLanguageRuntimes()) {
         if (auto vendor = runtime->GetDeclVendor()) {
-          std::vector<clang::NamedDecl *> decls;
-          if (vendor->FindDecls(const_typename, /*append*/ true,
-                                /*max_matches*/ 1, decls) > 0) {
-            if (CompilerType type =
-                    ClangASTContext::GetTypeForDecl(decls.front()))
-              return LLDB_RECORD_RESULT(SBType(type));
-          }
+          auto types = vendor->FindTypes(const_typename, /*max_matches*/ 1);
+          if (!types.empty())
+            return LLDB_RECORD_RESULT(SBType(types.front()));
         }
       }
     }
 
     // No matches, search for basic typename matches
     ClangASTContext *clang_ast = target_sp->GetScratchClangASTContext();
     if (clang_ast)
       return LLDB_RECORD_RESULT(SBType(ClangASTContext::GetBasicType(
if (num_matches > 0) {
       for (size_t idx = 0; idx < num_matches; idx++) {
         TypeSP type_sp(type_list.GetTypeAtIndex(idx));
         if (type_sp)
           sb_type_list.Append(SBType(type_sp));
       }
     }
 
     // Try the loaded language runtimes
-    // FIXME: This depends on clang, but should be able to support any
-    // TypeSystem/compiler.
     if (auto process_sp = target_sp->GetProcessSP()) {
       for (auto *runtime : process_sp->GetLanguageRuntimes()) {
         if (auto *vendor = runtime->GetDeclVendor()) {
-          std::vector<clang::NamedDecl *> decls;
-          if (vendor->FindDecls(const_typename, /*append*/ true,
-                                /*max_matches*/ 1, decls) > 0) {
-            for (auto *decl : decls) {
-              if (CompilerType type = ClangASTContext::GetTypeForDecl(decl))
-                sb_type_list.Append(SBType(type));
-            }
-          }
-        }
-      }
-    }
+          auto types =
+              vendor->FindTypes(const_typename, /*max_matches*/ UINT32_MAX);
+          for (auto type : types)
 
     if (sb_type_list.GetSize() == 0) {
       // No matches, search for basic typename matches
       ClangASTContext *clang_ast = target_sp->GetScratchClangASTContext();
       if (clang_ast)
         sb_type_list.Append(SBType(ClangASTContext::GetBasicType(
             clang_ast->getASTContext(), const_typename)));
     }

lldb/trunk/source/Plugins/Language/ObjC/ObjCLanguage.cpp

std::unique_ptr<Language::TypeScavenger> ObjCLanguage::GetTypeScavenger() {
   };
 
   class ObjCRuntimeScavenger : public Language::TypeScavenger {
   protected:
     bool Find_Impl(ExecutionContextScope *exe_scope, const char *key,
                    ResultSet &results) override {
       bool result = false;
 
-      Process *process = exe_scope->CalculateProcess().get();
-      if (process) {
-        auto objc_runtime = ObjCLanguageRuntime::Get(*process);
-        if (objc_runtime) {
-          auto decl_vendor = objc_runtime->GetDeclVendor();
-          if (decl_vendor) {
-            std::vector<clang::NamedDecl *> decls;
+      if (auto *process = exe_scope->CalculateProcess().get()) {
+        if (auto *objc_runtime = ObjCLanguageRuntime::Get(*process)) {
+          if (auto *decl_vendor = objc_runtime->GetDeclVendor()) {
             ConstString name(key);
-            decl_vendor->FindDecls(name, true, UINT32_MAX, decls);
-            for (auto decl : decls) {
-              if (decl) {
-                if (CompilerType candidate =
-                        ClangASTContext::GetTypeForDecl(decl)) {
-                  result = true;
-                  std::unique_ptr<Language::TypeScavenger::Result> result(
-                      new ObjCScavengerResult(candidate));
-                  results.insert(std::move(result));
-                }
-              }
-            }
-          }
-        }
-      }
+            for (const CompilerType &type :
+                 decl_vendor->FindTypes(name, /*max_matches*/ UINT32_MAX)) {
+                  new ObjCScavengerResult(type));
 
       return result;
     }
 
     friend class lldb_private::ObjCLanguage;
   };
 
   class ObjCModulesScavenger : public Language::TypeScavenger {
   protected:
     bool Find_Impl(ExecutionContextScope *exe_scope, const char *key,
                    ResultSet &results) override {
       bool result = false;
 
-      Target *target = exe_scope->CalculateTarget().get();
-      if (target) {
-        if (auto clang_modules_decl_vendor =
+      if (auto *target = exe_scope->CalculateTarget().get()) {
+        if (auto *clang_modules_decl_vendor =
                 target->GetClangModulesDeclVendor()) {
-          std::vector<clang::NamedDecl *> decls;
           ConstString key_cs(key);
-
-          if (clang_modules_decl_vendor->FindDecls(key_cs, false, UINT32_MAX,
-                                                   decls) > 0 &&
-              !decls.empty()) {
-            CompilerType module_type =
-                ClangASTContext::GetTypeForDecl(decls.front());
+          auto types = clang_modules_decl_vendor->FindTypes(
+              key_cs, /*max_matches*/ UINT32_MAX);
+          if (!types.empty()) {
             result = true;
             std::unique_ptr<Language::TypeScavenger::Result> result(
-                new ObjCScavengerResult(module_type));
+                new ObjCScavengerResult(types.front()));
             results.insert(std::move(result));
           }
         }
       }
 
       return result;
     }
 

lldb/trunk/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp

if (objc_class_sp) {
         class_type_or_name.SetTypeSP(type_sp);
       else {
         type_sp = LookupInCompleteClassCache(class_name);
         if (type_sp) {
           objc_class_sp->SetType(type_sp);
           class_type_or_name.SetTypeSP(type_sp);
         } else {
           // try to go for a CompilerType at least
-          DeclVendor *vendor = GetDeclVendor();
-          if (vendor) {
-            std::vector<clang::NamedDecl *> decls;
-            if (vendor->FindDecls(class_name, false, 1, decls) && decls.size())
-              class_type_or_name.SetCompilerType(
-                  ClangASTContext::GetTypeForDecl(decls[0]));
+          if (auto *vendor = GetDeclVendor()) {
+            auto types = vendor->FindTypes(class_name, /*max_matches*/ 1);
+            if (!types.empty())
+              class_type_or_name.SetCompilerType(types.front());
           }
         }
       }
     }
   }
   return !class_type_or_name.IsEmpty();
 }
 

lldb/trunk/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTypeEncodingParser.cpp

if (less_than_pos != std::string::npos) {
       else
         name.erase(less_than_pos);
     }
 
     DeclVendor *decl_vendor = m_runtime.GetDeclVendor();
     if (!decl_vendor)
       return clang::QualType();
 
-    const bool append = false;
-    const uint32_t max_matches = 1;
-    std::vector<clang::NamedDecl *> decls;
-
-    uint32_t num_types =
-        decl_vendor->FindDecls(ConstString(name), append, max_matches, decls);
+    auto types = decl_vendor->FindTypes(ConstString(name), /*max_matches*/ 1);
 
 // The user can forward-declare something that has no definition.  The runtime
 // doesn't prohibit this at all. This is a rare and very weird case.  We keep
 // this assert in debug builds so we catch other weird cases.
 #ifdef LLDB_CONFIGURATION_DEBUG
-    assert(num_types);
+    assert(!types.empty());
 #else
-    if (!num_types)
+    if (types.empty())
       return ast_ctx.getObjCIdType();
 #endif
 
-    return ClangUtil::GetQualType(
-        ClangASTContext::GetTypeForDecl(decls[0]).GetPointerType());
+    return ClangUtil::GetQualType(types.front().GetPointerType());
   } else {
     // We're going to resolve this dynamically anyway, so just smile and wave.
     return ast_ctx.getObjCIdType();
   }
 }
 
 clang::QualType
 AppleObjCTypeEncodingParser::BuildType(clang::ASTContext &ast_ctx,

lldb/trunk/source/Symbol/CMakeLists.txt

add_lldb_library(lldbSymbol
   CompileUnit.cpp
   CompilerDecl.cpp
   CompilerDeclContext.cpp
   CompilerType.cpp
   CxxModuleHandler.cpp
   DWARFCallFrameInfo.cpp
   DebugMacros.cpp
   Declaration.cpp
+  DeclVendor.cpp
   FuncUnwinders.cpp
   Function.cpp
   LineEntry.cpp
   LineTable.cpp
   LocateSymbolFile.cpp
   ObjectFile.cpp
   PostfixExpression.cpp
   Symbol.cpp

lldb/trunk/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 <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;
+  if (FindDecls(name, /*append*/ true, max_matches, decls))
+    for (auto *decl : decls)
+      if (auto type = ClangASTContext::GetTypeForDecl(decl))
+        ret.push_back(type);
+  return ret;
+}