Add Code Completion

Author: alexander-penev

include/clang/Interpreter/CppInterOp.h

@@ -648,6 +648,12 @@ namespace Cpp {
   CPPINTEROP_API std::string EndStdStreamCapture();
 
   ///@}
+
+  /// Append all Code completion suggestions to Results.
+  ///\param[in] code - code fragmet to complete
+  ///\param[out] Results - CC suggestions for code fragment. Suggestions are appended.
+  CPPINTEROP_API void CodeComplete(const char* code, std::vector<std::string>& Results);
+
 } // end namespace Cpp
 
 #endif // CPPINTEROP_CPPINTEROP_H

lib/Interpreter/CMakeLists.txt

@@ -3,9 +3,16 @@ set(LLVM_LINK_COMPONENTS
   BinaryFormat
   Core
   Object
-  OrcJIT
+  OrcJit
   Support
 )
+# FIXME: Investigate why this needs to be conditionally included.
+if ("LLVMFrontendDriver" IN_LIST LLVM_AVAILABLE_LIBS)
+  list(APPEND LLVM_LINK_COMPONENTS  FrontendDriver)
+endif()
+if ("LLVMOrcDebugging" IN_LIST LLVM_AVAILABLE_LIBS)
+  list(APPEND LLVM_LINK_COMPONENTS OrcDebugging)
+endif()
 
 set(DLM
   DynamicLibraryManager.cpp

lib/Interpreter/Compatibility.h

@@ -10,6 +10,10 @@
 #include "clang/Basic/Version.h"
 #include "clang/Config/config.h"
 
+#if CLANG_VERSION_MAJOR >= 18
+#include "clang/Interpreter/CodeCompletion.h"
+#endif
+
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
@@ -28,6 +32,8 @@
 
 #include "cling/Utils/AST.h"
 
+#include <regex>
+
 namespace Cpp {
 namespace Cpp_utils = cling::utils;
 }
@@ -69,6 +75,27 @@ getSymbolAddress(const cling::Interpreter& I, llvm::StringRef IRName) {
   Names.push_back(Jit.getExecutionSession().intern(IRName));
   return llvm::make_error<llvm::orc::SymbolsNotFound>(Names);
 }
+
+inline void codeComplete(const cling::Interpreter& I, const char* code, std::vector<std::string>& Results) {
+  std::vector<std::string> results;
+  size_t cursor = std::string(code).size() + 1;
+  I.codeComplete(code, cursor, results);
+
+  // append cleaned results
+  for (auto& r : results) {
+    // remove the definition at the beginning (for example [#int#])
+    r = std::regex_replace(r, std::regex("\\[\\#.*\\#\\]"), "");
+    // remove the variable name in <#type name#>
+    r = std::regex_replace(r, std::regex("(\\ |\\*)+(\\w+)(\\#\\>)"), "$1$3");
+    // remove unnecessary space at the end of <#type   #>
+    r = std::regex_replace(r, std::regex("\\ *(\\#\\>)"), "$1");
+    // remove <# #> to keep only the type
+    r = std::regex_replace(r, std::regex("\\<\\#([^#>]*)\\#\\>"), "$1");
+    if (r.find(code) == 0)
+      Results.push_back(r);
+  }
+}
+
 } // namespace compat
 
 #endif // USE_CLING
@@ -184,6 +211,7 @@ inline void maybeMangleDeclName(const clang::GlobalDecl& GD,
 // Clang 14 - Add new Interpreter methods: getExecutionEngine,
 //            getSymbolAddress, getSymbolAddressFromLinkerName
 // Clang 15 - Add new Interpreter methods: Undo
+// Clang 18 - Add new Interpreter methods: CodeComplete
 
 inline llvm::orc::LLJIT* getExecutionEngine(clang::Interpreter& I) {
 #if CLANG_VERSION_MAJOR >= 14
@@ -247,6 +275,34 @@ inline llvm::Error Undo(clang::Interpreter& I, unsigned N = 1) {
 #endif
 }
 
+inline void codeComplete(clang::Interpreter& I, const char* code, std::vector<std::string>& Results) {
+#if CLANG_VERSION_MAJOR >= 18
+  auto CB = clang::IncrementalCompilerBuilder();
+  auto CI = CB.CreateCpp();
+  if (auto Err = CI.takeError()) {
+    llvm::logAllUnhandledErrors(std::move(Err), llvm::errs(), "error: ");
+    return;
+  }
+  auto Interp = clang::Interpreter::create(std::move(*CI));
+  if (auto Err = Interp.takeError()) {
+    llvm::logAllUnhandledErrors(std::move(Err), llvm::errs(), "error: ");
+    return;
+  }
+
+  std::vector<std::string> results;
+  std::vector<std::string> Comps;
+  clang::CompilerInstance *MainCI = (*Interp)->getCompilerInstance();
+  auto CC = clang::ReplCodeCompleter();
+  CC.codeComplete(MainCI, code, /* Lines */ 1, std::string(code).size() + 1,
+                  I.getCompilerInstance(), results);
+  for (auto r : results)
+    if (r.find(CC.Prefix) == 0)
+      Results.push_back(r);
+#else
+  assert(false && "CodeCompletion API only available in Clang >= 18.");
+#endif
+}
+
 } // namespace compat
 
 #include "CppInterOpInterpreter.h"

lib/Interpreter/CppInterOp.cpp

@@ -3257,4 +3257,9 @@ namespace Cpp {
     return result;
   }
 
+  void CodeComplete(const char* code, std::vector<std::string>& Results) {
+    compat::codeComplete(getInterp(), code, Results);
+  }
+
+
   } // end namespace Cpp

unittests/CppInterOp/InterpreterTest.cpp

@@ -1,11 +1,15 @@
 #include "clang/Interpreter/CppInterOp.h"
 
+#include "clang/Basic/Version.h"
+
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/Path.h"
 
 #include <gmock/gmock.h>
 #include "gtest/gtest.h"
 
+#include <algorithm>
+
 using ::testing::StartsWith;
 
 TEST(InterpreterTest, Version) {
@@ -103,3 +107,19 @@ TEST(InterpreterTest, DetectSystemCompilerIncludePaths) {
   Cpp::DetectSystemCompilerIncludePaths(includes);
   EXPECT_FALSE(includes.empty());
 }
+
+TEST(InterpreterTest, CodeCompletion) {
+#if CLANG_VERSION_MAJOR >= 18 || USE_CLING
+  std::vector<std::string> cc;
+  Cpp::Declare("int foo = 12;");
+  Cpp::CodeComplete("f", cc);
+  size_t cnt = 0;
+  for (auto& r : cc) {
+    if (r == "float" || r == "foo") cnt++;
+    printf("!!!%s", r.c_str());
+  }
+  EXPECT_EQ(2U, cnt); // float and foo
+#else
+  GTEST_SKIP();
+#endif
+}