[lldb][NFC] Add an ImporterBackedASTSource that serves as base class for LLDB ExternalASTSources that use the ASTImporter

[teemperor]

Summary

This gives all ExternalASTSource classes a common base class that allows
other classes (in LLDB's case ClangASTImporter) to invalidate the redeclaration chains
in an ASTContext. The implementation just calls the (private) function to bump the
generation counter which is how we track whether a redeclaration chain is out of date.

This is used in D101950 to let the ClangASTImporter mark redeclaration chains as
out-of-date so that they update themselves via the ExternalASTSource.

Patch itself is NFC as it just changes the inheritance of a bunch of classes and changes
the LLVM RTTI to make sure we can reliably cast to it. Will be merged with its
dependent patch that lets the ClangASTImporter handle redeclaration chains.

[aprantl]

LGTM

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

 //===-- ASTUtils.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 LLDB_SOURCE_PLUGINS_EXPRESSIONPARSER_CLANG_ASTUTILS_H
 #define LLDB_SOURCE_PLUGINS_EXPRESSIONPARSER_CLANG_ASTUTILS_H
 
+#include "Plugins/TypeSystem/Clang/ImporterBackedASTSource.h"
 #include "clang/Basic/Module.h"
 #include "clang/Sema/Lookup.h"
 #include "clang/Sema/MultiplexExternalSemaSource.h"
 #include "clang/Sema/Sema.h"
 #include "clang/Sema/SemaConsumer.h"
 
 namespace lldb_private {
 
 /// Wraps an ExternalASTSource into an ExternalSemaSource. Doesn't take
 /// ownership of the provided source.
-class ExternalASTSourceWrapper : public clang::ExternalSemaSource {
+class ExternalASTSourceWrapper : public ImporterBackedASTSource {
   ExternalASTSource *m_Source;
 
 public:
   ExternalASTSourceWrapper(ExternalASTSource *Source) : m_Source(Source) {
     assert(m_Source && "Can't wrap nullptr ExternalASTSource");
   }
 
   ~ExternalASTSourceWrapper() override;

 /// higher priority can fulfill a request, all sources with a lower priority
 /// will not receive the request.
 ///
 /// This class is mostly use to multiplex between sources of different
 /// 'quality', e.g. a C++ modules and debug information. The C++ module will
 /// provide more accurate replies to the requests, but might not be able to
 /// answer all requests. The debug information will be used as a fallback then
 /// to provide information that is not in the C++ module.
-class SemaSourceWithPriorities : public clang::ExternalSemaSource {
+class SemaSourceWithPriorities : public ImporterBackedASTSource {
 
 private:
   /// The sources ordered in decreasing priority.
   llvm::SmallVector<clang::ExternalSemaSource *, 2> Sources;
 
 public:
   /// Construct a SemaSourceWithPriorities with a 'high quality' source that
   /// has the higher priority and a 'low quality' source that will be used

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

 //===-- ClangASTSource.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 LLDB_SOURCE_PLUGINS_EXPRESSIONPARSER_CLANG_CLANGASTSOURCE_H
 #define LLDB_SOURCE_PLUGINS_EXPRESSIONPARSER_CLANG_CLANGASTSOURCE_H
 
 #include <set>
 
 #include "Plugins/ExpressionParser/Clang/ClangASTImporter.h"
 #include "Plugins/ExpressionParser/Clang/NameSearchContext.h"
+#include "Plugins/TypeSystem/Clang/ImporterBackedASTSource.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Target/Target.h"
 #include "clang/AST/ExternalASTSource.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
 ///
 /// As Clang parses an expression, it may encounter names that are not defined
 /// inside the expression, including variables, functions, and types.  Clang
 /// knows the name it is looking for, but nothing else. The ExternalSemaSource
 /// class provides Decls (VarDecl, FunDecl, TypeDecl) to Clang for these
 /// names, consulting the ClangExpressionDeclMap to do the actual lookups.
-class ClangASTSource : public clang::ExternalASTSource,
+class ClangASTSource : public ImporterBackedASTSource,
                        public ClangASTImporter::MapCompleter {
 public:
   /// Constructor
   ///
   /// Initializes class variables.
   ///
   /// \param[in] target
   ///     A reference to the target containing debug information to use.

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

 //===-- ClangExternalASTSourceCallbacks.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 LLDB_SOURCE_PLUGINS_EXPRESSIONPARSER_CLANG_CLANGEXTERNALASTSOURCECALLBACKS_H
 #define LLDB_SOURCE_PLUGINS_EXPRESSIONPARSER_CLANG_CLANGEXTERNALASTSOURCECALLBACKS_H
 
+#include "Plugins/TypeSystem/Clang/ImporterBackedASTSource.h"
 #include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
 #include "clang/Basic/Module.h"
 
 namespace lldb_private {
 
-class ClangExternalASTSourceCallbacks : public clang::ExternalASTSource {
+class ClangExternalASTSourceCallbacks : public ImporterBackedASTSource {
   /// LLVM RTTI support.
   static char ID;
 
 public:
   /// LLVM RTTI support.
-  bool isA(const void *ClassID) const override { return ClassID == &ID; }
+  bool isA(const void *ClassID) const override {
+    return ClassID == &ID || ImporterBackedASTSource::isA(ClassID);
+  }
   static bool classof(const clang::ExternalASTSource *s) { return s->isA(&ID); }
 
   ClangExternalASTSourceCallbacks(TypeSystemClang &ast) : m_ast(ast) {}
 
   void FindExternalLexicalDecls(
       const clang::DeclContext *DC,
       llvm::function_ref<bool(clang::Decl::Kind)> IsKindWeWant,
       llvm::SmallVectorImpl<clang::Decl *> &Result) override;

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

 add_lldb_library(lldbPluginTypeSystemClang PLUGIN
+  ImporterBackedASTSource.cpp
   TypeSystemClang.cpp
 
   LINK_LIBS
     lldbCore
     lldbSymbol
     lldbTarget
     lldbUtility
     lldbPluginExpressionParserClang

lldb/source/Plugins/TypeSystem/Clang/ImporterBackedASTSource.h

+//===-- ImporterBackedASTSource.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 LLDB_SOURCE_PLUGINS_TYPESYSTEM_CLANG_IMPORTERBACKEDASTSOURCE
+#define LLDB_SOURCE_PLUGINS_TYPESYSTEM_CLANG_IMPORTERBACKEDASTSOURCE
+
+#include "clang/AST/ASTContext.h"
+#include "clang/Sema/ExternalSemaSource.h"
+
+namespace lldb_private {
+
+/// The base class of all ExternalASTSources in LLDB that use the
+/// ClangASTImporter to move declarations from other ASTs to the ASTContext they
+/// are attached to.
+class ImporterBackedASTSource : public clang::ExternalSemaSource {
+  /// LLVM RTTI support.
+  static char ID;
+
+public:
+  /// LLVM RTTI support.
+  bool isA(const void *ClassID) const override {
+    return ClassID == &ID || ExternalSemaSource::isA(ClassID);
+  }
+  static bool classof(const clang::ExternalASTSource *s) { return s->isA(&ID); }
+
+  /// This marks all redeclaration chains in the ASTContext as out-of-date and
+  /// that this ExternalASTSource should be consulted to get the complete
+  /// redeclaration chain.
+  ///
+  /// \see ExternalASTSource::CompleteRedeclChain
+  void MarkRedeclChainsAsOutOfDate(clang::ASTContext &c) {
+    // This invalidates redeclaration chains but also other things such as
+    // identifiers. There isn't a more precise way at the moment that only
+    // affects redecl chains.
+    incrementGeneration(c);
+  }
+};
+
+} // namespace lldb_private
+
+#endif // LLDB_SOURCE_PLUGINS_TYPESYSTEM_CLANG_IMPORTERBACKEDASTSOURCE

lldb/source/Plugins/TypeSystem/Clang/ImporterBackedASTSource.cpp

+//===-- ImporterBackedASTSource.cpp ---------------------------------------===//
+//
+// 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/TypeSystem/Clang/ImporterBackedASTSource.h"
+
+using namespace lldb_private;
+
+char ImporterBackedASTSource::ID;