Revert "[clang-repl] Introduce Value to capture expression results"

This reverts commit a423b7f1d7ca8b263af85944f57a69aa08fc942c.
See https://lab.llvm.org/buildbot/#/changes/95083

2 files changed, 11 insertions, 231 deletions

diff --git a/clang/include/clang/Interpreter/Interpreter.h b/clang/include/clang/Interpreter/Interpreter.h
index e680218452d1..b3d64458d777 100644
--- a/clang/include/clang/Interpreter/Interpreter.h
+++ b/clang/include/clang/Interpreter/Interpreter.h
@@ -14,15 +14,14 @@
 #ifndef LLVM_CLANG_INTERPRETER_INTERPRETER_H
 #define LLVM_CLANG_INTERPRETER_INTERPRETER_H
 
-#include "clang/AST/Decl.h"
-#include "clang/AST/GlobalDecl.h"
 #include "clang/Interpreter/PartialTranslationUnit.h"
-#include "clang/Interpreter/Value.h"
 
-#include "llvm/ADT/DenseMap.h"
+#include "clang/AST/GlobalDecl.h"
+
 #include "llvm/ExecutionEngine/JITSymbol.h"
 #include "llvm/ExecutionEngine/Orc/Shared/ExecutorAddress.h"
 #include "llvm/Support/Error.h"
+
 #include <memory>
 #include <vector>
 
@@ -55,26 +54,24 @@ class Interpreter {
   Interpreter(std::unique_ptr<CompilerInstance> CI, llvm::Error &Err);
 
   llvm::Error CreateExecutor();
-  unsigned InitPTUSize = 0;
-
-  // This member holds the last result of the value printing. It's a class
-  // member because we might want to access it after more inputs. If no value
-  // printing happens, it's in an invalid state.
-  Value LastValue;
 
 public:
   ~Interpreter();
   static llvm::Expected<std::unique_ptr<Interpreter>>
   create(std::unique_ptr<CompilerInstance> CI);
-  const ASTContext &getASTContext() const;
-  ASTContext &getASTContext();
   const CompilerInstance *getCompilerInstance() const;
   llvm::Expected<llvm::orc::LLJIT &> getExecutionEngine();
 
   llvm::Expected<PartialTranslationUnit &> Parse(llvm::StringRef Code);
   llvm::Error Execute(PartialTranslationUnit &T);
-  llvm::Error ParseAndExecute(llvm::StringRef Code, Value *V = nullptr);
-  llvm::Expected<llvm::orc::ExecutorAddr> CompileDtorCall(CXXRecordDecl *CXXRD);
+  llvm::Error ParseAndExecute(llvm::StringRef Code) {
+    auto PTU = Parse(Code);
+    if (!PTU)
+      return PTU.takeError();
+    if (PTU->TheModule)
+      return Execute(*PTU);
+    return llvm::Error::success();
+  }
 
   /// Undo N previous incremental inputs.
   llvm::Error Undo(unsigned N = 1);
@@ -95,23 +92,6 @@ public:
   /// file.
   llvm::Expected<llvm::orc::ExecutorAddr>
   getSymbolAddressFromLinkerName(llvm::StringRef LinkerName) const;
-
-  enum InterfaceKind { NoAlloc, WithAlloc, CopyArray };
-
-  const llvm::SmallVectorImpl<Expr *> &getValuePrintingInfo() const {
-    return ValuePrintingInfo;
-  }
-
-  Expr *SynthesizeExpr(Expr *E);
-
-private:
-  size_t getEffectivePTUSize() const;
-
-  bool FindRuntimeInterface();
-
-  llvm::DenseMap<CXXRecordDecl *, llvm::orc::ExecutorAddr> Dtors;
-
-  llvm::SmallVector<Expr *, 3> ValuePrintingInfo;
 };
 } // namespace clang
 
