Remove the unused return value in ASTImporter::Imported [NFC]

[teemperor]

Summary

ASTImporter::Imported currently returns a Decl, but that return value is not used by the ASTImporter (or anywhere else)
nor is it documented.

[balazske]

I would prefer an observer-like solution but I am not against this change.

[martong]

LGTM!

cfe/trunk/include/clang/AST/ASTImporter.h

public:
     /// Called for ObjCInterfaceDecl, ObjCProtocolDecl, and TagDecl.
     /// Mark the Decl as complete, filling it in as much as possible.
     ///
     /// \param D A declaration in the "to" context.
     virtual void CompleteDecl(Decl* D);
 
     /// Subclasses can override this function to observe all of the \c From ->
     /// \c To declaration mappings as they are imported.
-    virtual Decl *Imported(Decl *From, Decl *To) { return To; }
+    virtual void Imported(Decl *From, Decl *To) {}
 
     /// Store and assign the imported declaration to its counterpart.
     Decl *MapImported(Decl *From, Decl *To);
 
     /// Called by StructuralEquivalenceContext.  If a RecordDecl is
     /// being compared to another RecordDecl as part of import, completing the
     /// other RecordDecl may trigger importation of the first RecordDecl. This
     /// happens especially for anonymous structs.  If the original of the second

cfe/trunk/lib/AST/ExternalASTMerger.cpp

LazyASTImporter(ExternalASTMerger &_Parent, ASTContext &ToContext,
                   const ExternalASTMerger::OriginMap &_FromOrigins)
       : ASTImporter(ToContext, ToFileManager, FromContext, FromFileManager,
                     /*MinimalImport=*/true),
         Parent(_Parent), Reverse(FromContext, FromFileManager, ToContext,
                                  ToFileManager, /*MinimalImport=*/true), FromOrigins(_FromOrigins) {}
 
   /// Whenever a DeclContext is imported, ensure that ExternalASTSource's origin
   /// map is kept up to date.  Also set the appropriate flags.
-  Decl *Imported(Decl *From, Decl *To) override {
+  void Imported(Decl *From, Decl *To) override {
     if (auto *ToDC = dyn_cast<DeclContext>(To)) {
       const bool LoggingEnabled = Parent.LoggingEnabled();
       if (LoggingEnabled)
         logs() << "(ExternalASTMerger*)" << (void*)&Parent
                << " imported (DeclContext*)" << (void*)ToDC
                << ", (ASTContext*)" << (void*)&getToContext()
                << " from (DeclContext*)" << (void*)llvm::cast<DeclContext>(From)
                << ", (ASTContext*)" << (void*)&getFromContext()
void Imported(Decl *From, Decl *To) override {
     } else if (auto *ToNamespace = dyn_cast<NamespaceDecl>(To)) {
       ToNamespace->setHasExternalVisibleStorage();
       assert(Parent.CanComplete(ToNamespace));
     } else if (auto *ToContainer = dyn_cast<ObjCContainerDecl>(To)) {
       ToContainer->setHasExternalLexicalStorage();
       ToContainer->getPrimaryContext()->setMustBuildLookupTable();
       assert(Parent.CanComplete(ToContainer));
     }
-    return To;
   }
   ASTImporter &GetReverse() { return Reverse; }
 };
 
 bool HasDeclOfSameType(llvm::ArrayRef<Candidate> Decls, const Candidate &C) {
   if (isa<FunctionDecl>(C.first.get()))
     return false;
   return llvm::any_of(Decls, [&](const Candidate &D) {

lldb/trunk/include/lldb/Symbol/ClangASTImporter.h

public:
 
     void
     InitDeportWorkQueues(std::set<clang::NamedDecl *> *decls_to_deport,
                          std::set<clang::NamedDecl *> *decls_already_deported);
     void ExecuteDeportWorkQueues();
 
     void ImportDefinitionTo(clang::Decl *to, clang::Decl *from);
 
-    clang::Decl *Imported(clang::Decl *from, clang::Decl *to) override;
+    void Imported(clang::Decl *from, clang::Decl *to) override;
 
     clang::Decl *GetOriginalDecl(clang::Decl *To) override;
 
     std::set<clang::NamedDecl *> *m_decls_to_deport;
     std::set<clang::NamedDecl *> *m_decls_already_deported;
     ClangASTImporter &m_master;
     clang::ASTContext *m_source_ctx;
   };

lldb/trunk/source/Symbol/ClangASTImporter.cpp

do {
         to_objc_interface->startDefinition();
 
       to_objc_interface->setSuperClass(m_source_ctx->getTrivialTypeSourceInfo(
           m_source_ctx->getObjCInterfaceType(imported_from_superclass)));
     } while (0);
   }
 }
 
-clang::Decl *ClangASTImporter::Minion::Imported(clang::Decl *from,
+void ClangASTImporter::Minion::Imported(clang::Decl *from,
                                                 clang::Decl *to) {
   ClangASTMetrics::RegisterClangImport();
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
   lldb::user_id_t user_id = LLDB_INVALID_UID;
   ClangASTMetadata *metadata = m_master.GetDeclMetadata(from);
   if (metadata)
if (log) {
         log->Printf(
             "    [ClangASTImporter] To is an %sDecl - attributes %s%s",
             ((Decl *)to_container_decl)->getDeclKindName(),
             (to_container_decl->hasExternalLexicalStorage() ? " Lexical" : ""),
             (to_container_decl->hasExternalVisibleStorage() ? " Visible" : ""));
       }
     }
   }
-
-  return clang::ASTImporter::Imported(from, to);
 }
 
 clang::Decl *ClangASTImporter::Minion::GetOriginalDecl(clang::Decl *To) {
   ASTContextMetadataSP to_context_md =
       m_master.GetContextMetadata(&To->getASTContext());
 
   if (!to_context_md)
     return nullptr;
 
   OriginMap::iterator iter = to_context_md->m_origins.find(To);
 
   if (iter == to_context_md->m_origins.end())
     return nullptr;
 
   return const_cast<clang::Decl *>(iter->second.decl);
 }