[core] Remove never used code from the callbacks.

This will allow us to simplify our ASTConsumer model instead of creating many
multiplexers that are not needed. That should simplify adoption of latest
versions of clad.

Author: vgvassilev

core/metacling/src/TClingCallbacks.cxx

@@ -1059,19 +1059,6 @@ void TClingCallbacks::DefinitionShadowed(const clang::NamedDecl *D) {
    TCling__InvalidateGlobal(D);
 }
 
-void TClingCallbacks::DeclDeserialized(const clang::Decl* D) {
-   if (const RecordDecl* RD = dyn_cast<RecordDecl>(D)) {
-      // FIXME: Our AutoLoading doesn't work (load the library) when the looked
-      // up decl is found in the PCH/PCM. We have to do that extra step, which
-      // loads the corresponding library when a decl was deserialized.
-      //
-      // Unfortunately we cannot do that with the current implementation,
-      // because the library load will pull in the header files of the library
-      // as well, even though they are in the PCH/PCM and available.
-      (void)RD;//TCling__AutoLoadCallback(RD->getNameAsString().c_str());
-   }
-}
-
 void TClingCallbacks::LibraryLoaded(const void* dyLibHandle,
                                     llvm::StringRef canonicalName) {
    TCling__LibraryLoadedRTTI(dyLibHandle, canonicalName);

core/metacling/src/TClingCallbacks.h

@@ -112,10 +112,6 @@ class TClingCallbacks : public cling::InterpreterCallbacks {
    /// data about the old (global) decl.
    void DefinitionShadowed(const clang::NamedDecl *D) override;
 
-   // Used to inform client about a new decl read by the ASTReader.
-   //
-   void DeclDeserialized(const clang::Decl *D) override;
-
    void LibraryLoaded(const void *dyLibHandle, llvm::StringRef canonicalName) override;
    void LibraryUnloaded(const void *dyLibHandle, llvm::StringRef canonicalName) override;
 

interpreter/cling/include/cling/Interpreter/InterpreterCallbacks.h

@@ -19,7 +19,6 @@
 #include <memory>
 
 namespace clang {
-  class ASTDeserializationListener;
   class Decl;
   class DeclContext;
   class DeclarationName;
@@ -37,7 +36,6 @@ namespace clang {
 namespace cling {
   class Interpreter;
   class InterpreterCallbacks;
-  class InterpreterDeserializationListener;
   class InterpreterExternalSemaSource;
   class InterpreterPPCallbacks;
   class Transaction;
@@ -57,12 +55,6 @@ namespace cling {
     ///
     InterpreterExternalSemaSource* m_ExternalSemaSource;
 
-    ///\brief Our custom ASTDeserializationListener, translating interesting
-    /// events into callbacks.
-    ///
-    std::unique_ptr
-    <InterpreterDeserializationListener> m_DeserializationListener;
-
     ///\brief Our custom PPCallbacks, translating interesting
     /// events into interpreter callbacks.
     ///
@@ -83,25 +75,18 @@ namespace cling {
     ///\param[in] interp - an interpreter.
     ///\param[in] enableExternalSemaSourceCallbacks  - creates a default
     ///           InterpreterExternalSemaSource and attaches it to Sema.
-    ///\param[in] enableDeserializationListenerCallbacks - creates a default
-    ///           InterpreterDeserializationListener and attaches it to the
-    ///           ModuleManager if it is set.
     ///\param[in] enablePPCallbacks  - creates a default InterpreterPPCallbacks
     ///           and attaches it to the Preprocessor.
     ///
     InterpreterCallbacks(Interpreter* interp,
                          bool enableExternalSemaSourceCallbacks = false,
-                         bool enableDeserializationListenerCallbacks = false,
                          bool enablePPCallbacks = false);
 
     virtual ~InterpreterCallbacks();
 
     cling::Interpreter* getInterpreter() const { return m_Interpreter; }
     clang::ExternalSemaSource* getInterpreterExternalSemaSource() const;
 
-    clang::ASTDeserializationListener*
-    getInterpreterDeserializationListener() const;
-
    virtual void InclusionDirective(clang::SourceLocation /*HashLoc*/,
                                    const clang::Token& /*IncludeTok*/,
                                    llvm::StringRef /*FileName*/,
@@ -174,16 +159,6 @@ namespace cling {
     ///\param[in] - The declaration that has been shadowed.
     virtual void DefinitionShadowed(const clang::NamedDecl*) {}
 
-    /// \brief Used to inform client about a new decl read by the ASTReader.
-    ///
-    ///\param[in] - The Decl read by the ASTReader.
-    virtual void DeclDeserialized(const clang::Decl*) {}
-
-    /// \brief Used to inform client about a new type read by the ASTReader.
-    ///
-    ///\param[in] - The Type read by the ASTReader.
-    virtual void TypeDeserialized(const clang::Type*) {}
-
     virtual void LibraryLoaded(const void*, llvm::StringRef) {}
     virtual void LibraryUnloaded(const void*, llvm::StringRef) {}
 

interpreter/cling/lib/Interpreter/InterpreterCallbacks.cpp

@@ -13,12 +13,10 @@
 
 #include "clang/AST/ASTContext.h"
 #include "clang/Frontend/CompilerInstance.h"
-#include "clang/Frontend/MultiplexConsumer.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Sema/CodeCompleteConsumer.h"
 #include "clang/Sema/MultiplexExternalSemaSource.h"
 #include "clang/Sema/Sema.h"
-#include "clang/Serialization/ASTDeserializationListener.h"
 #include "clang/Serialization/ASTReader.h"
 
 #include <optional>
@@ -27,8 +25,8 @@ using namespace clang;
 
 namespace cling {
 
-  ///\brief Translates 'interesting' for the interpreter
-  /// ASTDeserializationListener events into interpreter callback.
+  ///\brief Translates 'interesting' for the interpreter into interpreter
+  /// callback.
   ///
   class InterpreterPPCallbacks : public PPCallbacks {
   private:
@@ -69,40 +67,6 @@ namespace cling {
     }
   };
 
-  ///\brief Translates 'interesting' for the interpreter
-  /// ASTDeserializationListener events into interpreter callback.
-  ///
-  class InterpreterDeserializationListener : public ASTDeserializationListener {
-  private:
-    cling::InterpreterCallbacks* m_Callbacks;
-  public:
-    InterpreterDeserializationListener(InterpreterCallbacks* C)
-      : m_Callbacks(C) {}
-
-    void DeclRead(serialization::DeclID, const Decl *D) override {
-      if (m_Callbacks)
-        m_Callbacks->DeclDeserialized(D);
-    }
-
-    void TypeRead(serialization::TypeIdx, QualType T) override {
-      if (m_Callbacks)
-        m_Callbacks->TypeDeserialized(T.getTypePtr());
-    }
-  };
-
-  /// \brief Wraps an ASTDeserializationListener in an ASTConsumer so that
-  /// it can be used with a MultiplexConsumer.
-  class DeserializationListenerWrapper : public ASTConsumer {
-    ASTDeserializationListener* m_Listener;
-
-  public:
-    DeserializationListenerWrapper(ASTDeserializationListener* Listener)
-        : m_Listener(Listener) {}
-    ASTDeserializationListener* GetASTDeserializationListener() override {
-      return m_Listener;
-    }
-  };
-
   /// \brief wraps an ExternalASTSource in an ExternalSemaSource. No functional
   /// difference between the original source and this wrapper intended.
   class ExternalASTSourceWrapper : public ExternalSemaSource {
@@ -297,7 +261,6 @@ namespace cling {
 
   InterpreterCallbacks::InterpreterCallbacks(Interpreter* interp,
                              bool enableExternalSemaSourceCallbacks/* = false*/,
-                        bool enableDeserializationListenerCallbacks/* = false*/,
                                              bool enablePPCallbacks/* = false*/)
     : m_Interpreter(interp), m_ExternalSemaSource(nullptr), m_PPCallbacks(nullptr),
       m_IsRuntime(false) {
@@ -340,27 +303,6 @@ namespace cling {
         }
     }
 
-    if (enableDeserializationListenerCallbacks && Reader) {
-      // Create a new deserialization listener.
-      m_DeserializationListener.
-        reset(new InterpreterDeserializationListener(this));
-
-      // Wrap the deserialization listener in an MultiplexConsumer and then
-      // combine it with the existing Consumer.
-      // FIXME: Maybe it's better to make MultiplexASTDeserializationListener
-      // public instead. See also: https://reviews.llvm.org/D37475
-      std::unique_ptr<DeserializationListenerWrapper> wrapper(
-          new DeserializationListenerWrapper(m_DeserializationListener.get()));
-
-      std::vector<std::unique_ptr<ASTConsumer>> Consumers;
-      Consumers.push_back(std::move(wrapper));
-      Consumers.push_back(m_Interpreter->getCI()->takeASTConsumer());
-
-      std::unique_ptr<clang::MultiplexConsumer> multiConsumer(
-          new clang::MultiplexConsumer(std::move(Consumers)));
-      m_Interpreter->getCI()->setASTConsumer(std::move(multiConsumer));
-    }
-
     if (enablePPCallbacks) {
       Preprocessor& PP = m_Interpreter->getCI()->getPreprocessor();
       m_PPCallbacks = new InterpreterPPCallbacks(this);
@@ -384,11 +326,6 @@ namespace cling {
     return m_ExternalSemaSource;
   }
 
-  ASTDeserializationListener*
-  InterpreterCallbacks::getInterpreterDeserializationListener() const {
-    return m_DeserializationListener.get();
-  }
-
   bool InterpreterCallbacks::FileNotFound(llvm::StringRef) {
     // Default implementation is no op.
     return false;

interpreter/cling/lib/Interpreter/MultiplexInterpreterCallbacks.h

@@ -21,7 +21,7 @@ namespace cling {
 
   public:
     MultiplexInterpreterCallbacks(Interpreter* interp)
-      : InterpreterCallbacks(interp, true, true, true) {}
+      : InterpreterCallbacks(interp, true, true) {}
 
     void addCallback(std::unique_ptr<InterpreterCallbacks> newCb) {
       m_Callbacks.push_back(std::move(newCb));
@@ -122,18 +122,6 @@ namespace cling {
        }
      }
 
-     void DeclDeserialized(const clang::Decl* D) override {
-       for (auto&& cb : m_Callbacks) {
-         cb->DeclDeserialized(D);
-       }
-     }
-
-     void TypeDeserialized(const clang::Type* Ty) override {
-       for (auto&& cb : m_Callbacks) {
-         cb->TypeDeserialized(Ty);
-       }
-     }
-
      void LibraryLoaded(const void* Lib, llvm::StringRef Name) override {
        for (auto&& cb : m_Callbacks) {
          cb->LibraryLoaded(Lib,Name);