Revert "[NFC][cling] Add CreateCI to match upstream structure"

This reverts commit 1a2ed14. It
introduced a stack-use-after-scope because the Compilation has a
reference to the Driver (on the stack). I tried moving back only
these two variables and pass CC1Args to CreateCI, but that does
not work either because it needs a DiagnosticsEngine. For now I
don't see a good way out, so revert this refactoring to solve the
concrete issue.

Author: hahnjo

interpreter/cling/lib/Interpreter/CIFactory.cpp

@@ -42,7 +42,6 @@
 #include "llvm/Config/llvm-config.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/Option/ArgList.h"
-#include "llvm/Support/Error.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
@@ -1256,54 +1255,6 @@ namespace {
     }
   }
 
-  // Goal is to make this as close to the function in
-  // clang/lib/Interpreter/Interpreter.cpp taking only clang arguments
-  static llvm::Expected<std::unique_ptr<CompilerInstance>>
-  CreateCI(const std::vector<const char*>& ClangArgv,
-           const std::string& ExeName,
-           std::unique_ptr<clang::driver::Compilation>& Compilation) {
-    auto InvocationPtr = std::make_shared<clang::CompilerInvocation>();
-
-    // The compiler invocation is the owner of the diagnostic options.
-    // Everything else points to them.
-    DiagnosticOptions& DiagOpts = InvocationPtr->getDiagnosticOpts();
-    llvm::IntrusiveRefCntPtr<DiagnosticsEngine> Diags =
-        SetupDiagnostics(DiagOpts, ExeName);
-    if (!Diags)
-      return llvm::createStringError(llvm::errc::not_supported,
-                                     "Could not setup diagnostic engine.");
-
-    llvm::Triple TheTriple(llvm::sys::getProcessTriple());
-    clang::driver::Driver Drvr(ClangArgv[0], TheTriple.getTriple(), *Diags);
-    // Drvr.setWarnMissingInput(false);
-    Drvr.setCheckInputsExist(false); // think foo.C(12)
-    llvm::ArrayRef<const char*> RF(&(ClangArgv[0]), ClangArgv.size());
-    Compilation.reset(Drvr.BuildCompilation(RF));
-    if (!Compilation)
-      return llvm::createStringError(
-          llvm::errc::not_supported,
-          "Couldn't create clang::driver::Compilation.");
-
-    const llvm::opt::ArgStringList* CC1Args =
-        GetCC1Arguments(Compilation.get());
-    if (!CC1Args)
-      return llvm::createStringError(llvm::errc::not_supported,
-                                     "Could not get cc1 arguments.");
-
-    clang::CompilerInvocation::CreateFromArgs(*InvocationPtr, *CC1Args, *Diags);
-    // We appreciate the error message about an unknown flag (or do we? if not
-    // we should switch to a different DiagEngine for parsing the flags).
-    // But in general we'll happily go on.
-    Diags->Reset();
-
-    // Create and setup a compiler instance.
-    std::unique_ptr<CompilerInstance> CI(new CompilerInstance());
-    CI->setInvocation(InvocationPtr);
-    CI->setDiagnostics(Diags.get()); // Diags is ref-counted
-
-    return CI;
-  }
-
   static CompilerInstance*
   createCIImpl(std::unique_ptr<llvm::MemoryBuffer> Buffer,
                const CompilerOptions& COpts, const char* LLVMDir,
@@ -1466,27 +1417,53 @@ namespace {
       argvCompile.push_back("<<< cling interactive line includer >>>");
     }
 
+    auto InvocationPtr = std::make_shared<clang::CompilerInvocation>();
+
+    // The compiler invocation is the owner of the diagnostic options.
+    // Everything else points to them.
+    DiagnosticOptions& DiagOpts = InvocationPtr->getDiagnosticOpts();
     // add prefix to diagnostic messages if second compiler instance is existing
     // e.g. in CUDA mode
     std::string ExeName = "";
     if (COpts.CUDAHost)
       ExeName = "cling";
     if (COpts.CUDADevice)
       ExeName = "cling-ptx";
+    llvm::IntrusiveRefCntPtr<DiagnosticsEngine> Diags =
+        SetupDiagnostics(DiagOpts, ExeName);
+    if (!Diags) {
+      cling::errs() << "Could not setup diagnostic engine.\n";
+      return nullptr;
+    }
 
-    std::unique_ptr<clang::driver::Compilation> Compilation;
+    llvm::Triple TheTriple(llvm::sys::getProcessTriple());
+    clang::driver::Driver Drvr(argv[0], TheTriple.getTriple(), *Diags);
+    //Drvr.setWarnMissingInput(false);
+    Drvr.setCheckInputsExist(false); // think foo.C(12)
+    llvm::ArrayRef<const char*>RF(&(argvCompile[0]), argvCompile.size());
+    std::unique_ptr<clang::driver::Compilation>
+      Compilation(Drvr.BuildCompilation(RF));
+    if (!Compilation) {
+      cling::errs() << "Couldn't create clang::driver::Compilation.\n";
+      return nullptr;
+    }
 
-    auto CIOrErr = CreateCI(argvCompile, ExeName, Compilation);
-    if (auto Err = CIOrErr.takeError()) {
-      llvm::logAllUnhandledErrors(std::move(Err), cling::errs());
+    const llvm::opt::ArgStringList* CC1Args = GetCC1Arguments(Compilation.get());
+    if (!CC1Args) {
+      cling::errs() << "Could not get cc1 arguments.\n";
       return nullptr;
     }
-    std::unique_ptr<clang::CompilerInstance> CI = std::move(*CIOrErr);
 
-    DiagnosticsEngine& Diags = CI->getDiagnostics();
-    CompilerInvocation& Invocation = CI->getInvocation();
-    DiagnosticOptions& DiagOpts = Invocation.getDiagnosticOpts();
+    clang::CompilerInvocation::CreateFromArgs(*InvocationPtr, *CC1Args, *Diags);
+    // We appreciate the error message about an unknown flag (or do we? if not
+    // we should switch to a different DiagEngine for parsing the flags).
+    // But in general we'll happily go on.
+    Diags->Reset();
 
+    // Create and setup a compiler instance.
+    std::unique_ptr<CompilerInstance> CI(new CompilerInstance());
+    CI->setInvocation(InvocationPtr);
+    CI->setDiagnostics(Diags.get()); // Diags is ref-counted
     if (!OnlyLex)
       CI->getDiagnosticOpts().ShowColors =
         llvm::sys::Process::StandardOutIsDisplayed() ||
@@ -1499,9 +1476,9 @@ namespace {
     // Copied from CompilerInstance::createDiagnostics:
     // Chain in -verify checker, if requested.
     if (DiagOpts.VerifyDiagnostics)
-      Diags.setClient(new clang::VerifyDiagnosticConsumer(Diags));
+      Diags->setClient(new clang::VerifyDiagnosticConsumer(*Diags));
     // Configure our handling of diagnostics.
-    ProcessWarningOptions(Diags, DiagOpts);
+    ProcessWarningOptions(*Diags, DiagOpts);
 
     if (COpts.HasOutput && !OnlyLex) {
       ActionScan scan(clang::driver::Action::PrecompileJobClass,
@@ -1514,13 +1491,14 @@ namespace {
       if (!SetupCompiler(CI.get(), COpts))
         return nullptr;
 
-      ProcessWarningOptions(Diags, DiagOpts);
+      ProcessWarningOptions(*Diags, DiagOpts);
       return CI.release();
     }
 
     IntrusiveRefCntPtr<llvm::vfs::OverlayFileSystem> Overlay =
         new llvm::vfs::OverlayFileSystem(llvm::vfs::getRealFileSystem());
     CI->createFileManager(Overlay);
+    clang::CompilerInvocation& Invocation = CI->getInvocation();
     std::string& PCHFile = Invocation.getPreprocessorOpts().ImplicitPCHInclude;
     bool InitLang = true, InitTarget = true;
     if (!PCHFile.empty()) {
@@ -1572,14 +1550,14 @@ namespace {
           // When running interactively pass on the info that the PCH
           // has failed so that IncrmentalParser::Initialize won't try again.
           if (!HasInput && llvm::sys::Process::StandardInIsUserInput()) {
-            const unsigned ID =
-                Diags.getCustomDiagID(clang::DiagnosticsEngine::Level::Error,
-                                      "Problems loading PCH: '%0'.");
-
-            Diags.Report(ID) << PCHFile;
+            const unsigned ID = Diags->getCustomDiagID(
+                                       clang::DiagnosticsEngine::Level::Error,
+                                       "Problems loading PCH: '%0'.");
+            
+            Diags->Report(ID) << PCHFile;
             // If this was the only error, then don't let it stop anything
-            if (Diags.getClient()->getNumErrors() == 1)
-              Diags.Reset(true);
+            if (Diags->getClient()->getNumErrors() == 1)
+              Diags->Reset(true);
             // Clear the include so no one else uses it.
             std::string().swap(PCHFile);
           }