[NFC][CIFactory] Make ASTConsumer optional for autocomplete paths

Author: devajithvs

core/dictgen/src/LinkdefReader.cxx

@@ -1058,9 +1058,9 @@ bool LinkdefReader::Parse(SelectionRules &sr, llvm::StringRef code, const std::v
 
    // Extract all #pragmas
    std::unique_ptr<llvm::MemoryBuffer> memBuf = llvm::MemoryBuffer::getMemBuffer(code, "CLING #pragma extraction");
-   clang::CompilerInstance *pragmaCI = cling::CIFactory::createCI(std::move(memBuf), parserArgsC.size(),
-                                                                  &parserArgsC[0], llvmdir, nullptr /*Consumer*/,
-                                                                  {} /*ModuleFileExtension*/, true /*OnlyLex*/);
+   clang::CompilerInstance *pragmaCI =
+      cling::CIFactory::createCI(std::move(memBuf), parserArgsC.size(), &parserArgsC[0], llvmdir,
+                                 std::nullopt /*Consumer*/, {} /*ModuleFileExtension*/, true /*OnlyLex*/);
 
    clang::Preprocessor &PP = pragmaCI->getPreprocessor();
    clang::DiagnosticConsumer &DClient = pragmaCI->getDiagnosticClient();

interpreter/cling/include/cling/Interpreter/CIFactory.h

@@ -37,13 +37,15 @@ namespace cling {
 
     clang::CompilerInstance*
     createCI(llvm::StringRef Code, const InvocationOptions& Opts,
-             const char* LLVMDir, std::unique_ptr<clang::ASTConsumer> consumer,
+             const char* LLVMDir,
+             std::optional<std::unique_ptr<clang::ASTConsumer>> consumerOpt,
              const ModuleFileExtensions& moduleExtensions,
              bool AutoComplete = false);
 
     clang::CompilerInstance*
     createCI(MemBufPtr_t Buffer, int Argc, const char* const* Argv,
-             const char* LLVMDir, std::unique_ptr<clang::ASTConsumer> consumer,
+             const char* LLVMDir,
+             std::optional<std::unique_ptr<clang::ASTConsumer>> consumerOpt,
              const ModuleFileExtensions& moduleExtensions,
              bool OnlyLex = false);
   } // namespace CIFactory

interpreter/cling/lib/Interpreter/CIFactory.cpp

@@ -1700,7 +1700,7 @@ namespace {
 
     std::vector<std::unique_ptr<ASTConsumer>> Consumers;
 
-    if (!OnlyLex) {
+    if (!OnlyLex && !AutoComplete) {
       assert(customConsumer && "Need to specify a custom consumer"
                                " when not in OnlyLex mode");
       Consumers.push_back(std::move(customConsumer));
@@ -1834,25 +1834,27 @@ namespace {
 
 namespace cling {
 
-  CompilerInstance*
-  CIFactory::createCI(llvm::StringRef Code, const InvocationOptions& Opts,
-                      const char* LLVMDir,
-                      std::unique_ptr<clang::ASTConsumer> consumer,
-                      const ModuleFileExtensions& moduleExtensions,
-                      bool AutoComplete /*false*/) {
+  CompilerInstance* CIFactory::createCI(
+      llvm::StringRef Code, const InvocationOptions& Opts, const char* LLVMDir,
+      std::optional<std::unique_ptr<clang::ASTConsumer>> consumerOpt,
+      const ModuleFileExtensions& moduleExtensions,
+      bool AutoComplete /*false*/) {
     return createCIImpl(llvm::MemoryBuffer::getMemBuffer(Code),
-                        Opts.CompilerOpts, LLVMDir, std::move(consumer),
+                        Opts.CompilerOpts, LLVMDir,
+                        consumerOpt ? std::move(*consumerOpt) : nullptr,
                         moduleExtensions, false /*OnlyLex*/,
                         !Opts.IsInteractive(), AutoComplete);
   }
 
-CompilerInstance* CIFactory::createCI(
-    MemBufPtr_t Buffer, int argc, const char* const* argv, const char* LLVMDir,
-    std::unique_ptr<clang::ASTConsumer> consumer,
-    const ModuleFileExtensions& moduleExtensions, bool OnlyLex /*false*/) {
-  return createCIImpl(std::move(Buffer), CompilerOptions(argc, argv),  LLVMDir,
-                      std::move(consumer), moduleExtensions, OnlyLex);
-}
+  CompilerInstance* CIFactory::createCI(
+      MemBufPtr_t Buffer, int argc, const char* const* argv,
+      const char* LLVMDir,
+      std::optional<std::unique_ptr<clang::ASTConsumer>> consumerOpt,
+      const ModuleFileExtensions& moduleExtensions, bool OnlyLex /*false*/) {
+    return createCIImpl(std::move(Buffer), CompilerOptions(argc, argv), LLVMDir,
+                        consumerOpt ? std::move(*consumerOpt) : nullptr,
+                        moduleExtensions, OnlyLex);
+  }
 
 } // namespace cling
 

interpreter/cling/lib/Interpreter/IncrementalParser.cpp

@@ -293,7 +293,8 @@ namespace cling {
     std::unique_ptr<cling::DeclCollector> consumer;
     consumer.reset(m_Consumer = new cling::DeclCollector());
     m_CI.reset(CIFactory::createCI("\n", interp->getOptions(), llvmdir,
-                                   std::move(consumer), moduleExtensions));
+                                   std::make_optional(std::move(consumer)),
+                                   moduleExtensions));
 
     if (!m_CI) {
       cling::errs() << "Compiler instance could not be created.\n";

interpreter/cling/lib/Interpreter/Interpreter.cpp

@@ -1036,12 +1036,11 @@ namespace cling {
     std::string llvmDir = parentResourceDir.str();
 
     // arguments for constructing CI
-    auto declCollector = std::make_unique<cling::DeclCollector>();
     const ModuleFileExtensions& moduleExtensions = {};
 
     auto InterpCI = std::unique_ptr<clang::CompilerInstance>(
-        CIFactory::createCI("\n", getOptions(), llvmDir.c_str(),
-                            std::move(declCollector), moduleExtensions,
+        CIFactory::createCI("\n", getOptions(), llvmDir.c_str(), std::nullopt,
+                            moduleExtensions,
                             /*AutoComplete=*/true));
 
     auto CC = ClingCodeCompleter();