Store state

Author: vgvassilev

clang/include/clang/AST/ASTContext.h

@@ -1066,6 +1066,8 @@ class ASTContext : public RefCountedBase<ASTContext> {
   Module *getCurrentNamedModule() const { return CurrentCXXNamedModule; }
 
   TranslationUnitDecl *getTranslationUnitDecl() const {
+    assert(TUDecl->getMostRecentDecl() == TUDecl &&
+           "The active TU is not current one!");
     return TUDecl->getMostRecentDecl();
   }
   void addTranslationUnitDecl() {

clang/include/clang/Interpreter/Interpreter.h

@@ -94,6 +94,14 @@ class Interpreter {
   Value LastValue;
 
 public:
+  class SynthesizingCodeRAII {
+
+  };
+
+  SynthesizingCodeRAII EnterCodeSynthesisScope() {
+
+  }
+
   ~Interpreter();
   static llvm::Expected<std::unique_ptr<Interpreter>>
   create(std::unique_ptr<CompilerInstance> CI);
@@ -142,6 +150,8 @@ class Interpreter {
 
   std::unique_ptr<llvm::Module> GenModule();
 
+  
+
 private:
   size_t getEffectivePTUSize() const;
 

clang/lib/Interpreter/IncrementalExecutor.cpp

@@ -65,10 +65,6 @@ IncrementalExecutor::IncrementalExecutor(llvm::orc::ThreadSafeContext &TSC,
 
 IncrementalExecutor::~IncrementalExecutor() {}
 
-llvm::Error IncrementalExecutor::addModule(std::unique_ptr<llvm::Module> &M) {
-  return Jit->addIRModule({std::move(M), TSCtx});
-}
-
 llvm::Error IncrementalExecutor::addModule(PartialTranslationUnit &PTU) {
   llvm::orc::ResourceTrackerSP RT =
       Jit->getMainJITDylib().createResourceTracker();

clang/lib/Interpreter/IncrementalExecutor.h

@@ -50,7 +50,6 @@ class IncrementalExecutor {
                       const clang::TargetInfo &TI);
   ~IncrementalExecutor();
 
-  llvm::Error addModule(std::unique_ptr<llvm::Module> &M);
   llvm::Error addModule(PartialTranslationUnit &PTU);
   llvm::Error removeModule(PartialTranslationUnit &PTU);
   llvm::Error runCtors() const;

clang/lib/Interpreter/Interpreter.cpp

@@ -378,22 +378,6 @@ llvm::Error Interpreter::CreateExecutor() {
   return Err;
 }
 
-llvm::Error Interpreter::ExecuteModule(std::unique_ptr<llvm::Module> &M) {
-  if (!IncrExecutor) {
-    auto Err = CreateExecutor();
-    if (Err)
-      return Err;
-  }
-  // FIXME: Add a callback to retain the llvm::Module once the JIT is done.
-  if (auto Err = IncrExecutor->addModule(M))
-    return Err;
-
-  if (auto Err = IncrExecutor->runCtors())
-    return Err;
-
-  return llvm::Error::success();
-}
-
 llvm::Error Interpreter::Execute(PartialTranslationUnit &T) {
   assert(T.TheModule);
   if (!IncrExecutor) {

clang/lib/Interpreter/InterpreterUtils.cpp

@@ -484,7 +484,7 @@ QualType GetFullyQualifiedType(QualType QT, const ASTContext &Ctx) {
   if (Prefix) {
     // We intentionally always use ETK_None, we never want
     // the keyword (humm ... what about anonymous types?)
-    QT = Ctx.getElaboratedType(ETK_None, Prefix, QT);
+    QT = Ctx.getElaboratedType(ElaboratedTypeKeyword::None, Prefix, QT);
     QT = Ctx.getQualifiedType(QT, PrefixQualifiers);
   }
   return QT;

clang/lib/Interpreter/ValuePrinter.cpp

@@ -115,9 +115,9 @@ static std::string PrintEnum(const Value &V) {
       IsFirst = false;
     }
   }
-
-  SS << " : " << PrintQualType(Ctx, ED->getIntegerType()) << " "
-     << llvm::toString(AP, /*Radix=*/10);
+  llvm::SmallString<64> APStr;
+  AP.toString(APStr, /*Radix=*/10);
+  SS << " : " << PrintQualType(Ctx, ED->getIntegerType()) << " "  << APStr;
   return Str;
 }
 
@@ -277,10 +277,15 @@ static llvm::Expected<llvm::orc::ExecutorAddr> CompileDecl(Interpreter &Interp,
   ASTConsumer &Consumer = Interp.getCompilerInstance()->getASTConsumer();
   Consumer.HandleTopLevelDecl(DeclGroupRef(D));
   Interp.getCompilerInstance()->getSema().PerformPendingInstantiations();
-  Consumer.HandleTranslationUnit(Interp.getASTContext());
+  ASTContext &C = Interp.getASTContext();
+  TranslationUnitDecl *TUPart = C.getTranslationUnitDecl();
+  assert(!TUPart->containsDecl(D) && "Decl already added!");
+  TUPart->addDecl(D);
+  Consumer.HandleTranslationUnit(C);
 
   if (std::unique_ptr<llvm::Module> M = Interp.GenModule()) {
-    if (llvm::Error Err = Interp.ExecuteModule(M))
+    PartialTranslationUnit PTU = {TUPart, std::move(M)};
+    if (llvm::Error Err = Interp.Execute(PTU))
       return Err;
     ASTNameGenerator ASTNameGen(Interp.getASTContext());
     llvm::Expected<llvm::orc::ExecutorAddr> AddrOrErr =

clang/tools/clang-repl/ClangRepl.cpp

@@ -82,10 +82,10 @@ static int checkDiagErrors(const clang::CompilerInstance *CI, bool HasError) {
 }
 
 struct ReplListCompleter {
-  clang::IncrementalCompilerBuilder &CB;
-  clang::Interpreter &MainInterp;
-  ReplListCompleter(clang::IncrementalCompilerBuilder &CB,
-                    clang::Interpreter &Interp)
+  clang::caas::IncrementalCompilerBuilder &CB;
+  clang::caas::Interpreter &MainInterp;
+  ReplListCompleter(clang::caas::IncrementalCompilerBuilder &CB,
+                    clang::caas::Interpreter &Interp)
       : CB(CB), MainInterp(Interp){};
 
   std::vector<llvm::LineEditor::Completion> operator()(llvm::StringRef Buffer,
@@ -117,7 +117,7 @@ ReplListCompleter::operator()(llvm::StringRef Buffer, size_t Pos,
 
   size_t Lines =
       std::count(Buffer.begin(), std::next(Buffer.begin(), Pos), '\n') + 1;
-  auto Interp = clang::Interpreter::create(std::move(*CI));
+  auto Interp = clang::caas::Interpreter::create(std::move(*CI));
 
   if (auto Err = Interp.takeError()) {
     // log the error and returns an empty vector;

clang/unittests/Interpreter/CodeCompletionTest.cpp

@@ -13,14 +13,14 @@
 
 using namespace clang;
 namespace {
-auto CB = clang::IncrementalCompilerBuilder();
+auto CB = clang::caas::IncrementalCompilerBuilder();
 
-static std::unique_ptr<Interpreter> createInterpreter() {
+static std::unique_ptr<caas::Interpreter> createInterpreter() {
   auto CI = cantFail(CB.CreateCpp());
-  return cantFail(clang::Interpreter::create(std::move(CI)));
+  return cantFail(caas::Interpreter::create(std::move(CI)));
 }
 
-static std::vector<std::string> runComp(clang::Interpreter &MainInterp,
+static std::vector<std::string> runComp(caas::Interpreter &MainInterp,
                                         llvm::StringRef Input,
                                         llvm::Error &ErrR) {
   auto CI = CB.CreateCpp();
@@ -29,7 +29,7 @@ static std::vector<std::string> runComp(clang::Interpreter &MainInterp,
     return {};
   }
 
-  auto Interp = clang::Interpreter::create(std::move(*CI));
+  auto Interp = caas::Interpreter::create(std::move(*CI));
   if (auto Err = Interp.takeError()) {
     // log the error and returns an empty vector;
     ErrR = std::move(Err);