diff --git a/clang/include/clang/Interpreter/Value.h b/clang/include/clang/Interpreter/Value.h
deleted file mode 100644
index 90a0097e5cc3..000000000000
--- a/clang/include/clang/Interpreter/Value.h
+++ /dev/null
@@ -1,200 +0,0 @@
-//===--- Value.h - Definition of interpreter value --------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// Value is a lightweight struct that is used for carrying execution results in
-// clang-repl. It's a special runtime that acts like a messager between compiled
-// code and interpreted code. This makes it possible to exchange interesting
-// information between the compiled & interpreted world.
-//
-// A typical usage is like the below:
-//
-// Value V;
-// Interp.ParseAndExecute("int x = 42;");
-// Interp.ParseAndExecute("x", &V);
-// V.getType(); // <-- Yields a clang::QualType.
-// V.getInt(); // <-- Yields 42.
-//
-// The current design is still highly experimental and nobody should rely on the
-// API being stable because we're hopefully going to make significant changes to
-// it in the relatively near future. For example, Value also intends to be used
-// as an exchange token for JIT support enabling remote execution on the embed
-// devices where the JIT infrastructure cannot fit. To support that we will need
-// to split the memory storage in a different place and perhaps add a resource
-// header is similar to intrinsics headers which have stricter performance
-// constraints.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_CLANG_INTERPRETER_VALUE_H
-#define LLVM_CLANG_INTERPRETER_VALUE_H
-
-#include <cstdint>
-// NOTE: Since the REPL itself could also include this runtime, extreme caution
-// should be taken when MAKING CHANGES to this file, especially when INCLUDE NEW
-// HEADERS, like <string>, <memory> and etc. (That pulls a large number of
-// tokens and will impact the runtime performance of the REPL)
-
-namespace llvm {
-class raw_ostream;
-
-} // namespace llvm
-
-namespace clang {
-
-class ASTContext;
-class Interpreter;
-class QualType;
-
-#if __has_attribute(visibility) &&                                             \
-    (!(defined(_WIN32) || defined(__CYGWIN__)) ||                              \
-     (defined(__MINGW32__) && defined(__clang__)))
-#if defined(LLVM_BUILD_LLVM_DYLIB) || defined(LLVM_BUILD_SHARED_LIBS)
-#define REPL_EXTERNAL_VISIBILITY __attribute__((visibility("default")))
-#else
-#define REPL_EXTERNAL_VISIBILITY
-#endif
-#else
-#if defined(_WIN32)
-#define REPL_EXTERNAL_VISIBILITY __declspec(dllexport)
-#endif
-#endif
-
-#define REPL_BUILTIN_TYPES                                                     \
-  X(bool, Bool)                                                                \
-  X(char, Char_S)                                                              \
-  X(signed char, SChar)                                                        \
-  X(unsigned char, UChar)                                                      \
-  X(short, Short)                                                              \
-  X(unsigned short, UShort)                                                    \
-  X(int, Int)                                                                  \
-  X(unsigned int, UInt)                                                        \
-  X(long, Long)                                                                \
-  X(unsigned long, ULong)                                                      \
-  X(long long, LongLong)                                                       \
-  X(unsigned long long, ULongLong)                                             \
-  X(float, Float)                                                              \
-  X(double, Double)                                                            \
-  X(long double, LongDouble)
-
-class REPL_EXTERNAL_VISIBILITY Value {
-  union Storage {
-#define X(type, name) type m_##name;
-    REPL_BUILTIN_TYPES
-#undef X
-    void *m_Ptr;
-  };
-
-public:
-  enum Kind {
-#define X(type, name) K_##name,
-    REPL_BUILTIN_TYPES
-#undef X
-
-        K_Void,
-    K_PtrOrObj,
-    K_Unspecified
-  };
-
-  Value() = default;
-  Value(Interpreter *In, void *Ty);
-  Value(const Value &RHS);
-  Value(Value &&RHS) noexcept;
-  Value &operator=(const Value &RHS);
-  Value &operator=(Value &&RHS) noexcept;
-  ~Value();
-
-  void printType(llvm::raw_ostream &Out) const;
-  void printData(llvm::raw_ostream &Out) const;
-  void print(llvm::raw_ostream &Out) const;
-  void dump() const;
-  void clear();
-
-  ASTContext &getASTContext();
-  const ASTContext &getASTContext() const;
-  Interpreter &getInterpreter();
-  const Interpreter &getInterpreter() const;
-  QualType getType() const;
-
-  bool isValid() const { return ValueKind != K_Unspecified; }
-  bool isVoid() const { return ValueKind == K_Void; }
-  bool hasValue() const { return isValid() && !isVoid(); }
-  bool isManuallyAlloc() const { return IsManuallyAlloc; }
-  Kind getKind() const { return ValueKind; }
-  void setKind(Kind K) { ValueKind = K; }
-  void setOpaqueType(void *Ty) { OpaqueType = Ty; }
-
-  void *getPtr() const;
-  void setPtr(void *Ptr) { Data.m_Ptr = Ptr; }
-
-#define X(type, name)                                                          \
-  void set##name(type Val) { Data.m_##name = Val; }                            \
-  type get##name() const { return Data.m_##name; }
-  REPL_BUILTIN_TYPES
-#undef X
-
-  /// \brief Get the value with cast.
-  //
-  /// Get the value cast to T. This is similar to reinterpret_cast<T>(value),
-  /// casting the value of builtins (except void), enums and pointers.
-  /// Values referencing an object are treated as pointers to the object.
-  template <typename T> T convertTo() const {
-    return convertFwd<T>::cast(*this);
-  }
-
-protected:
-  bool isPointerOrObjectType() const { return ValueKind == K_PtrOrObj; }
-
-  /// \brief Get to the value with type checking casting the underlying
-  /// stored value to T.
-  template <typename T> T as() const {
-    switch (ValueKind) {
-    default:
-      return T();
-#define X(type, name)                                                          \
-  case Value::K_##name:                                                        \
-    return (T)Data.m_##name;
-      REPL_BUILTIN_TYPES
-#undef X
-    }
-  }
-
-  // Allow convertTo to be partially specialized.
-  template <typename T> struct convertFwd {
-    static T cast(const Value &V) {
-      if (V.isPointerOrObjectType())
-        return (T)(uintptr_t)V.as<void *>();
-      if (!V.isValid() || V.isVoid()) {
-        return T();
-      }
-      return V.as<T>();
-    }
-  };
-
-  template <typename T> struct convertFwd<T *> {
-    static T *cast(const Value &V) {
-      if (V.isPointerOrObjectType())
-        return (T *)(uintptr_t)V.as<void *>();
-      return nullptr;
-    }
-  };
-
-  Interpreter *Interp = nullptr;
-  void *OpaqueType = nullptr;
-  Storage Data;
-  Kind ValueKind = K_Unspecified;
-  bool IsManuallyAlloc = false;
-};
-
-template <> inline void *Value::as() const {
-  if (isPointerOrObjectType())
-    return Data.m_Ptr;
-  return (void *)as<uintptr_t>();
-}
-
-} // namespace clang
-#endif