[ClangExpressionParser] Add ClangDeclVendor

[xiaobai]

Summary

This introduces a layer between DeclVendor and the currently implemented
DeclVendors (ClangModulesDeclVendor and AppleObjCDeclVendor). This
allows the removal of DeclVendor::GetImporterSource which is extremely
clang-specific, freeing up the interface to be more general.

A good follow up to this would be to remove the remaining instances of
clang in DeclVendor, either by moving things to ClangDeclVendor or by
using wrappers (e.g. CompilerDecl instead of clang::NamedDecl).

[JDevlieghere]

lldb/include/lldb/Symbol/DeclVendor.h

27

What's eLastClangDeclVendor and where is it used?

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

33

I think a switch would be more readable?

[xiaobai]

lldb/include/lldb/Symbol/DeclVendor.h

27

Following the advice here: https://llvm.org/docs/HowToSetUpLLVMStyleRTTI.html

I added a Last one to indicate that any new ClangDeclVendor subclasses should go before this one. It also makes the classof pattern of checking bounds easier. (kind >= eFoo && kind < eLastFoo).

[JDevlieghere]

lldb/include/lldb/Symbol/DeclVendor.h

27

Fair enough, I totally forgot about that pattern.

[teemperor]

LGTM

[shafik]

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

110 ↗

(On Diff #216201)

This part of the change was recently reverted, see: http://llvm.org/viewvc/llvm-project?view=revision&revision=372974

I am wondering if the change right above for runtime_decl_vendor is also problematic as well. Can you explain the rationale?

CC @teemperor

[xiaobai]

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

110 ↗

(On Diff #216201)

This is actually a bug. I intended to cast it to a ClangDeclVendor. The instance above for runtime_decl_vendor shouldn't be problematic. The rationale behind this change was to remove the clang-specific code in the DeclVendor class by introducing a ClangDeclVendor class to sit in between DeclVendor and its clang-specific subclasses (ClangModulesDeclVendor and AppleObjCDeclVendor). That partial revert is probably fine honestly since it's using ClangModulesDeclVendor directly.

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 "clang/AST/ExternalASTMerger.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.
 class DeclVendor {
 public:
+  enum DeclVendorKind {
+    eClangDeclVendor,
+    eClangModuleDeclVendor,
+    eAppleObjCDeclVendor,
+    eLastClangDeclVendor,
+  };
   // Constructors and Destructors
-  DeclVendor() {}
+  DeclVendor(DeclVendorKind kind) : m_kind(kind) {}
 
   virtual ~DeclVendor() {}
 
+  DeclVendorKind GetKind() const { return m_kind; }
+
   /// Look up the set of Decls that the DeclVendor currently knows about
   /// matching a given name.
   ///
   /// \param[in] name
   ///     The name to look for.
   ///
   /// \param[in] append
   ///     If true, FindDecls will clear "decls" when it starts.
public:
   ///
   /// \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);
+
+  const DeclVendorKind m_kind;
 };
 
 } // namespace lldb_private
 
 #endif

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

do {
       if (!process)
         break;
 
       ObjCLanguageRuntime *language_runtime(ObjCLanguageRuntime::Get(*process));
 
       if (!language_runtime)
         break;
 
-      DeclVendor *runtime_decl_vendor = language_runtime->GetDeclVendor();
-
-      if (!runtime_decl_vendor)
-        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 {
-      DeclVendor *modules_decl_vendor =
-          m_target->GetClangModulesDeclVendor();
+      auto *modules_decl_vendor = llvm::cast<ClangModulesDeclVendor>(
+          m_target->GetClangModulesDeclVendor());
 
       if (!modules_decl_vendor)
         break;
 
       sources.push_back(modules_decl_vendor->GetImporterSource());
     } while (false);
 
     if (!is_shared_context) {

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/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;
+
+  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/ClangModulesDeclVendor.h

 //===-- ClangModulesDeclVendor.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_ClangModulesDeclVendor_h
 #define liblldb_ClangModulesDeclVendor_h
 
 #include "lldb/Core/ClangForward.h"
-#include "lldb/Symbol/DeclVendor.h"
 #include "lldb/Symbol/SourceModule.h"
 #include "lldb/Target/Platform.h"
 
+#include "Plugins/ExpressionParser/Clang/ClangDeclVendor.h"
+
 #include <set>
 #include <vector>
 
 namespace lldb_private {
 
-class ClangModulesDeclVendor : public DeclVendor {
+class ClangModulesDeclVendor : public ClangDeclVendor {
 public:
   // Constructors and Destructors
   ClangModulesDeclVendor();
 
   ~ClangModulesDeclVendor() override;
 
+  static bool classof(const DeclVendor *vendor) {
+    return vendor->GetKind() == eClangModuleDeclVendor;
+  }
+
   static ClangModulesDeclVendor *Create(Target &target);
 
   typedef std::vector<ConstString> ModulePath;
   typedef uintptr_t ModuleID;
   typedef std::vector<ModuleID> ModuleVector;
 
   /// Add a module to the list of modules to search.
   ///

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

default:
       error_stream.PutChar('\n');
       break;
     case clang::DiagnosticsEngine::Level::Ignored:
       break;
     }
   }
 }
 
-ClangModulesDeclVendor::ClangModulesDeclVendor() {}
+ClangModulesDeclVendor::ClangModulesDeclVendor()
+    : ClangDeclVendor(eClangModuleDeclVendor) {}
 
 ClangModulesDeclVendor::~ClangModulesDeclVendor() {}
 
 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)

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

 //===-- AppleObjCDeclVendor.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_AppleObjCDeclVendor_h_
 #define liblldb_AppleObjCDeclVendor_h_
 
 #include "lldb/Symbol/ClangASTContext.h"
-#include "lldb/Symbol/DeclVendor.h"
 #include "lldb/lldb-private.h"
 
+#include "Plugins/ExpressionParser/Clang/ClangDeclVendor.h"
 #include "Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h"
 
 namespace lldb_private {
 
 class AppleObjCExternalASTSource;
 
-class AppleObjCDeclVendor : public DeclVendor {
+class AppleObjCDeclVendor : public ClangDeclVendor {
 public:
   AppleObjCDeclVendor(ObjCLanguageRuntime &runtime);
 
+  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:

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

void StartTranslationUnit(clang::ASTConsumer *Consumer) override {
     translation_unit_decl->setHasExternalLexicalStorage();
   }
 
 private:
   AppleObjCDeclVendor &m_decl_vendor;
 };
 
 AppleObjCDeclVendor::AppleObjCDeclVendor(ObjCLanguageRuntime &runtime)
-    : DeclVendor(), m_runtime(runtime), m_ast_ctx(runtime.GetProcess()
-                                                      ->GetTarget()
-                                                      .GetArchitecture()
-                                                      .GetTriple()
-                                                      .getTriple()
-                                                      .c_str()),
+    : ClangDeclVendor(eAppleObjCDeclVendor), m_runtime(runtime),
+      m_ast_ctx(runtime.GetProcess()
       m_type_realizer_sp(m_runtime.GetEncodingToType()) {
   m_external_source = new AppleObjCExternalASTSource(*this);
   llvm::IntrusiveRefCntPtr<clang::ExternalASTSource> external_source_owning_ptr(
       m_external_source);
   m_ast_ctx.getASTContext()->setExternalSource(external_source_owning_ptr);
 }
 
 clang::ObjCInterfaceDecl *