Fixing creation of Interpreter

Author: anutosh491

lib/Interpreter/CXCppInterOp.cpp

@@ -271,8 +271,15 @@ static inline compat::Interpreter* getInterpreter(const CXInterpreterImpl* I) {
 }
 
 CXInterpreter clang_createInterpreter(const char* const* argv, int argc) {
-  auto* I = new CXInterpreterImpl(); // NOLINT(*-owning-memory)
+  auto I = std::make_unique<CXInterpreterImpl>(); // NOLINT(*-owning-memory)
+#ifdef CPPINTEROP_USE_CLING
   I->Interp = std::make_unique<compat::Interpreter>(argc, argv);
+#else
+  I->Interp = compat::Interpreter::create(argc, argv);
+  if (!I->Interp) {
+    return nullptr;
+  }
+#endif
   // create a bridge between CXTranslationUnit and clang::Interpreter
   // auto AU = std::make_unique<ASTUnit>(false);
   // AU->FileMgr = I->Interp->getCompilerInstance().getFileManager();
@@ -281,7 +288,7 @@ CXInterpreter clang_createInterpreter(const char* const* argv, int argc) {
   // AU->Ctx = &I->Interp->getSema().getASTContext();
   // I->TU.reset(MakeCXTranslationUnit(static_cast<CIndexer*>(clang_createIndex(0,
   // 0)), AU));
-  return I;
+  return I.release();
 }
 
 CXInterpreter clang_createInterpreterFromRawPtr(TInterp_t I) {

lib/Interpreter/Compatibility.h

@@ -294,9 +294,11 @@ createClangInterpreter(std::vector<const char*>& args) {
     return nullptr;
   }
   if (CudaEnabled) {
-    if (auto Err = (*innerOrErr)->LoadDynamicLibrary("libcudart.so"))
+    if (auto Err = (*innerOrErr)->LoadDynamicLibrary("libcudart.so")) {
       llvm::logAllUnhandledErrors(std::move(Err), llvm::errs(),
                                   "Failed load libcudart.so runtime:");
+      return nullptr;
+    }
   }
 
   return std::move(*innerOrErr);

lib/Interpreter/CppInterOp.cpp

@@ -2957,7 +2957,15 @@ namespace Cpp {
                    std::back_inserter(ClingArgv),
                    [&](const std::string& str) { return str.c_str(); });
 
+#ifdef CPPINTEROP_USE_CLING
     auto I = new compat::Interpreter(ClingArgv.size(), &ClingArgv[0]);
+#else
+    auto Interp = compat::Interpreter::create(
+        static_cast<int>(ClingArgv.size()), ClingArgv.data());
+    if (!Interp)
+      return nullptr;
+    auto* I = Interp.release();
+#endif
 
     // Honor -mllvm.
     //

lib/Interpreter/CppInterOpInterpreter.h

@@ -136,11 +136,14 @@ class Interpreter {
 private:
   std::unique_ptr<clang::Interpreter> inner;
 
+  Interpreter(std::unique_ptr<clang::Interpreter> CI) : inner(std::move(CI)) {}
+
 public:
-  Interpreter(int argc, const char* const* argv, const char* llvmdir = 0,
-              const std::vector<std::shared_ptr<clang::ModuleFileExtension>>&
-                  moduleExtensions = {},
-              void* extraLibHandle = 0, bool noRuntime = true) {
+  static std::unique_ptr<Interpreter>
+  create(int argc, const char* const* argv, const char* llvmdir = nullptr,
+         const std::vector<std::shared_ptr<clang::ModuleFileExtension>>&
+             moduleExtensions = {},
+         void* extraLibHandle = nullptr, bool noRuntime = true) {
     // Initialize all targets (required for device offloading)
     llvm::InitializeAllTargetInfos();
     llvm::InitializeAllTargets();
@@ -150,7 +153,13 @@ class Interpreter {
     std::vector<const char*> vargs(argv + 1, argv + argc);
     vargs.push_back("-include");
     vargs.push_back("new");
-    inner = compat::createClangInterpreter(vargs);
+    auto CI = compat::createClangInterpreter(vargs);
+    if (!CI) {
+      llvm::errs() << "Interpreter creation failed\n";
+      return nullptr;
+    }
+
+    return std::unique_ptr<Interpreter>(new Interpreter(std::move(CI)));
   }
 
   ~Interpreter() {}

unittests/CppInterOp/CUDATest.cpp

@@ -13,7 +13,7 @@ static bool HasCudaSDK() {
     // FIXME: Enable this for cling.
     return false;
 #endif // CLANG_VERSION_MAJOR < 16
-    Cpp::CreateInterpreter({}, {"--cuda"});
+    if(!Cpp::CreateInterpreter({}, {"--cuda"})) return false;
     return Cpp::Declare("__global__ void test_func() {}"
                         "test_func<<<1,1>>>();") == 0;
   };
@@ -30,7 +30,7 @@ static bool HasCudaRuntime() {
     if (!HasCudaSDK())
       return false;
 
-    Cpp::CreateInterpreter({}, {"--cuda"});
+    if(!Cpp::CreateInterpreter({}, {"--cuda"})) return false;
     if (Cpp::Declare("__global__ void test_func() {}"
                      "test_func<<<1,1>>>();"))
       return false;