[clang-repl] Implement pretty printing of custom types.

[v.g.vassilev]

Summary

This patch is the third part of the below RFC:
https://discourse.llvm.org/t/rfc-handle-execution-results-in-clang-repl/68493

• It implements Value::dump to enable pretty printing. For example:

clang-repl> int x = 42;
clang-repl> x
(int) 42

It also works for STL facilities:

clang-repl> #include <vector>
clang-repl> std::vector<int> v{1,2,3};
clang-repl> v
(std::vector<int> &) { 1, 2, 3 }

• Users can also provide their own pretty printers by writing an

overload of PrintValueRuntime(T*). For example:

clang-repl> struct S{};
clang-repl> std::string PrintValueRuntime(S* s) { return "My printer!"; }
clang-repl> S{}
clang-repl> (S) My printer!

Signed-off-by: Jun Zhang <[e-mail]>

[junaire]

Update + Rebase

[junaire]

Update

[junaire]

CHANGELOG:

1. Add constant array tests.
2. Fix misc issues.

[junaire]

Rebase

[junaire]

Update

[junaire]

Sync

[junaire]

Rebase

[junaire]

Update

[junaire]

Update

[junaire]

.

[junaire]

.

[junaire]

.

[junaire]

clang/test/Interpreter/pretty-print.cpp

108

Hi @mizvekov, do you have a clue about why it doesn't print the correct type? So in ValuePrinter.cpp:50 I dumped the type it shows:

AutoType 0x62d000533c00 'typename _MakeUniq<int>::__single_object' sugar
`-ElaboratedType 0x62d000450500 'typename _MakeUniq<int>::__single_object' sugar
  `-TypedefType 0x62d0004501e0 'std::_MakeUniq<int>::__single_object' sugar
    |-Typedef 0x62d000450160 '__single_object'
    `-ElaboratedType 0x62d000450100 'unique_ptr<int>' sugar
      `-TemplateSpecializationType 0x62d0004500b0 'unique_ptr<int>' sugar unique_ptr
        |-TemplateArgument type 'int':'int'
        | `-SubstTemplateTypeParmType 0x62d00044fd50 'int' sugar typename depth 0 index 0 _Tp
        |   |-ClassTemplateSpecialization 0x62d00044fa08 '_MakeUniq'
        |   `-BuiltinType 0x621000019220 'int'
        `-RecordType 0x62d000450080 'class std::unique_ptr<int>'
          `-ClassTemplateSpecialization 0x62d00044ff70 'unique_ptr'

But in Cling it only has the RecordType. Do you think it's affected by your type resugaring patches?

[junaire]

Fix AutoType sugar

clang/test/Interpreter/pretty-print.cpp

108

Looks like below diff fixes this:

diff --git a/clang/lib/Interpreter/InterpreterUtils.cpp b/clang/lib/Interpreter/InterpreterUtils.cpp
index 05e6be0e9df2..da5da55e8e95 100644
--- a/clang/lib/Interpreter/InterpreterUtils.cpp
+++ b/clang/lib/Interpreter/InterpreterUtils.cpp
@@ -425,7 +425,7 @@ QualType GetFullyQualifiedType(QualType QT, const ASTContext &Ctx) {
   // Strip deduced types.
   if (const auto *AutoTy = dyn_cast<AutoType>(QT.getTypePtr())) {
     if (!AutoTy->getDeducedType().isNull())
-      return GetFullyQualifiedType(AutoTy->getDeducedType(), Ctx);
+      return GetFullyQualifiedType(AutoTy->getDeducedType().getDesugaredType(Ctx), Ctx);
   }

[junaire]

Fix

[junaire]

Remove unused code.

[junaire]

Add some comments

[junaire]

Export symbols in Windows.

[junaire]

Don't use C++17 because Clang on Windows is not default to that :(

[junaire]

Add macro guard.

[junaire]

• include <tuple> to avoid incorrect lookup on Windows
• Add -Xcc -fno-delayed-template-parsing to fix failure on Windows

[junaire]

Make and use our own std::void_t

[junaire]

.

[junaire]

Invite more people to the party :)

[junaire]

.

[junaire]

add caas namespace

[junaire]

.

[v.g.vassilev]

I believe this is heading in a good direction. Here are some comments from a partial review. Also perhaps we should extend the patch description (future commit message) to capture the idea of the pretty-printing including the dispatch, the approach how we build the AST and how to write a custom printer.

clang/lib/Interpreter/Value.cpp

272

We should add some documentation for users how to write a pretty-printer for a custom class.

We do not seem to support the multiple inheritance case where one of the base classes has a pretty-printer and the other does not. See the explanation in Cling. It is okay to not have it at the moment but we should include a FIXME here saying that we do not yet support it.

clang/lib/Interpreter/ValuePrinter.cpp

202

Similarly to the way we rebuild the AST during template instantiation, when we are synthesizing AST we do not need the lexical scope information generally.

Removing this need for the parser here will allow us to remove Interpreter::getParser which we should not expose as an API at that stage.

302

I'd prefer to inline to body of CompileDecl here instead of exposing it in the interpreter class.

clang/tools/clang-repl/CMakeLists.txt

40

We should check if there is a better way to export a subset of symbols through the llvm build system. Maybe @lhames, @sunho or @sgraenitz know how.

[aaron.ballman]

I didn't have the chance to complete my review (this is a pretty massive change), but here are some in-progress comments.

clang/include/clang/Interpreter/Interpreter.h

105

const mismatch here -- should be an overload set where the const member function returns a const reference and the non-const member function returns the non-const reference. (This is true in general, I see we've got other such functions that are const-qualified but returning non-const references.)

(Not critical to fix, but would be a nice follow-up NFC to correct these sorts of things; retro-fitting const correctness is hard, so we should strive for const correct by default for new code whenever possible.)

clang/lib/Headers/__clang_interpreter_runtime_printvalue.h

2–4

er, not certain the best way to repair this, but wrapping the comment isn't it. Maybe drop the "Incremental Compilation and Execution" bit?

29

34

You should use reserved identifiers where possible so as not to conflict with user-defined macros.

51

I wonder if it makes some degree of sense to use macros to declare these, so that it's easier to see there's a consistent pattern and which types are supported. e.g.,

#define __DECL_PRINT_VALUE_RUNTIME(type) __REPL_EXTERNAL_VISIBILITY std::string PrintValueRuntime(const type *__Ptr)

__DECL_PRINT_VALUE_RUNTIME(void);
__DECL_PRINT_VALUE_RUNTIME(void *);
__DECL_PRINT_VALUE_RUNTIME(bool);
...

#undef __DECL_PRINT_VALUE_RUNTIME

I also wonder: should this header have a C interface so it can be used from a C context, or is the repl context in which this is included only ever C++?

93

97

(and so forth in this header -- basically, every identifier should be in the reserved namespace unless it's the public API being exposed.)

clang/lib/Interpreter/Interpreter.cpp

434

Any way to make this take a const Decl * instead?

clang/lib/Interpreter/InterpreterUtils.cpp

108

111

117–122

133–136

139–140

157–158

163–168

I'll stop commenting on this sort of thing; you should apply this sort of cleanup to the whole patch.

186–189

So the first case is for handling enumerations and otherwise we expect a structure or a union? Similar question below as well.

239

[junaire]

Address comments.

[junaire]

clang/lib/Interpreter/Interpreter.cpp

434

DeclGroupRef in line 439 asks a non-const Decl*, should we use const Decl* and const cast it?

clang/lib/Interpreter/Value.cpp

272

Where should I put the doc? Value.cpp is the implementation and it's unlikely for regular users to read it.

[junaire]

Remove Interpereter::getParser + More clean up

[junaire]

Rebase

[v.g.vassilev]

clang/include/clang/Interpreter/Interpreter.h

82

We should move this routine to its user in maybe ValuePrinter.cpp.

clang/tools/clang-repl/CMakeLists.txt

40

I wonder if that's related to https://reviews.llvm.org/D151620 in some way? That is, does D151620 fix our exports and this section becomes redundant?

[junaire]

Make CreateUniqName a static helper

[junaire]

clang/tools/clang-repl/CMakeLists.txt

40

I haven't tested that but I don't think so. The patch you posted is about fixing issues on particular platforms like MinGW.

[v.g.vassilev]

clang/lib/Interpreter/IncrementalParser.h

81

Is that used?

clang/lib/Interpreter/ValuePrinter.cpp

263

Let's add a FIXME here. The problem CompileDecl and GenModule intends to solve is that when we synthesize AST we need to inform the rest of the Clang infrastructure about it and attach the produced llvm::Module to the JIT so that it can resolve symbols from it.

In cling that is solved with a RAII object which marks a scope where the synthesis happens and takes care to inform the rest of the infrastructure. We need something similar and a little more robust maybe. Something like ASTSynthesisRAII which ultimately hides this machinery especially from the public API.

443

All of the PrintValueRuntime seem to be duplicating code. We could use the preprocessor to expand these to but it would require some changes which I believe could be done as a separate patch:

• Perhaps we should be compatible with cling here in terms of naming as that's a public API - there I believe we use printValue.
• We should try to leverage TemplateBase.cpp::printIntegral for integral types.
• We should not return std::string here but a const char* and we should provide somewhere storage for them. That would probably make porting to embedded systems easier since on many the <string> header is hard to support.

I believe it would be enough to have a fixme for now.

474

We could use the preprocessor the way we do in Value.cpp to expand this dispatcher.

[v.g.vassilev]

clang/lib/Interpreter/ValuePrinter.cpp

2

Please add the llvm preamble.

[junaire]

Add LLVM preamble

[junaire]

clang/lib/Interpreter/ValuePrinter.cpp

263

I can't really get the point. I agree we shouldn't expose Interpreter::GenModule as a public interface but I don't understand the solution.

443

• I'd propose using PrintValueRuntime here. This is because we have used it across RFC and other documentation so I don't want to change it :(

We should not return std::string here but a const char* and we should provide somewhere storage for them. That would probably make porting to embedded systems easier since on many the <string> header is hard to support.

• That really touches the dark corner of our design. On the one hand, we try to keep Value itself as lightweight as possible, on the other hand, we use heavy headers like <string> and <type_traits> in value pretty printing. While this is awkward, we can hardly avoid it because the implementation needs to see the definition of these types to know how to print it. So how can we do this on resources limited systems? My point is that perhaps we can keep it as is, because it's very hard to measure how expensive the feature is on the targeting platform. If the system can afford this, then we don't need to worry about anything, but if the system can't even use STL itself, presumably it shouldn't use value printing at all! Note that this doesn't conflicts with the lightness of the value runtime as it SHOULD add as little overhead as possible no matter whether the host can afford it or not.

474

We actually can't because it doesn't strictly match everything. For example Char_S and SChar both map to V.getSChar() IIUC?

[aaron.ballman]

clang/lib/Headers/__clang_interpreter_runtime_printvalue.h

2–4

Comment can be re-flowed so this no longer wraps.

45

Need to use a reserved identifier for everything so you don't conflict with user-defined macros.

51

Still wondering about the C interface question.

80

Still need to make sure you're using reserved identifiers for these (should make a pass through the file and get all of the identifiers).

82

clang/lib/Interpreter/Value.cpp

272

I'd expect we'd be updating clang/docs/ClangRepl.rst for this sort of thing.

clang/lib/Interpreter/ValuePrinter.cpp

90–91

This doesn't distinguish between lvalue and rvalue references, which seems like a mistake.

165

Not just encodings, but also: how do you handle unprintable characters (like control characters)?

544

This seems rather reachable, no?

[v.g.vassilev]

Jun has moved on in his career and I'd like to take responsibility for this patch.

[v.g.vassilev]

• Address several comments
• Make __clang_interpreter_runtime_printvalue.h C++11 compliant.
• Support std::vector<bool>
• Add more tests

[v.g.vassilev]

clang/lib/Headers/__clang_interpreter_runtime_printvalue.h

80

Could you check now, I think I fixed all I thought needed fixing.

clang/lib/Interpreter/ValuePrinter.cpp

165

Extended the FIXME.

544

Do you mean that's not exhaustive list that we list here?

[v.g.vassilev]

Add forgotten file.

clang/include/clang/Interpreter/Interpreter.h

 namespace orc {
 class LLJIT;
 class ThreadSafeContext;
 } // namespace orc
 } // namespace llvm
 
 namespace clang {
 
+class Parser;
 class CompilerInstance;
+
+namespace caas {
 class IncrementalExecutor;
 class IncrementalParser;
 
 /// Create a pre-configured \c CompilerInstance for incremental processing.
 class IncrementalCompilerBuilder {
 public:
   static llvm::Expected<std::unique_ptr<CompilerInstance>>
   create(std::vector<const char *> &ClangArgv);
public:
   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 ExecuteModule(std::unique_ptr<llvm::Module> &M);
   llvm::Error Execute(PartialTranslationUnit &T);
   llvm::Error ParseAndExecute(llvm::StringRef Code, Value *V = nullptr);
   llvm::Expected<llvm::orc::ExecutorAddr> CompileDtorCall(CXXRecordDecl *CXXRD);
+  llvm::Expected<llvm::orc::ExecutorAddr> CompileDecl(Decl *D);
+  std::string CreateUniqName(std::string Base);
 
   /// Undo N previous incremental inputs.
   llvm::Error Undo(unsigned N = 1);
 
   /// Link a dynamic library
   llvm::Error LoadDynamicLibrary(const char *name);
 
   /// \returns the \c ExecutorAddr of a \c GlobalDecl. This interface uses
   /// the CodeGenModule's internal mangling cache to avoid recomputing the
   /// mangled name.
   llvm::Expected<llvm::orc::ExecutorAddr> getSymbolAddress(GlobalDecl GD) const;
 
   /// \returns the \c ExecutorAddr of a given name as written in the IR.
   llvm::Expected<llvm::orc::ExecutorAddr>
   getSymbolAddress(llvm::StringRef IRName) const;
 
   /// \returns the \c ExecutorAddr of a given name as written in the object
   /// file.
   llvm::Expected<llvm::orc::ExecutorAddr>
   getSymbolAddressFromLinkerName(llvm::StringRef LinkerName) const;
 
+  Parser &getParser() 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;
+  std::unique_ptr<llvm::Module> GenModule();
 
   llvm::SmallVector<Expr *, 3> ValuePrintingInfo;
 };
+} // namespace caas
 } // namespace clang
 
 #endif // LLVM_CLANG_INTERPRETER_INTERPRETER_H

clang/include/clang/Interpreter/PartialTranslationUnit.h

 namespace llvm {
 class Module;
 }
 
 namespace clang {
 
 class TranslationUnitDecl;
 
+namespace caas {
 /// The class keeps track of various objects created as part of processing
 /// incremental inputs.
 struct PartialTranslationUnit {
   TranslationUnitDecl *TUPart = nullptr;
 
   /// The llvm IR produced for the input.
   std::unique_ptr<llvm::Module> TheModule;
 };
+} // namespace caas
 } // namespace clang
 
 #endif // LLVM_CLANG_INTERPRETER_PARTIALTRANSLATIONUNIT_H

clang/include/clang/Interpreter/Value.h

 namespace llvm {
 class raw_ostream;
 
 } // namespace llvm
 
 namespace clang {
 
 class ASTContext;
-class Interpreter;
 class QualType;
 
+namespace caas {
+class Interpreter;
+
 #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
#undef X
   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 **getPtrAddress() 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
 
#undef X
   bool IsManuallyAlloc = false;
 };
 
 template <> inline void *Value::as() const {
   if (isPointerOrObjectType())
     return Data.m_Ptr;
   return (void *)as<uintptr_t>();
 }
-
+} // namespace caas
 } // namespace clang
 #endif

clang/lib/Headers/CMakeLists.txt

set(core_files
   stdbool.h
   stddef.h
   __stddef_max_align_t.h
   stdint.h
   stdnoreturn.h
   tgmath.h
   unwind.h
   varargs.h
+  __clang_interpreter_runtime_printvalue.h
   )
 
 set(arm_common_files
   # Headers shared by Arm and AArch64
   arm_acle.h
   )
 
 set(arm_only_files

clang/lib/Headers/__clang_interpreter_runtime_printvalue.h

+//===--- __clang_interpreter_runtime_printvalue.h - Incremental Compiation and
+// Execution---*- 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
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines runtime functions used to print STL components in
+// clang-repl. They are very heavy so we should only include it once and on
+// demand.
+//
+//===----------------------------------------------------------------------===//
+#ifndef LLVM_CLANG_INTERPRETER_RUNTIME_PRINT_VALUE_H
+#define LLVM_CLANG_INTERPRETER_RUNTIME_PRINT_VALUE_H
+
+#if !defined(__CLANG_REPL__)
+#error "This file should only be included by clang-repl!"
+#endif
+
+#include <memory>
+#include <string>
+#include <tuple>
+#include <type_traits>
+
+// We should include it somewhere instead of duplicating it...
+#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
+
+// Fallback for e.g. vector<bool>'s bit iterator:
+template <class T, class = typename std::enable_if_t<!std::is_pointer_v<T>>>
+inline std::string PrintValueRuntime(const T &Val) {
+  return "{not representable}";
+}
+
+// Below overloads are all defined in the library itself.
+REPL_EXTERNAL_VISIBILITY std::string PrintValueRuntime(const void *Ptr);
+
+REPL_EXTERNAL_VISIBILITY std::string PrintValueRuntime(const void **Ptr);
+
+REPL_EXTERNAL_VISIBILITY std::string PrintValueRuntime(const bool *Val);
+
+REPL_EXTERNAL_VISIBILITY std::string PrintValueRuntime(const char *Val);
+
+REPL_EXTERNAL_VISIBILITY std::string PrintValueRuntime(const signed char *Val);
+
+REPL_EXTERNAL_VISIBILITY std::string
+PrintValueRuntime(const unsigned char *Val);
+
+REPL_EXTERNAL_VISIBILITY std::string PrintValueRuntime(const short *Val);
+
+REPL_EXTERNAL_VISIBILITY std::string
+PrintValueRuntime(const unsigned short *Val);
+
+REPL_EXTERNAL_VISIBILITY std::string PrintValueRuntime(const int *Val);
+
+REPL_EXTERNAL_VISIBILITY std::string PrintValueRuntime(const unsigned int *Val);
+
+REPL_EXTERNAL_VISIBILITY std::string PrintValueRuntime(const long *Val);
+
+REPL_EXTERNAL_VISIBILITY std::string PrintValueRuntime(const long long *Val);
+
+REPL_EXTERNAL_VISIBILITY std::string
+PrintValueRuntime(const unsigned long *Val);
+
+REPL_EXTERNAL_VISIBILITY std::string
+PrintValueRuntime(const unsigned long long *Val);
+
+REPL_EXTERNAL_VISIBILITY std::string PrintValueRuntime(const float *Val);
+
+REPL_EXTERNAL_VISIBILITY std::string PrintValueRuntime(const double *Val);
+
+REPL_EXTERNAL_VISIBILITY std::string PrintValueRuntime(const long double *Val);
+
+REPL_EXTERNAL_VISIBILITY std::string PrintValueRuntime(const char *const *Val);
+
+REPL_EXTERNAL_VISIBILITY std::string PrintValueRuntime(const char **Val);
+
+namespace repl_runtime_detail {
+
+// Avoid using C++17 std::void_t because clang-repl can be used with lower
+// standards.
+template <typename... T> struct repl_make_void { typedef void type; };
+
+template <typename... T>
+using repl_void_t = typename repl_make_void<T...>::type;
+
+template <typename T, typename = void> struct is_iterable : std::false_type {};
+
+// this gets used only when we can call std::begin() and std::end() on that type
+template <typename T>
+struct is_iterable<T, repl_void_t<decltype(std::begin(std::declval<T &>())),
+                                  decltype(std::end(std::declval<T &>()))>>
+    : std::true_type {};
+
+template <typename> struct is_pair : std::false_type {};
+
+template <typename T, typename U>
+struct is_pair<std::pair<T, U>> : std::true_type {};
+
+template <typename T, typename = void> struct is_map : std::false_type {};
+
+template <typename T>
+struct is_map<T, repl_void_t<typename T::mapped_type>> : std::true_type {};
+
+// The type of the elements is std::pair, and the container is a map like type.
+template <
+    typename Container, typename Elt,
+    typename std::enable_if<is_pair<Elt>::value && is_map<Container>::value,
+                            bool>::type = true>
+std::string PrintCollectionElt(const Elt &Val) {
+  return PrintValueRuntime(&Val.first) + " => " +
+         PrintValueRuntime(&Val.second);
+}
+
+// The type of the elements is std::pair, and the container isn't a map like
+// type.
+template <
+    typename Container, typename Elt,
+    typename std::enable_if<is_pair<Elt>::value && !is_map<Container>::value,
+                            bool>::type = true>
+std::string PrintCollectionElt(const Elt &Val) {
+  return TuplePairPrintValue(&Val);
+}
+
+template <typename Container, typename Elt,
+          typename std::enable_if<!is_pair<Elt>::value, bool>::type = true>
+std::string PrintCollectionElt(const Elt &Val) {
+  return PrintValueRuntime(&Val);
+}
+
+template <class Tuple, std::size_t N = std::tuple_size<Tuple>(),
+          std::size_t TupleSize = std::tuple_size<Tuple>()>
+struct TupleLikePrinter {
+  static std::string print(const Tuple *T) {
+    constexpr std::size_t EltNum = TupleSize - N;
+    std::string Str;
+    // Not the first element.
+    if (EltNum != 0)
+      Str += ", ";
+    Str += PrintValueRuntime(&std::get<EltNum>(*T));
+    // If N+1 is not smaller than the size of the tuple,
+    // reroute the call to the printing function to the
+    // no-op specialisation to stop recursion.
+    constexpr std::size_t Nm1 = N - 1;
+    Str += TupleLikePrinter<Tuple, Nm1>::print((const Tuple *)T);
+    return Str;
+  }
+};
+
+template <class Tuple, std::size_t TupleSize>
+struct TupleLikePrinter<Tuple, 0, TupleSize> {
+  static std::string print(const Tuple *T) { return ""; }
+};
+
+template <class T> inline std::string TuplePairPrintValue(const T *Val) {
+  std::string Str("{ ");
+  Str += TupleLikePrinter<T>::print(Val);
+  Str += " }";
+  return Str;
+}
+
+} // namespace repl_runtime_detail
+
+template <
+    typename Container,
+    typename std::enable_if<repl_runtime_detail::is_iterable<Container>::value,
+                            bool>::type = true>
+inline std::string PrintValueRuntime(const Container *C) {
+  std::string Str("{ ");
+
+  for (auto Beg = C->begin(), End = C->end(); Beg != End; Beg++) {
+    if (Beg != C->begin())
+      Str += ", ";
+    Str += repl_runtime_detail::PrintCollectionElt<Container>(*Beg);
+  }
+  Str += " }";
+  return Str;
+}
+
+template <typename T, size_t N>
+inline std::string PrintValueRuntime(const T (*Obj)[N]) {
+  if (N == 0)
+    return "{}";
+
+  std::string Str = "{ ";
+  for (size_t Idx = 0; Idx < N; ++Idx) {
+    Str += PrintValueRuntime(*Obj + Idx);
+    if (Idx < N - 1)
+      Str += ", ";
+  }
+  return Str + " }";
+}
+
+template <size_t N> inline std::string PrintValueRuntime(const char (*Obj)[N]) {
+  const auto *Str = reinterpret_cast<const char *const>(Obj);
+  return PrintValueRuntime(&Str);
+}
+
+// tuple
+template <typename... Ts>
+inline std::string PrintValueRuntime(const std::tuple<Ts...> *Val) {
+  using T = std::tuple<Ts...>;
+  return repl_runtime_detail::TuplePairPrintValue<T>(Val);
+}
+
+// pair
+template <typename... Ts>
+inline std::string PrintValueRuntime(const std::pair<Ts...> *Val) {
+  using T = std::pair<Ts...>;
+  return repl_runtime_detail::TuplePairPrintValue<T>(Val);
+}
+
+// unique_ptr
+template <class T>
+inline std::string PrintValueRuntime(const std::unique_ptr<T> *Val) {
+  auto Ptr = Val->get();
+  return "std::unique_ptr -> " + PrintValueRuntime((const void **)&Ptr);
+}
+
+// shared_ptr
+template <class T>
+inline std::string PrintValueRuntime(const std::shared_ptr<T> *Val) {
+  auto Ptr = Val->get();
+  return "std::shared_ptr -> " + PrintValueRuntime((const void **)&Ptr);
+}
+
+// weak_ptr
+template <class T>
+inline std::string PrintValueRuntime(const std::weak_ptr<T> *Val) {
+  auto Ptr = Val->lock().get();
+  return "std::weak_ptr -> " + PrintValueRuntime((const void **)&Ptr);
+}
+
+// string
+template <class T>
+inline std::string PrintValueRuntime(const std::basic_string<T> *Val) {
+  const char *Chars = Val->c_str();
+  return PrintValueRuntime((const char **)&Chars);
+}
+#endif

clang/lib/Interpreter/CMakeLists.txt

set(LLVM_LINK_COMPONENTS
   )
 
 add_clang_library(clangInterpreter
   IncrementalExecutor.cpp
   IncrementalParser.cpp
   Interpreter.cpp
   InterpreterUtils.cpp
   Value.cpp
+  ValuePrinter.cpp
 
   DEPENDS
   intrinsics_gen
   ClangDriverOptions
 
   LINK_LIBS
   clangAST
   clangAnalysis

clang/lib/Interpreter/IncrementalExecutor.h

 namespace orc {
 class LLJIT;
 class ThreadSafeContext;
 } // namespace orc
 } // namespace llvm
 
 namespace clang {
 
-struct PartialTranslationUnit;
 class TargetInfo;
 
+namespace caas {
+struct PartialTranslationUnit;
+
 class IncrementalExecutor {
   using CtorDtorIterator = llvm::orc::CtorDtorIterator;
   std::unique_ptr<llvm::orc::LLJIT> Jit;
   llvm::orc::ThreadSafeContext &TSCtx;
 
   llvm::DenseMap<const PartialTranslationUnit *, llvm::orc::ResourceTrackerSP>
       ResourceTrackers;
 
 public:
   enum SymbolNameKind { IRName, LinkerName };
 
   IncrementalExecutor(llvm::orc::ThreadSafeContext &TSC, llvm::Error &Err,
                       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;
   llvm::Error cleanUp();
   llvm::Expected<llvm::orc::ExecutorAddr>
   getSymbolAddress(llvm::StringRef Name, SymbolNameKind NameKind) const;
 
   llvm::orc::LLJIT &GetExecutionEngine() { return *Jit; }
 };
-
+} // namespace caas
 } // end namespace clang
 
 #endif // LLVM_CLANG_LIB_INTERPRETER_INCREMENTALEXECUTOR_H

clang/lib/Interpreter/IncrementalExecutor.cpp

 #include "llvm/Support/TargetSelect.h"
 
 // Force linking some of the runtimes that helps attaching to a debugger.
 LLVM_ATTRIBUTE_USED void linkComponents() {
   llvm::errs() << (void *)&llvm_orc_registerJITLoaderGDBWrapper
                << (void *)&llvm_orc_registerJITLoaderGDBAllocAction;
 }
 
-namespace clang {
+namespace clang::caas {
 
 IncrementalExecutor::IncrementalExecutor(llvm::orc::ThreadSafeContext &TSC,
                                          llvm::Error &Err,
                                          const clang::TargetInfo &TI)
     : TSCtx(TSC) {
   using namespace llvm::orc;
   llvm::ErrorAsOutParameter EAO(&Err);
 
IncrementalExecutor::IncrementalExecutor(llvm::orc::ThreadSafeContext &TSC,
   else {
     Err = JitOrErr.takeError();
     return;
   }
 }
 
 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();
   ResourceTrackers[&PTU] = RT;
 
   return Jit->addIRModule(RT, {std::move(PTU.TheModule), TSCtx});
 }
 
IncrementalExecutor::getSymbolAddress(llvm::StringRef Name,
   auto Sym = (NameKind == LinkerName) ? Jit->lookupLinkerMangled(Name)
                                       : Jit->lookup(Name);
 
   if (!Sym)
     return Sym.takeError();
   return Sym;
 }
 
-} // end namespace clang
+} // namespace clang::caas

clang/lib/Interpreter/IncrementalParser.h

 #include <memory>
 namespace llvm {
 class LLVMContext;
 }
 
 namespace clang {
 class ASTConsumer;
 class CompilerInstance;
+class Parser;
+
+namespace caas {
 class IncrementalAction;
 class Interpreter;
-class Parser;
 /// Provides support for incremental compilation. Keeps track of the state
 /// changes between the subsequent incremental input.
 ///
 class IncrementalParser {
   /// Long-lived, incremental parsing action.
   std::unique_ptr<IncrementalAction> Act;
 
   /// Compiler instance performing the incremental compilation.
public:
   /// Uses the CodeGenModule mangled name cache and avoids recomputing.
   ///\returns the mangled name of a \c GD.
   llvm::StringRef GetMangledName(GlobalDecl GD) const;
 
   void CleanUpPTU(PartialTranslationUnit &PTU);
 
   std::list<PartialTranslationUnit> &getPTUs() { return PTUs; }
 
+  Parser &getParser() { return *P; }
+
   std::unique_ptr<llvm::Module> GenModule();
 
 private:
   llvm::Expected<PartialTranslationUnit &> ParseOrWrapTopLevelDecl();
 };
+} // namespace caas
 } // end namespace clang
 
 #endif // LLVM_CLANG_LIB_INTERPRETER_INCREMENTALPARSER_H

clang/lib/Interpreter/IncrementalParser.cpp

 #include "clang/Sema/Sema.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Support/CrashRecoveryContext.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/Timer.h"
 
 #include <sstream>
 
-namespace clang {
+namespace clang::caas {
 
 class IncrementalASTConsumer final : public ASTConsumer {
   Interpreter &Interp;
   std::unique_ptr<ASTConsumer> Consumer;
 
 public:
   IncrementalASTConsumer(Interpreter &InterpRef, std::unique_ptr<ASTConsumer> C)
       : Interp(InterpRef), Consumer(std::move(C)) {}

 }
 
 llvm::StringRef IncrementalParser::GetMangledName(GlobalDecl GD) const {
   CodeGenerator *CG = getCodeGen(Act.get());
   assert(CG);
   return CG->GetMangledName(GD);
 }
 
-} // end namespace clang
+} // namespace clang::caas

clang/lib/Interpreter/Interpreter.cpp

 #include "clang/Driver/Driver.h"
 #include "clang/Driver/Job.h"
 #include "clang/Driver/Options.h"
 #include "clang/Driver/Tool.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/TextDiagnosticBuffer.h"
 #include "clang/Interpreter/Value.h"
 #include "clang/Lex/PreprocessorOptions.h"
+#include "clang/Parse/Parser.h"
 #include "clang/Sema/Lookup.h"
 #include "llvm/ExecutionEngine/JITSymbol.h"
 #include "llvm/ExecutionEngine/Orc/LLJIT.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/TargetParser/Host.h"
 using namespace clang;
-
+using namespace clang::caas;
 // FIXME: Figure out how to unify with namespace init_convenience from
 //        tools/clang-import-test/clang-import-test.cpp
 namespace {
 /// Retrieves the clang CC1 specific flags out of the compilation's jobs.
 /// \returns NULL on error.
 static llvm::Expected<const llvm::opt::ArgStringList *>
 GetCC1Arguments(DiagnosticsEngine *Diagnostics,
                 driver::Compilation *Compilation) {
const char *const Runtimes = R"(
     void __clang_Interpreter_SetValueCopyArr(T* Src, void* Placement, unsigned long Size) {
       for (auto Idx = 0; Idx < Size; ++Idx)
         new ((void*)(((T*)Placement) + Idx)) T(Src[Idx]);
     }
     template <class T, unsigned long N>
     void __clang_Interpreter_SetValueCopyArr(const T (*Src)[N], void* Placement, unsigned long Size) {
       __clang_Interpreter_SetValueCopyArr(Src[0], Placement, Size);
     }
+    #define __CLANG_REPL__ 1
 )";
 
 llvm::Expected<std::unique_ptr<Interpreter>>
 Interpreter::create(std::unique_ptr<CompilerInstance> CI) {
   llvm::Error Err = llvm::Error::success();
   auto Interp =
       std::unique_ptr<Interpreter>(new Interpreter(std::move(CI), Err));
   if (Err)
     return std::move(Err);
   if (llvm::Error Err = Interp->ParseAndExecute(Runtimes))
     return std::move(Err);
 
   Interp->ValuePrintingInfo.resize(3);
   // FIXME: This is a ugly hack. Undo command checks its availability by looking
   // at the size of the PTU list. However we have parsed something in the
   // beginning of the REPL so we have to mark them as 'Irrevocable'.
   Interp->InitPTUSize = Interp->IncrParser->getPTUs().size();
   return std::move(Interp);
 }
 
 const CompilerInstance *Interpreter::getCompilerInstance() const {
   return IncrParser->getCI();
 }
 
+Parser &Interpreter::getParser() const { return IncrParser->getParser(); }
+
 llvm::Expected<llvm::orc::LLJIT &> Interpreter::getExecutionEngine() {
   if (!IncrExecutor) {
     if (auto Err = CreateExecutor())
       return std::move(Err);
   }
 
   return IncrExecutor->GetExecutionEngine();
 }
llvm::Error Interpreter::CreateExecutor() {
   llvm::Error Err = llvm::Error::success();
   auto Executor = std::make_unique<IncrementalExecutor>(*TSCtx, Err, TI);
   if (!Err)
     IncrExecutor = std::move(Executor);
 
   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) {
     auto Err = CreateExecutor();
     if (Err)
       return Err;
   }
   // FIXME: Add a callback to retain the llvm::Module once the JIT is done.
Interpreter::CompileDtorCall(CXXRecordDecl *CXXRD) {
   auto AddrOrErr = getSymbolAddress(Name);
   if (!AddrOrErr)
     return AddrOrErr.takeError();
 
   Dtors[CXXRD] = *AddrOrErr;
   return AddrOrErr;
 }
 
+std::unique_ptr<llvm::Module> Interpreter::GenModule() {
+  return IncrParser->GenModule();
+}
+
+llvm::Expected<llvm::orc::ExecutorAddr> Interpreter::CompileDecl(Decl *D) {
+  assert(D && "The Decl being compiled can't be null");
+
+  ASTConsumer &Consumer = getCompilerInstance()->getASTConsumer();
+  Consumer.HandleTopLevelDecl(DeclGroupRef(D));
+  getCompilerInstance()->getSema().PerformPendingInstantiations();
+  Consumer.HandleTranslationUnit(getASTContext());
+
+  if (std::unique_ptr<llvm::Module> M = GenModule()) {
+    if (llvm::Error Err = ExecuteModule(M))
+      return Err;
+    ASTNameGenerator ASTNameGen(getASTContext());
+    llvm::Expected<llvm::orc::ExecutorAddr> AddrOrErr =
+        getSymbolAddressFromLinkerName(ASTNameGen.getName(D));
+
+    return AddrOrErr;
+  }
+  return llvm::orc::ExecutorAddr{};
+}
+
+std::string Interpreter::CreateUniqName(std::string Base) {
+  static size_t I = 0;
+  Base += std::to_string(I);
+  I += 1;
+  return Base;
+}
+
 static constexpr llvm::StringRef MagicRuntimeInterface[] = {
     "__clang_Interpreter_SetValueNoAlloc",
     "__clang_Interpreter_SetValueWithAlloc",
     "__clang_Interpreter_SetValueCopyArr"};
 
 bool Interpreter::FindRuntimeInterface() {
   if (llvm::all_of(ValuePrintingInfo, [](Expr *E) { return E != nullptr; }))
     return true;
if (!LookupInterface(ValuePrintingInfo[CopyArray],
     return false;
   return true;
 }
 
 namespace {
 
 class RuntimeInterfaceBuilder
     : public TypeVisitor<RuntimeInterfaceBuilder, Interpreter::InterfaceKind> {
-  clang::Interpreter &Interp;
+  clang::caas::Interpreter &Interp;
   ASTContext &Ctx;
   Sema &S;
   Expr *E;
   llvm::SmallVector<Expr *, 3> Args;
 
 public:
-  RuntimeInterfaceBuilder(clang::Interpreter &In, ASTContext &C, Sema &SemaRef,
-                          Expr *VE, ArrayRef<Expr *> FixedArgs)
+  RuntimeInterfaceBuilder(clang::caas::Interpreter &In, ASTContext &C,
+                          Sema &SemaRef, Expr *VE, ArrayRef<Expr *> FixedArgs)
       : Interp(In), Ctx(C), S(SemaRef), E(VE) {
     // The Interpreter* parameter and the out parameter `OutVal`.
     for (Expr *E : FixedArgs)
       Args.push_back(E);
 
     // Get rid of ExprWithCleanups.
     if (auto *EWC = llvm::dyn_cast_if_present<ExprWithCleanups>(E))
       E = EWC->getSubExpr();

clang/lib/Interpreter/InterpreterUtils.h

 #include "clang/Frontend/TextDiagnosticBuffer.h"
 #include "clang/Lex/PreprocessorOptions.h"
 
 #include "clang/Sema/Lookup.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/TargetParser/Host.h"
 
-namespace clang {
+namespace clang::caas {
 IntegerLiteral *IntegerLiteralExpr(ASTContext &C, uint64_t Val);
 
 Expr *CStyleCastPtrExpr(Sema &S, QualType Ty, Expr *E);
 
 Expr *CStyleCastPtrExpr(Sema &S, QualType Ty, uintptr_t Ptr);
 
 Sema::DeclGroupPtrTy CreateDGPtrFrom(Sema &S, Decl *D);
 
 NamespaceDecl *LookupNamespace(Sema &S, llvm::StringRef Name,
                                const DeclContext *Within = nullptr);
 
 NamedDecl *LookupNamed(Sema &S, llvm::StringRef Name,
                        const DeclContext *Within);
 
+NestedNameSpecifier *CreateNestedNameSpecifier(const ASTContext &Ctx,
+                                               const NamespaceDecl *Namesp);
+
+NestedNameSpecifier *CreateNestedNameSpecifier(const ASTContext &Ctx,
+                                               const TypedefNameDecl *TD,
+                                               bool FullyQualify);
+
+NestedNameSpecifier *CreateNestedNameSpecifier(const ASTContext &Ctx,
+                                               const TagDecl *TD,
+                                               bool FullyQualify);
+
+QualType GetFullyQualifiedType(QualType QT, const ASTContext &Ctx);
+
 std::string GetFullTypeName(ASTContext &Ctx, QualType QT);
-} // namespace clang
+
+class Value;
+
+std::string ReplPrintTypeImpl(const Value &);
+
+std::string ReplPrintDataImpl(const Value &);
+} // namespace clang::caas
 
 #endif

clang/lib/Interpreter/InterpreterUtils.cpp

 //===--- InterpreterUtils.cpp - Incremental Utils --------*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements some common utils used in the incremental library.
 //
 //===----------------------------------------------------------------------===//
 
 #include "InterpreterUtils.h"
 
-namespace clang {
+namespace clang::caas {
 
 IntegerLiteral *IntegerLiteralExpr(ASTContext &C, uint64_t Val) {
   return IntegerLiteral::Create(C, llvm::APSInt::getUnsigned(Val),
                                 C.UnsignedLongLongTy, SourceLocation());
 }
 
 Expr *CStyleCastPtrExpr(Sema &S, QualType Ty, Expr *E) {
   ASTContext &Ctx = S.getASTContext();
NamedDecl *LookupNamed(Sema &S, llvm::StringRef Name,
   R.resolveKind();
 
   if (R.isSingleResult())
     return llvm::dyn_cast<NamedDecl>(R.getFoundDecl());
 
   return nullptr;
 }
 
+static NestedNameSpecifier *CreateOuterNNS(const ASTContext &Ctx, const Decl *D,
+                                           bool FullyQualify) {
+  const DeclContext *DC = D->getDeclContext();
+  if (const NamespaceDecl *NS = dyn_cast<NamespaceDecl>(DC)) {
+    while (NS && NS->isInline()) {
+      // Ignore inline namespace;
+      NS = dyn_cast_or_null<NamespaceDecl>(NS->getDeclContext());
+    }
+    if (NS && NS->getDeclName())
+      return CreateNestedNameSpecifier(Ctx, NS);
+    return nullptr; // no starting '::', no anonymous
+  }
+  if (const auto *TD = dyn_cast<TagDecl>(DC)) {
+    return CreateNestedNameSpecifier(Ctx, TD, FullyQualify);
+  }
+  if (const TypedefNameDecl *TDD = dyn_cast<TypedefNameDecl>(DC)) {
+    return CreateNestedNameSpecifier(Ctx, TDD, FullyQualify);
+  }
+  return nullptr; // no starting '::'
+}
+
+static NestedNameSpecifier *
+CreateNestedNameSpecifierForScopeOf(const ASTContext &Ctx, const Decl *D,
+                                    bool FullyQualified) {
+  // Create a nested name specifier for the declaring context of the type.
+
+  assert(D);
+
+  const NamedDecl *Outer =
+      llvm::dyn_cast_or_null<NamedDecl>(D->getDeclContext());
+  const NamespaceDecl *OuterNs =
+      llvm::dyn_cast_or_null<NamespaceDecl>(D->getDeclContext());
+  if (Outer && !(OuterNs && OuterNs->isAnonymousNamespace())) {
+
+    if (const CXXRecordDecl *CXXD =
+            llvm::dyn_cast<CXXRecordDecl>(D->getDeclContext())) {
+
+      if (ClassTemplateDecl *clTempl = CXXD->getDescribedClassTemplate()) {
+        // We are in the case of a type(def) that was declared in a
+        // class template but is *not* type dependent.  In clang, it gets
+        // attached to the class template declaration rather than any
+        // specific class template instantiation.   This result in 'odd'
+        // fully qualified typename:
+        //    vector<_Tp,_Alloc>::size_type
+        // Make the situation is 'useable' but looking a bit odd by
+        // picking a random instance as the declaring context.
+        // FIXME: We should not use the iterators here to check if we are in
+        // a template specialization. clTempl != cxxdecl already tell us that
+        // is the case. It seems that we rely on a side-effect from triggering
+        // deserializations to support 'some' use-case. See ROOT-9709.
+        if (clTempl->spec_begin() != clTempl->spec_end()) {
+          D = *(clTempl->spec_begin());
+          Outer = llvm::dyn_cast<NamedDecl>(D);
+          OuterNs = llvm::dyn_cast<NamespaceDecl>(D);
+        }
+      }
+    }
+
+    if (OuterNs) {
+      return CreateNestedNameSpecifier(Ctx, OuterNs);
+    }
+    if (const auto *TD = llvm::dyn_cast<TagDecl>(Outer)) {
+      return CreateNestedNameSpecifier(Ctx, TD, FullyQualified);
+    }
+  }
+  return nullptr;
+}
+
+static NestedNameSpecifier *
+CreateNestedNameSpecifierForScopeOf(const ASTContext &Ctx, const Type *TypePtr,
+                                    bool FullyQualified) {
+  // Create a nested name specifier for the declaring context of the type.
+
+  if (!TypePtr)
+    return nullptr;
+
+  Decl *D = nullptr;
+  if (const auto *TDT = llvm::dyn_cast<TypedefType>(TypePtr)) {
+    D = TDT->getDecl();
+  } else {
+    // There are probably other cases ...
+    if (const auto *TT = llvm::dyn_cast_or_null<TagType>(TypePtr))
+      D = TT->getDecl();
+    else
+      D = TypePtr->getAsCXXRecordDecl();
+  }
+
+  if (!D)
+    return nullptr;
+
+  return CreateNestedNameSpecifierForScopeOf(Ctx, D, FullyQualified);
+}
+
+static NestedNameSpecifier *
+GetFullyQualifiedNameSpecifier(const ASTContext &Ctx,
+                               NestedNameSpecifier *Scope) {
+  // Return a fully qualified version of this name specifier
+  if (Scope->getKind() == NestedNameSpecifier::Global) {
+    // Already fully qualified.
+    return Scope;
+  }
+
+  if (const Type *Type = Scope->getAsType()) {
+    // Find decl context.
+    const TagDecl *TD = nullptr;
+    if (const TagType *tagdecltype = dyn_cast<TagType>(Type)) {
+      TD = tagdecltype->getDecl();
+    } else {
+      TD = Type->getAsCXXRecordDecl();
+    }
+    if (TD) {
+      return CreateNestedNameSpecifier(Ctx, TD, true /*FullyQualified*/);
+    }
+    if (const TypedefType *TDD = dyn_cast<TypedefType>(Type)) {
+      return CreateNestedNameSpecifier(Ctx, TDD->getDecl(),
+                                       true /*FullyQualified*/);
+    }
+  } else if (const NamespaceDecl *NS = Scope->getAsNamespace()) {
+    return CreateNestedNameSpecifier(Ctx, NS);
+  } else if (const NamespaceAliasDecl *alias = Scope->getAsNamespaceAlias()) {
+    const NamespaceDecl *CanonNS = alias->getNamespace()->getCanonicalDecl();
+    return CreateNestedNameSpecifier(Ctx, CanonNS);
+  }
+
+  return Scope;
+}
+
+static bool GetFullyQualifiedTemplateName(const ASTContext &Ctx,
+                                          TemplateName &Name) {
+
+  bool Changed = false;
+  NestedNameSpecifier *NNS = nullptr;
+
+  TemplateDecl *TD = Name.getAsTemplateDecl();
+  QualifiedTemplateName *qtname = Name.getAsQualifiedTemplateName();
+
+  if (qtname && !qtname->hasTemplateKeyword()) {
+    NNS = qtname->getQualifier();
+    NestedNameSpecifier *qNNS = GetFullyQualifiedNameSpecifier(Ctx, NNS);
+    if (qNNS != NNS) {
+      Changed = true;
+      NNS = qNNS;
+    } else {
+      NNS = nullptr;
+    }
+  } else {
+    NNS = CreateNestedNameSpecifierForScopeOf(Ctx, TD, true);
+  }
+  if (NNS) {
+    Name = Ctx.getQualifiedTemplateName(NNS,
+                                        /*TemplateKeyword=*/false,
+                                        TemplateName(TD));
+    Changed = true;
+  }
+  return Changed;
+}
+
+static bool GetFullyQualifiedTemplateArgument(const ASTContext &Ctx,
+                                              TemplateArgument &Arg) {
+  bool Changed = false;
+
+  // Note: we do not handle TemplateArgument::Expression, to replace it
+  // we need the information for the template instance decl.
+  // See GetPartiallyDesugaredTypeImpl
+
+  if (Arg.getKind() == TemplateArgument::Template) {
+    TemplateName Name = Arg.getAsTemplate();
+    Changed = GetFullyQualifiedTemplateName(Ctx, Name);
+    if (Changed) {
+      Arg = TemplateArgument(Name);
+    }
+  } else if (Arg.getKind() == TemplateArgument::Type) {
+    QualType SubTy = Arg.getAsType();
+    // Check if the type needs more desugaring and recurse.
+    QualType QTFQ = GetFullyQualifiedType(SubTy, Ctx);
+    if (QTFQ != SubTy) {
+      Arg = TemplateArgument(QTFQ);
+      Changed = true;
+    }
+  } else if (Arg.getKind() == TemplateArgument::Pack) {
+    SmallVector<TemplateArgument, 2> desArgs;
+    for (auto I = Arg.pack_begin(), E = Arg.pack_end(); I != E; ++I) {
+      TemplateArgument PackArg(*I);
+      Changed = GetFullyQualifiedTemplateArgument(Ctx, PackArg);
+      desArgs.push_back(PackArg);
+    }
+    if (Changed) {
+      // The allocator in ASTContext is mutable ...
+      // Keep the argument const to be inline will all the other interfaces
+      // like:  NestedNameSpecifier::Create
+      ASTContext &MutableCtx(const_cast<ASTContext &>(Ctx));
+      Arg = TemplateArgument::CreatePackCopy(MutableCtx, desArgs);
+    }
+  }
+  return Changed;
+}
+
+static const Type *GetFullyQualifiedLocalType(const ASTContext &Ctx,
+                                              const Type *Typeptr) {
+  // We really just want to handle the template parameter if any ....
+  // In case of template specializations iterate over the arguments and
+  // fully qualify them as well.
+  if (const auto *TST =
+          llvm::dyn_cast<const TemplateSpecializationType>(Typeptr)) {
+
+    bool MightHaveChanged = false;
+    llvm::SmallVector<TemplateArgument, 4> desArgs;
+    for (auto &I : TST->template_arguments()) {
+
+      // cheap to copy and potentially modified by
+      // GetFullyQualifedTemplateArgument
+      TemplateArgument arg(I);
+      MightHaveChanged |= GetFullyQualifiedTemplateArgument(Ctx, arg);
+      desArgs.push_back(arg);
+    }
+
+    // If desugaring happened allocate new type in the AST.
+    if (MightHaveChanged) {
+      QualType QT = Ctx.getTemplateSpecializationType(
+          TST->getTemplateName(), desArgs, TST->getCanonicalTypeInternal());
+      return QT.getTypePtr();
+    }
+  } else if (const auto *TSTRecord =
+                 llvm::dyn_cast<const RecordType>(Typeptr)) {
+    // We are asked to fully qualify and we have a Record Type,
+    // which can point to a template instantiation with no sugar in any of
+    // its template argument, however we still need to fully qualify them.
+
+    if (const auto *TSTdecl = llvm::dyn_cast<ClassTemplateSpecializationDecl>(
+            TSTRecord->getDecl())) {
+      const TemplateArgumentList &templateArgs = TSTdecl->getTemplateArgs();
+
+      bool MightHaveChanged = false;
+      llvm::SmallVector<TemplateArgument, 4> desArgs;
+      for (unsigned int I = 0, E = templateArgs.size(); I != E; ++I) {
+
+        // cheap to copy and potentially modified by
+        // GetFullyQualifedTemplateArgument
+        TemplateArgument arg(templateArgs[I]);
+        MightHaveChanged |= GetFullyQualifiedTemplateArgument(Ctx, arg);
+        desArgs.push_back(arg);
+      }
+
+      // If desugaring happened allocate new type in the AST.
+      if (MightHaveChanged) {
+        TemplateName TN(TSTdecl->getSpecializedTemplate());
+        QualType QT = Ctx.getTemplateSpecializationType(
+            TN, desArgs, TSTRecord->getCanonicalTypeInternal());
+        return QT.getTypePtr();
+      }
+    }
+  }
+  return Typeptr;
+}
+
+NestedNameSpecifier *CreateNestedNameSpecifier(const ASTContext &Ctx,
+                                               const NamespaceDecl *NSD) {
+  while (NSD && NSD->isInline()) {
+    // Ignore inline namespace;
+    NSD = dyn_cast_or_null<NamespaceDecl>(NSD->getDeclContext());
+  }
+  if (!NSD)
+    return nullptr;
+
+  bool FullyQualified = true; // doesn't matter, DeclContexts are namespaces
+  return NestedNameSpecifier::Create(
+      Ctx, CreateOuterNNS(Ctx, NSD, FullyQualified), NSD);
+}
+
+NestedNameSpecifier *CreateNestedNameSpecifier(const ASTContext &Ctx,
+                                               const TypedefNameDecl *TD,
+                                               bool FullyQualify) {
+  return NestedNameSpecifier::Create(Ctx, CreateOuterNNS(Ctx, TD, FullyQualify),
+                                     /*Template=*/true, TD->getTypeForDecl());
+}
+
+NestedNameSpecifier *CreateNestedNameSpecifier(const ASTContext &Ctx,
+                                               const TagDecl *TD,
+                                               bool FullyQualify) {
+  const Type *Ty = Ctx.getTypeDeclType(TD).getTypePtr();
+  if (FullyQualify)
+    Ty = GetFullyQualifiedLocalType(Ctx, Ty);
+  return NestedNameSpecifier::Create(Ctx, CreateOuterNNS(Ctx, TD, FullyQualify),
+                                     /*Template=*/false, Ty);
+}
+
+QualType GetFullyQualifiedType(QualType QT, const ASTContext &Ctx) {
+  // Return the fully qualified type, if we need to recurse through any
+  // template parameter, this needs to be merged somehow with
+  // GetPartialDesugaredType.
+
+  // In case of myType* we need to strip the pointer first, fully qualifiy
+  // and attach the pointer once again.
+  if (llvm::isa<PointerType>(QT.getTypePtr())) {
+    // Get the qualifiers.
+    Qualifiers Quals = QT.getQualifiers();
+    QT = GetFullyQualifiedType(QT->getPointeeType(), Ctx);
+    QT = Ctx.getPointerType(QT);
+    // Add back the qualifiers.
+    QT = Ctx.getQualifiedType(QT, Quals);
+    return QT;
+  }
+
+  // In case of myType& we need to strip the pointer first, fully qualifiy
+  // and attach the pointer once again.
+  if (llvm::isa<ReferenceType>(QT.getTypePtr())) {
+    // Get the qualifiers.
+    bool IsLValueRefTy = llvm::isa<LValueReferenceType>(QT.getTypePtr());
+    Qualifiers Quals = QT.getQualifiers();
+    QT = GetFullyQualifiedType(QT->getPointeeType(), Ctx);
+    // Add the r- or l-value reference type back to the desugared one.
+    if (IsLValueRefTy)
+      QT = Ctx.getLValueReferenceType(QT);
+    else
+      QT = Ctx.getRValueReferenceType(QT);
+    // Add back the qualifiers.
+    QT = Ctx.getQualifiedType(QT, Quals);
+    return QT;
+  }
+
+  // Strip deduced types.
+  if (const auto *AutoTy = dyn_cast<AutoType>(QT.getTypePtr())) {
+    if (!AutoTy->getDeducedType().isNull())
+      return GetFullyQualifiedType(
+          AutoTy->getDeducedType().getDesugaredType(Ctx), Ctx);
+  }
+
+  // Remove the part of the type related to the type being a template
+  // parameter (we won't report it as part of the 'type name' and it is
+  // actually make the code below to be more complex (to handle those)
+  while (llvm::isa<SubstTemplateTypeParmType>(QT.getTypePtr())) {
+    // Get the qualifiers.
+    Qualifiers Quals = QT.getQualifiers();
+
+    QT = llvm::cast<SubstTemplateTypeParmType>(QT.getTypePtr())->desugar();
+
+    // Add back the qualifiers.
+    QT = Ctx.getQualifiedType(QT, Quals);
+  }
+
+  NestedNameSpecifier *Prefix = nullptr;
+  Qualifiers PrefixQualifiers;
+  if (const auto *EType = llvm::dyn_cast<ElaboratedType>(QT.getTypePtr())) {
+    // Intentionally, we do not care about the other compononent of
+    // the elaborated type (the keyword) as part of the partial
+    // desugaring (and/or name normalization) is to remove it.
+    Prefix = EType->getQualifier();
+    if (Prefix) {
+      const NamespaceDecl *NS = Prefix->getAsNamespace();
+      if (Prefix != NestedNameSpecifier::GlobalSpecifier(Ctx) &&
+          !(NS && NS->isAnonymousNamespace())) {
+        PrefixQualifiers = QT.getLocalQualifiers();
+        Prefix = GetFullyQualifiedNameSpecifier(Ctx, Prefix);
+        QT = QualType(EType->getNamedType().getTypePtr(), 0);
+      } else {
+        Prefix = nullptr;
+      }
+    }
+  } else {
+
+    // Create a nested name specifier if needed (i.e. if the decl context
+    // is not the global scope.
+    Prefix = CreateNestedNameSpecifierForScopeOf(Ctx, QT.getTypePtr(),
+                                                 true /*FullyQualified*/);
+
+    // move the qualifiers on the outer type (avoid 'std::const string'!)
+    if (Prefix) {
+      PrefixQualifiers = QT.getLocalQualifiers();
+      QT = QualType(QT.getTypePtr(), 0);
+    }
+  }
+
+  // In case of template specializations iterate over the arguments and
+  // fully qualify them as well.
+  if (llvm::isa<const TemplateSpecializationType>(QT.getTypePtr())) {
+
+    Qualifiers Qualifiers = QT.getLocalQualifiers();
+    const Type *TypePtr = GetFullyQualifiedLocalType(Ctx, QT.getTypePtr());
+    QT = Ctx.getQualifiedType(TypePtr, Qualifiers);
+
+  } else if (llvm::isa<const RecordType>(QT.getTypePtr())) {
+    // We are asked to fully qualify and we have a Record Type,
+    // which can point to a template instantiation with no sugar in any of
+    // its template argument, however we still need to fully qualify them.
+
+    Qualifiers Qualifiers = QT.getLocalQualifiers();
+    const Type *TypePtr = GetFullyQualifiedLocalType(Ctx, QT.getTypePtr());
+    QT = Ctx.getQualifiedType(TypePtr, Qualifiers);
+  }
+  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.getQualifiedType(QT, PrefixQualifiers);
+  }
+  return QT;
+}
+
 std::string GetFullTypeName(ASTContext &Ctx, QualType QT) {
+  QualType FQT = GetFullyQualifiedType(QT, Ctx);
   PrintingPolicy Policy(Ctx.getPrintingPolicy());
   Policy.SuppressScope = false;
   Policy.AnonymousTagLocations = false;
-  return QT.getAsString(Policy);
+  return FQT.getAsString(Policy);
 }
-} // namespace clang
+} // namespace clang::caas

clang/lib/Interpreter/Value.cpp

 //===--- Interpreter.h - Incremental Compiation and Execution---*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines the class that used to represent a value in incremental
 // C++.
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/Interpreter/Value.h"
+#include "InterpreterUtils.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/Type.h"
 #include "clang/Interpreter/Interpreter.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/raw_os_ostream.h"
 #include <cassert>
 #include <cstdint>
 #include <utility>
 
 using namespace clang;
+using namespace clang::caas;
 
 namespace {
 
 // This is internal buffer maintained by Value, used to hold temporaries.
 class ValueStorage {
 public:
   using DtorFunc = void (*)(void *);
 

 
 Value::~Value() { clear(); }
 
 void *Value::getPtr() const {
   assert(ValueKind == K_PtrOrObj);
   return Data.m_Ptr;
 }
 
+void **Value::getPtrAddress() const {
+  assert(ValueKind == K_PtrOrObj);
+  return &const_cast<Value *>(this)->Data.m_Ptr;
+}
+
 QualType Value::getType() const {
   return QualType::getFromOpaquePtr(OpaqueType);
 }
 
 Interpreter &Value::getInterpreter() {
   assert(Interp != nullptr &&
          "Can't get interpreter from a default constructed value");
   return *Interp;

 
 const ASTContext &Value::getASTContext() const {
   return getInterpreter().getASTContext();
 }
 
 void Value::dump() const { print(llvm::outs()); }
 
 void Value::printType(llvm::raw_ostream &Out) const {
-  Out << "Not implement yet.\n";
+  Out << ReplPrintTypeImpl(*this);
 }
+
 void Value::printData(llvm::raw_ostream &Out) const {
-  Out << "Not implement yet.\n";
+  Out << ReplPrintDataImpl(*this);
 }
+
 void Value::print(llvm::raw_ostream &Out) const {
   assert(OpaqueType != nullptr && "Can't print default Value");
-  Out << "Not implement yet.\n";
+
+  // Don't even try to print a void or an invalid type, it doesn't make sense.
+  if (getType()->isVoidType() || !isValid())
+    return;
+
+  // We need to get all the results together then print it, since `printType` is
+  // much faster than `printData`.
+  std::string Str;
+  llvm::raw_string_ostream SS(Str);
+
+  SS << "(";
+  printType(SS);
+  SS << ") ";
+  printData(SS);
+  SS << "\n";
+  Out << Str;
 }

clang/lib/Interpreter/ValuePrinter.cpp

+#include "InterpreterUtils.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/AST/PrettyPrinter.h"
+#include "clang/AST/Type.h"
+#include "clang/Frontend/CompilerInstance.h"
+#include "clang/Interpreter/Interpreter.h"
+#include "clang/Interpreter/Value.h"
+#include "clang/Parse/Parser.h"
+#include "clang/Sema/Lookup.h"
+#include "clang/Sema/Sema.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/raw_ostream.h"
+#include <cassert>
+#include <string>
+
+using namespace clang;
+using namespace clang::caas;
+
+static std::string PrintDeclType(const QualType &QT, NamedDecl *D) {
+  std::string Str;
+  llvm::raw_string_ostream SS(Str);
+  if (QT.hasQualifiers())
+    SS << QT.getQualifiers().getAsString() << " ";
+  SS << D->getQualifiedNameAsString();
+  return Str;
+}
+
+static std::string PrintQualType(ASTContext &Ctx, QualType QT) {
+  std::string Str;
+  llvm::raw_string_ostream SS(Str);
+  PrintingPolicy Policy(Ctx.getPrintingPolicy());
+  // Print the Allocator in STL containers, for instance.
+  Policy.SuppressDefaultTemplateArgs = false;
+  Policy.SuppressUnwrittenScope = true;
+  // Print 'a<b<c> >' rather than 'a<b<c>>'.
+  Policy.SplitTemplateClosers = true;
+
+  struct LocalPrintingPolicyRAII {
+    ASTContext &Context;
+    PrintingPolicy Policy;
+
+    LocalPrintingPolicyRAII(ASTContext &Ctx, PrintingPolicy &PP)
+        : Context(Ctx), Policy(Ctx.getPrintingPolicy()) {
+      Context.setPrintingPolicy(PP);
+    }
+    ~LocalPrintingPolicyRAII() { Context.setPrintingPolicy(Policy); }
+  } X(Ctx, Policy);
+
+  const QualType NonRefTy = QT.getNonReferenceType();
+
+  if (const auto *TTy = llvm::dyn_cast<TagType>(NonRefTy))
+    SS << PrintDeclType(NonRefTy, TTy->getDecl());
+  else if (const auto *TRy = dyn_cast<RecordType>(NonRefTy))
+    SS << PrintDeclType(NonRefTy, TRy->getDecl());
+  else {
+    const QualType Canon = NonRefTy.getCanonicalType();
+    if (Canon->isBuiltinType() && !NonRefTy->isFunctionPointerType() &&
+        !NonRefTy->isMemberPointerType()) {
+      SS << Canon.getAsString(Ctx.getPrintingPolicy());
+    } else if (const auto *TDTy = dyn_cast<TypedefType>(NonRefTy)) {
+      // FIXME: TemplateSpecializationType & SubstTemplateTypeParmType checks
+      // are predominately to get STL containers to print nicer and might be
+      // better handled in GetFullyQualifiedName.
+      //
+      // std::vector<Type>::iterator is a TemplateSpecializationType
+      // std::vector<Type>::value_type is a SubstTemplateTypeParmType
+      //
+      QualType SSDesugar = TDTy->getLocallyUnqualifiedSingleStepDesugaredType();
+      if (llvm::isa<SubstTemplateTypeParmType>(SSDesugar))
+        SS << GetFullTypeName(Ctx, Canon);
+      else if (llvm::isa<TemplateSpecializationType>(SSDesugar))
+        SS << GetFullTypeName(Ctx, NonRefTy);
+      else
+        SS << PrintDeclType(NonRefTy, TDTy->getDecl());
+    } else
+      SS << GetFullTypeName(Ctx, NonRefTy);
+  }
+
+  if (QT->isReferenceType())
+    SS << " &";
+
+  return Str;
+}
+
+static std::string PrintEnum(const Value &V) {
+  std::string Str;
+  llvm::raw_string_ostream SS(Str);
+  ASTContext &Ctx = const_cast<ASTContext &>(V.getASTContext());
+
+  QualType DesugaredTy = V.getType().getDesugaredType(Ctx);
+  const EnumType *EnumTy = DesugaredTy.getNonReferenceType()->getAs<EnumType>();
+  assert(EnumTy && "Fail to cast to enum type");
+
+  EnumDecl *ED = EnumTy->getDecl();
+  uint64_t Data = V.getULongLong();
+  bool IsFirst = true;
+  llvm::APSInt AP = Ctx.MakeIntValue(Data, DesugaredTy);
+
+  for (auto I = ED->enumerator_begin(), E = ED->enumerator_end(); I != E; ++I) {
+    if (I->getInitVal() == AP) {
+      if (!IsFirst)
+        SS << " ? ";
+      SS << "(" + I->getQualifiedNameAsString() << ")";
+      IsFirst = false;
+    }
+  }
+
+  SS << " : " << PrintQualType(Ctx, ED->getIntegerType()) << " "
+     << llvm::toString(AP, /*Radix=*/10);
+  return Str;
+}
+
+static std::string PrintFunction(const Value &V, const void *Ptr) {
+  std::string Str;
+  llvm::raw_string_ostream SS(Str);
+  SS << "Function @" << Ptr;
+
+  const FunctionDecl *FD = nullptr;
+
+  auto Decls = V.getASTContext().getTranslationUnitDecl()->decls();
+  assert(std::distance(Decls.begin(), Decls.end()) == 1 &&
+         "TU should only contain one Decl");
+  auto *TLSD = llvm::cast<TopLevelStmtDecl>(*Decls.begin());
+
+  // Get __clang_Interpreter_SetValueNoAlloc(void *This, void *OutVal, void
+  // *OpaqueType, void *Val);
+  if (auto *InterfaceCall = llvm::dyn_cast<CallExpr>(TLSD->getStmt())) {
+    const auto *Arg = InterfaceCall->getArg(/*Val*/ 3);
+    // Get rid of cast nodes.
+    while (const CastExpr *CastE = llvm::dyn_cast<CastExpr>(Arg))
+      Arg = CastE->getSubExpr();
+    if (const DeclRefExpr *DeclRefExp = llvm::dyn_cast<DeclRefExpr>(Arg))
+      FD = llvm::dyn_cast<FunctionDecl>(DeclRefExp->getDecl());
+
+    if (FD) {
+      SS << '\n';
+      const clang::FunctionDecl *FDef;
+      if (FD->hasBody(FDef))
+        FDef->print(SS);
+    }
+  }
+  return Str;
+}
+
+static std::string PrintAddress(const void *Ptr, char Prefix) {
+  std::string Str;
+  llvm::raw_string_ostream SS(Str);
+  if (!Ptr)
+    return Str;
+  SS << Prefix << Ptr;
+  return Str;
+}
+
+// TODO: Encodings.
+static std::string PrintOneChar(char Val) {
+  std::string Str;
+  llvm::raw_string_ostream SS(Str);
+
+  SS << "'" << Val << "'";
+  return Str;
+}
+
+// Char pointers
+// Assumption is this is a string.
+// N is limit to prevent endless loop if Ptr is not really a string.
+static std::string PrintString(const char *const *Ptr, size_t N = 10000) {
+  std::string Str;
+  llvm::raw_string_ostream SS(Str);
+
+  const char *Start = *Ptr;
+  if (!Start)
+    return "nullptr";
+
+  const char *End = Start + N;
+  // If we're gonnd do this, better make sure the end is valid too
+  // FIXME: getpagesize() & GetSystemInfo().dwPageSize might be better
+  static constexpr auto PAGE_SIZE = 1024;
+  while (N > 1024) {
+    N -= PAGE_SIZE;
+    End = Start + N;
+  }
+
+  if (*Start == 0)
+    return "\"\"";
+
+  // Copy the bytes until we get a null-terminator
+  SS << "\"";
+  while (Start < End && *Start)
+    SS << *Start++;
+  SS << "\"";
+
+  return Str;
+}
+
+// Build the CallExpr to `PrintValueRuntime`.
+static void BuildWrapperBody(Interpreter &Interp, Sema &S, ASTContext &Ctx,
+                             FunctionDecl *WrapperFD, QualType QT,
+                             const void *ValPtr) {
+  Sema::SynthesizedFunctionScope SemaFScope(S, WrapperFD);
+  clang::Parser::ParseScope PS(
+      &Interp.getParser(), clang::Scope::FnScope | clang::Scope::BlockScope);
+
+  clang::DeclarationName RuntimeCallName =
+      S.PP.getIdentifierInfo("PrintValueRuntime");
+  clang::LookupResult R(S, RuntimeCallName, SourceLocation(),
+                        clang::Sema::LookupOrdinaryName);
+  S.LookupQualifiedName(R, Ctx.getTranslationUnitDecl());
+
+  Expr *OverldExpr = UnresolvedLookupExpr::Create(
+      Ctx, /*NamingClass=*/nullptr, NestedNameSpecifierLoc(),
+      clang::DeclarationNameInfo(RuntimeCallName, SourceLocation()),
+      /*RequiresADL*/ false, R.isOverloadedResult(), R.begin(), R.end());
+
+  if (const auto *AT = llvm::dyn_cast<AutoType>(QT.getTypePtr())) {
+    if (AT->isDeduced())
+      QT = AT->getDeducedType().getDesugaredType(Ctx);
+  }
+
+  if (const auto *PT = llvm::dyn_cast<PointerType>(QT.getTypePtr())) {
+    // Normalize `X*` to `const void*`, invoke `printValue(const void**)`,
+    // unless it's a character string.
+    QualType QTPointeeUnqual = PT->getPointeeType().getUnqualifiedType();
+    if (!Ctx.hasSameType(QTPointeeUnqual, Ctx.CharTy) &&
+        !Ctx.hasSameType(QTPointeeUnqual, Ctx.WCharTy) &&
+        !Ctx.hasSameType(QTPointeeUnqual, Ctx.Char16Ty) &&
+        !Ctx.hasSameType(QTPointeeUnqual, Ctx.Char32Ty)) {
+      QT = Ctx.getPointerType(Ctx.VoidTy.withConst());
+    }
+  } else if (const auto *RTy = llvm::dyn_cast<ReferenceType>(QT.getTypePtr())) {
+    // X& will be printed as X* (the pointer will be added below).
+    QT = RTy->getPointeeType();
+    // Val will be a X**, but we cast this to X*, so dereference here:
+    ValPtr = *(const void *const *)ValPtr;
+  }
+
+  // `PrintValueRuntime()` takes the *address* of the value to be printed:
+  QualType QTPtr = Ctx.getPointerType(QT);
+  Expr *TypeArg = CStyleCastPtrExpr(S, QTPtr, (uintptr_t)ValPtr);
+  llvm::SmallVector<Expr *, 1> CallArgs = {TypeArg};
+
+  // Create the CallExpr.
+  ExprResult RuntimeCall =
+      S.ActOnCallExpr(S.getCurScope(), OverldExpr, SourceLocation(), CallArgs,
+                      SourceLocation());
+  assert(!RuntimeCall.isInvalid() && "Cannot create call to PrintValueRuntime");
+
+  // Create the ReturnStmt.
+  StmtResult RetStmt =
+      S.ActOnReturnStmt(SourceLocation(), RuntimeCall.get(), S.getCurScope());
+  assert(!RetStmt.isInvalid() && "Cannot create ReturnStmt");
+
+  // Create the CompoundStmt.
+  StmtResult Body =
+      CompoundStmt::Create(Ctx, {RetStmt.get()}, FPOptionsOverride(),
+                           SourceLocation(), SourceLocation());
+  assert(!Body.isInvalid() && "Cannot create function body");
+
+  WrapperFD->setBody(Body.get());
+  // Add attribute `__attribute__((used))`.
+  WrapperFD->addAttr(UsedAttr::CreateImplicit(Ctx));
+}
+
+static constexpr const char *const WrapperName = "__InterpreterCallPrint";
+
+static std::string SynthesizeRuntimePrint(const Value &V) {
+  Interpreter &Interp = const_cast<Interpreter &>(V.getInterpreter());
+  Sema &S = Interp.getCompilerInstance()->getSema();
+  ASTContext &Ctx = S.getASTContext();
+
+  // Only include this header once and on demand. Because it's very heavy.
+  static bool Included = false;
+  if (!Included) {
+    Included = true;
+    llvm::cantFail(
+        Interp.Parse("#include <__clang_interpreter_runtime_printvalue.h>"));
+  }
+  // Lookup std::string.
+  NamespaceDecl *Std = LookupNamespace(S, "std");
+  assert(Std && "Cannot find namespace std");
+  Decl *StdStringDecl = LookupNamed(S, "string", Std);
+  assert(StdStringDecl && "Cannot find std::string");
+  const auto *StdStringTyDecl = llvm::dyn_cast<TypeDecl>(StdStringDecl);
+  assert(StdStringTyDecl && "Cannot find type of std::string");
+
+  // Create the wrapper function.
+  DeclarationName DeclName =
+      &Ctx.Idents.get(Interp.CreateUniqName(WrapperName));
+  QualType RetTy(StdStringTyDecl->getTypeForDecl(), 0);
+  QualType FnTy =
+      Ctx.getFunctionType(RetTy, {}, FunctionProtoType::ExtProtoInfo());
+  auto *WrapperFD = FunctionDecl::Create(
+      Ctx, Ctx.getTranslationUnitDecl(), SourceLocation(), SourceLocation(),
+      DeclName, FnTy, Ctx.getTrivialTypeSourceInfo(FnTy), SC_None);
+
+  void *ValPtr = V.getPtr();
+  if (!V.isManuallyAlloc())
+    ValPtr = V.getPtrAddress();
+
+  BuildWrapperBody(Interp, S, Ctx, WrapperFD, V.getType(), ValPtr);
+
+  auto AddrOrErr = Interp.CompileDecl(WrapperFD);
+  if (!AddrOrErr)
+    llvm::logAllUnhandledErrors(AddrOrErr.takeError(), llvm::errs(),
+                                "Fail to get symbol address");
+  if (auto *Main = AddrOrErr->toPtr<std::string (*)()>())
+    return (*Main)();
+  return "Error to print the value!";
+}
+
+REPL_EXTERNAL_VISIBILITY std::string PrintValueRuntime(const void *Ptr) {
+  return PrintAddress(Ptr, '@');
+}
+
+REPL_EXTERNAL_VISIBILITY std::string PrintValueRuntime(const void **Ptr) {
+  return PrintAddress(*Ptr, '@');
+}
+
+REPL_EXTERNAL_VISIBILITY std::string PrintValueRuntime(const bool *Val) {
+  if (*Val)
+    return "true";
+  return "false";
+}
+
+REPL_EXTERNAL_VISIBILITY std::string PrintValueRuntime(const char *Val) {
+  return PrintOneChar(*Val);
+}
+
+REPL_EXTERNAL_VISIBILITY std::string PrintValueRuntime(const signed char *Val) {
+  return PrintOneChar(*Val);
+}
+
+REPL_EXTERNAL_VISIBILITY std::string
+PrintValueRuntime(const unsigned char *Val) {
+  return PrintOneChar(*Val);
+}
+
+REPL_EXTERNAL_VISIBILITY std::string PrintValueRuntime(const short *Val) {
+  std::string Str;
+  llvm::raw_string_ostream SS(Str);
+  SS << *Val;
+  return Str;
+}
+
+REPL_EXTERNAL_VISIBILITY std::string
+PrintValueRuntime(const unsigned short *Val) {
+  std::string Str;
+  llvm::raw_string_ostream SS(Str);
+  SS << *Val;
+  return Str;
+}
+
+REPL_EXTERNAL_VISIBILITY std::string PrintValueRuntime(const int *Val) {
+  std::string Str;
+  llvm::raw_string_ostream SS(Str);
+  SS << *Val;
+  return Str;
+}
+
+REPL_EXTERNAL_VISIBILITY std::string
+PrintValueRuntime(const unsigned int *Val) {
+  std::string Str;
+  llvm::raw_string_ostream SS(Str);
+  SS << *Val;
+  return Str;
+}
+
+REPL_EXTERNAL_VISIBILITY std::string PrintValueRuntime(const long *Val) {
+  std::string Str;
+  llvm::raw_string_ostream SS(Str);
+  SS << *Val;
+  return Str;
+}
+
+REPL_EXTERNAL_VISIBILITY std::string PrintValueRuntime(const long long *Val) {
+  std::string Str;
+  llvm::raw_string_ostream SS(Str);
+  SS << *Val;
+  return Str;
+}
+
+REPL_EXTERNAL_VISIBILITY std::string
+PrintValueRuntime(const unsigned long *Val) {
+  std::string Str;
+  llvm::raw_string_ostream SS(Str);
+  SS << *Val;
+  return Str;
+}
+
+REPL_EXTERNAL_VISIBILITY std::string
+PrintValueRuntime(const unsigned long long *Val) {
+  std::string Str;
+  llvm::raw_string_ostream SS(Str);
+  SS << *Val;
+  return Str;
+}
+
+REPL_EXTERNAL_VISIBILITY std::string PrintValueRuntime(const float *Val) {
+  std::string Str;
+  llvm::raw_string_ostream SS(Str);
+  SS << llvm::format("%#.6g", *Val) << 'f';
+  return Str;
+}
+
+REPL_EXTERNAL_VISIBILITY std::string PrintValueRuntime(const double *Val) {
+  std::string Str;
+  llvm::raw_string_ostream SS(Str);
+  SS << llvm::format("%#.12g", *Val);
+  return Str;
+}
+
+REPL_EXTERNAL_VISIBILITY std::string PrintValueRuntime(const long double *Val) {
+  std::string Str;
+  llvm::raw_string_ostream SS(Str);
+  SS << llvm::format("%#.8Lg", *Val) << 'L';
+  return Str;
+}
+
+REPL_EXTERNAL_VISIBILITY std::string PrintValueRuntime(const char *const *Val) {
+  return PrintString(Val);
+}
+
+REPL_EXTERNAL_VISIBILITY std::string PrintValueRuntime(const char **Val) {
+  return PrintString(Val);
+}
+
+template <typename T> static std::string PrintValueWrapper(const T &Val) {
+  return PrintValueRuntime(&Val);
+}
+
+namespace clang {
+std::string ReplPrintDataImpl(const Value &V) {
+  std::string Str;
+  llvm::raw_string_ostream SS(Str);
+
+  QualType QT = V.getType();
+  QualType DesugaredTy = QT.getDesugaredType(V.getASTContext());
+  QualType NonRefTy = DesugaredTy.getNonReferenceType();
+
+  if (NonRefTy->isNullPtrType())
+    SS << "nullptr\n";
+  else if (NonRefTy->isEnumeralType())
+    return PrintEnum(V);
+  else if (NonRefTy->isFunctionType())
+    return PrintFunction(V, &V);
+  else if ((NonRefTy->isPointerType() || NonRefTy->isMemberPointerType()) &&
+           NonRefTy->getPointeeType()->isFunctionProtoType())
+    return PrintFunction(V, V.getPtr());
+  else if (auto *BT = DesugaredTy.getCanonicalType()->getAs<BuiltinType>()) {
+    switch (BT->getKind()) {
+    case BuiltinType::Bool: {
+      SS << PrintValueWrapper(V.getBool());
+      break;
+    }
+    case BuiltinType::Char_S:
+    case BuiltinType::SChar: {
+      SS << PrintValueWrapper(V.getSChar());
+      break;
+    }
+    case BuiltinType::Short: {
+      SS << PrintValueWrapper(V.getShort());
+      break;
+    }
+    case BuiltinType::Int: {
+      SS << PrintValueWrapper(V.getInt());
+      break;
+    }
+    case BuiltinType::Long: {
+      SS << PrintValueWrapper(V.getLong());
+      break;
+    }
+    case BuiltinType::LongLong: {
+      SS << PrintValueWrapper(V.getLongLong());
+      break;
+    }
+    case BuiltinType::Char_U:
+    case BuiltinType::UChar: {
+      SS << PrintValueWrapper(V.getUChar());
+      break;
+    }
+    case BuiltinType::UShort: {
+      SS << PrintValueWrapper(V.getUShort());
+      break;
+    }
+    case BuiltinType::UInt: {
+      SS << PrintValueWrapper(V.getUInt());
+      break;
+    }
+    case BuiltinType::ULong: {
+      SS << PrintValueWrapper(V.getULong());
+      break;
+    }
+    case BuiltinType::ULongLong: {
+      SS << PrintValueWrapper(V.getULongLong());
+      break;
+    }
+    case BuiltinType::Float: {
+      SS << PrintValueWrapper(V.getFloat());
+      break;
+    }
+    case BuiltinType::Double: {
+      SS << PrintValueWrapper(V.getDouble());
+      break;
+    }
+    case BuiltinType::LongDouble: {
+      SS << PrintValueWrapper(V.getLongDouble());
+      break;
+    }
+    default:
+      llvm_unreachable("Unknown Builtintype kind");
+    }
+  } else if (auto *CXXRD = NonRefTy->getAsCXXRecordDecl();
+             CXXRD && CXXRD->isLambda()) {
+    SS << PrintAddress(V.getPtr(), '@');
+  } else {
+    // All fails then generate a runtime call, this is slow.
+    SS << SynthesizeRuntimePrint(V);
+  }
+  return Str;
+}
+
+std::string ReplPrintTypeImpl(const Value &V) {
+  ASTContext &Ctx = const_cast<ASTContext &>(V.getASTContext());
+  QualType QT = V.getType();
+
+  return PrintQualType(Ctx, QT);
+}
+
+} // namespace clang

clang/test/Interpreter/pretty-print.cpp

+// RUN: clang-repl "int i = 10;" 'extern "C" int printf(const char*,...);' \
+// RUN:            'auto r1 = printf("i = %d\n", i);' | FileCheck --check-prefix=CHECK-DRIVER %s
+// UNSUPPORTED: system-aix
+// CHECK-DRIVER: i = 10
+// RUN: cat %s | clang-repl -Xcc -fno-delayed-template-parsing | FileCheck %s
+extern "C" int printf(const char*,...);
+
+char c = 'a';
+c
+// CHECK: (char) 'a'
+
+const char* c_str = "Goodbye, world!";
+c_str
+// CHECK-NEXT: (const char *) "Goodbye, world!"
+
+const char* c_null_str = 0;
+c_null_str
+// CHECK-NEXT: (const char *) nullptr
+
+"Hello, world"
+// CHECK-NEXT: (const char[13]) "Hello, world"
+
+int x = 42;
+x
+// CHECK-NEXT: (int) 42
+
+&x
+// CHECK-NEXT: (int *) [[Addr:@0x.*]]
+
+x - 2
+// CHECK-NEXT: (int) 40
+
+float f = 4.2f;
+f
+// CHECK-NEXT: (float) 4.20000f
+
+double d = 4.21;
+d
+// CHECK-NEXT: (double) 4.21000000000
+
+struct S1{};
+S1 s1;
+s1
+// CHECK-NEXT: (S1 &) [[Addr:@0x.*]]
+
+S1{}
+// CHECK-NEXT: (S1) [[Addr:@0x.*]]
+
+struct S2 {int d;} E = {22};
+E
+// CHECK-NEXT: (struct S2 &) [[Addr:@0x.*]]
+E.d
+// CHECK-NEXT: (int) 22
+
+struct S3 { int* p; S3() { p = new int(42); } ~S3() { delete p; } };
+S3{}
+// CHECK-NEXT: (S3) [[Addr:@0x.*]]
+S3 s3;
+s3
+// CHECK-NEXT: (S3 &) [[Addr:@0x.*]]
+
+struct S4 { ~S4() { printf("~S4()\n"); }};
+S4{}
+// CHECK-NEXT: (S4) [[Addr:@0x.*]]
+
+enum Enum{ e1 = -12, e2, e3=33, e4, e5 = 33};
+e2
+// CHECK-NEXT: (Enum) (e2) : int -11
+::e1
+// CHECK-NEXT: (Enum) (e1) : int -12
+
+enum class Color { Black = 0, Red, Green };
+Color::Black
+// CHECK-NEXT: (Color) (Color::Black) : int 0
+
+int arr[3] = {1,2,3};
+arr
+// CHECK-NEXT: (int[3]) { 1, 2, 3 }
+
+auto Lambda1 = []{};
+Lambda1
+// CHECK-NEXT: ((lambda) &) [[Addr:@0x.*]]
+[]{}
+// CHECK-NEXT: ((lambda at input_line_84:1:1)) [[Addr:@0x.*]]
+
+template<int n> struct F{ enum {RET=F<n-1>::RET*n} ; };
+template<> struct F<0> { enum {RET = 1}; };
+F<7>::RET
+// CHECK-NEXT: (F<7>::(unnamed enum at input_line_87:1:27)) (F<7>::RET) : unsigned int 5040
+
+int foo() { return 42; }
+foo()
+// CHECK-NEXT: (int) 42
+
+void bar() {}
+bar()
+
+struct S5 { int foo() { return 42; }};
+&S5::foo
+// CHECK-NEXT: (int (S5::*)()) Function [[Addr:@0x.*]]
+
+#include <memory>
+
+auto p1 = std::make_shared<int>(42);
+p1
+// CHECK-NEXT: (std::shared_ptr<int> &) std::shared_ptr -> [[Addr:@0x.*]]
+
+auto p2 = std::make_unique<int>(42);
+p2
+// CHECK-NEXT: (std::unique_ptr<int, std::default_delete<int> > &) std::unique_ptr -> [[Addr:@0x.*]]
+
+#include <array>
+std::array<int, 3> a{1, 2, 3};
+a
+// CHECK-NEXT: (std::array<int, 3> &) { 1, 2, 3 }
+
+#include <vector>
+std::vector<int> v1 = {7, 5, 16, 8};
+v1
+// CHECK-NEXT: (std::vector<int> &) { 7, 5, 16, 8 }
+
+std::vector<bool> v = {true, false, true};
+v
+// CHECK-NEXT: (std::vector<bool> &) { true, false, true }
+
+#include <deque>
+std::deque<int> dq = {7, 5, 16, 8};
+dq
+// CHECK-NEXT: (std::deque<int> &) { 7, 5, 16, 8 }
+
+#include <forward_list>
+std::forward_list<int> fl {3,4,5,6};
+fl
+// CHECK-NEXT: (std::forward_list<int> &) { 3, 4, 5, 6 }
+
+#include <set>
+std::set<int> z1 = {2,4,6,8};
+z1
+// CHECK-NEXT: (std::set<int> &) { 2, 4, 6, 8 }
+
+#include <unordered_set>
+std::unordered_set<int> z2 = {8,2,4,6};
+z2
+// CHECK-NEXT: (std::unordered_set<int> &) { [[Num:[0-9]+]], [[Num:[0-9]+]], [[Num:[0-9]+]], [[Num:[0-9]+]] }
+
+std::multiset<int> e {3,2,1,2,4,7,3};
+e
+// CHECK-NEXT: (std::multiset<int> &) { 1, 2, 2, 3, 3, 4, 7 }
+
+#include <string>
+std::string std_str = "Hello, world!";
+std_str
+// CHECK-NEXT: (std::string &) "Hello, world!"
+
+#include <utility>
+std::pair<int,char> pr(42,'a');
+pr
+// CHECK-NEXT: (std::pair<int, char> &) { 42, 'a' }
+
+#include <tuple>
+std::tuple<int,double,char> tu(42,3.14,'a');
+tu
+// CHECK-NEXT: (std::tuple<int, double, char> &) { 42, 3.14000000000, 'a' }
+
+#include <map>
+std::map<const char*, int> m1{{"CPU", 10}, {"GPU", 15}, {"RAM", 20}};
+m1
+// CHECK-NEXT: (std::map<const char *, int> &) { "CPU" => 10, "GPU" => 15, "RAM" => 20 }
+
+#include <unordered_map>
+std::unordered_map<int, int> m2 = { {1,2}, {3,4}};
+m2
+// CHECK-NEXT: (std::unordered_map<int, int> &) { [[Num:[0-9]+]] => [[Num:[0-9]+]], [[Num:[0-9]+]] => [[Num:[0-9]+]] }
+
+struct MyType {};
+std::string PrintValueRuntime(const MyType*) { return "My pretty printer!"; }
+MyType{}
+// CHECK-NEXT: (MyType) My pretty printer!
+%quit
+

clang/tools/clang-repl/CMakeLists.txt

 set( LLVM_LINK_COMPONENTS
   ${LLVM_TARGETS_TO_BUILD}
   Core
   LineEditor
   Option
   OrcJIT
   Support
   )
 
 add_clang_tool(clang-repl
   ClangRepl.cpp
   )
 
+if(MSVC)
+  set_target_properties(clang-repl PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS 1)
+
+  # RTTI/C++ symbols
+  set(clang_repl_exports ${clang_repl_exports} ??_7type_info@@6B@
+    ?__type_info_root_node@@3U__type_info_node@@A
+    ?nothrow@std@@3Unothrow_t@1@B
+  )
+
+  # Compiler added symbols for static variables. NOT for VStudio < 2015
+  set(clang_repl_exports ${clang_repl_exports} _Init_thread_abort _Init_thread_epoch
+    _Init_thread_footer _Init_thread_header _tls_index
+  )
+
+  if(CMAKE_SIZEOF_VOID_P EQUAL 8)
+    # new/delete variants needed when linking to static msvc runtime (esp. Debug)
+    set(clang_repl_exports ${clang_repl_exports}
+      ??2@YAPEAX_K@Z
+      ??3@YAXPEAX@Z
+      ??_U@YAPEAX_K@Z
+      ??_V@YAXPEAX@Z
+      ??3@YAXPEAX_K@Z
+      ??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@H@Z
+      ??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@M@Z
+      ??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@N@Z
+      ??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@PEBX@Z
+      ??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@P6AAEAV01@AEAV01@@Z@Z
+      ??$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@D@Z
+      ??$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@PEBD@Z
+      ?_Facet_Register@std@@YAXPEAV_Facet_base@1@@Z
+    )
+  else()
+    set(clang_repl_exports ${clang_repl_exports}
+      ??2@YAPAXI@Z
+      ??3@YAXPAX@Z
+      ??3@YAXPAXI@Z
+      ??_U@YAPAXI@Z
+      ??_V@YAXPAX@Z
+      ??_V@YAXPAXI@Z
+      ??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV01@H@Z
+      ??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV01@M@Z
+      ??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV01@N@Z
+      ??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV01@PBX@Z
+      ??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV01@P6AAAV01@AAV01@@Z@Z
+      ??$?6U?$char_traits@D@std@@@std@@YAAAV?$basic_ostream@DU?$char_traits@D@std@@@0@AAV10@D@Z
+      ??$?6U?$char_traits@D@std@@@std@@YAAAV?$basic_ostream@DU?$char_traits@D@std@@@0@AAV10@PBD@Z
+      ?_Facet_Register@std@@YAXPAV_Facet_base@1@@Z
+    )
+  endif()
+
+  # List to '/EXPORT:sym0 /EXPORT:sym1 /EXPORT:sym2 ...'
+  foreach(sym ${clang_repl_exports})
+    set(clang_repl_link_str "${clang_repl_link_str} /EXPORT:${sym}")
+  endforeach(sym ${clang_repl_exports})
+
+  set_property(TARGET clang-repl APPEND_STRING PROPERTY LINK_FLAGS ${clang_repl_link_str})
+
+endif(MSVC)
+
 clang_target_link_libraries(clang-repl PRIVATE
   clangAST
   clangBasic
   clangFrontend
   clangInterpreter
   )
 
 # Support plugins.
 if(CLANG_PLUGIN_SUPPORT)
   export_executable_symbols_for_plugins(clang-repl)
 endif()

clang/tools/clang-repl/ClangRepl.cpp

else {
       llvm::consumeError(J.takeError());
       llvm::outs() << "false\n";
     }
     return 0;
   }
 
   // FIXME: Investigate if we could use runToolOnCodeWithArgs from tooling. It
   // can replace the boilerplate code for creation of the compiler instance.
-  auto CI = ExitOnErr(clang::IncrementalCompilerBuilder::create(ClangArgv));
+  auto CI =
+      ExitOnErr(clang::caas::IncrementalCompilerBuilder::create(ClangArgv));
 
   // Set an error handler, so that any LLVM backend diagnostics go through our
   // error handler.
   llvm::install_fatal_error_handler(LLVMErrorHandler,
                                     static_cast<void *>(&CI->getDiagnostics()));
 
   // Load any requested plugins.
   CI->LoadRequestedPlugins();
 
-  auto Interp = ExitOnErr(clang::Interpreter::create(std::move(CI)));
+  auto Interp = ExitOnErr(clang::caas::Interpreter::create(std::move(CI)));
   for (const std::string &input : OptInputs) {
     if (auto Err = Interp->ParseAndExecute(input))
       llvm::logAllUnhandledErrors(std::move(Err), llvm::errs(), "error: ");
   }
 
   bool HasError = false;
 
   if (OptInputs.empty()) {

clang/unittests/Interpreter/ExceptionTests/InterpreterExceptionTest.cpp

 #include "llvm/ExecutionEngine/Orc/LLJIT.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/TargetSelect.h"
 
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
 using namespace clang;
+using namespace clang::caas;
 
 namespace {
 using Args = std::vector<const char *>;
 static std::unique_ptr<Interpreter>
 createInterpreter(const Args &ExtraArgs = {},
                   DiagnosticConsumer *Client = nullptr) {
   Args ClangArgs = {"-Xclang", "-emit-llvm-only"};
   ClangArgs.insert(ClangArgs.end(), ExtraArgs.begin(), ExtraArgs.end());
-  auto CI = cantFail(clang::IncrementalCompilerBuilder::create(ClangArgs));
+  auto CI =
+      cantFail(clang::caas::IncrementalCompilerBuilder::create(ClangArgs));
   if (Client)
     CI->getDiagnostics().setClient(Client, /*ShouldOwnClient=*/false);
-  return cantFail(clang::Interpreter::create(std::move(CI)));
+  return cantFail(clang::caas::Interpreter::create(std::move(CI)));
 }
 
 TEST(InterpreterTest, CatchException) {
   llvm::llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
   llvm::InitializeNativeTarget();
   llvm::InitializeNativeTargetAsmPrinter();
 
   {

clang/unittests/Interpreter/IncrementalProcessingTest.cpp

 #include "llvm/TargetParser/Host.h"
 #include "llvm/TargetParser/Triple.h"
 #include "gtest/gtest.h"
 
 #include <memory>
 
 using namespace llvm;
 using namespace clang;
+using namespace clang::caas;
 
 namespace {
 
 // Incremental processing produces several modules, all using the same "main
 // file". Make sure CodeGen can cope with that, e.g. for static initializers.
 const char TestProgram1[] = "extern \"C\" int funcForProg1() { return 17; }\n"
                             "struct EmitCXXGlobalInitFunc1 {\n"
                             "   EmitCXXGlobalInitFunc1() {}\n"
const Function *getGlobalInit(llvm::Module *M) {
   return nullptr;
 }
 
 TEST(IncrementalProcessing, EmitCXXGlobalInitFunc) {
   std::vector<const char *> ClangArgv = {"-Xclang", "-emit-llvm-only"};
   auto CI = llvm::cantFail(IncrementalCompilerBuilder::create(ClangArgv));
   auto Interp = llvm::cantFail(Interpreter::create(std::move(CI)));
 
-  std::array<clang::PartialTranslationUnit *, 2> PTUs;
+  std::array<clang::caas::PartialTranslationUnit *, 2> PTUs;
 
   PTUs[0] = &llvm::cantFail(Interp->Parse(TestProgram1));
   ASSERT_TRUE(PTUs[0]->TheModule);
   ASSERT_TRUE(PTUs[0]->TheModule->getFunction("funcForProg1"));
 
   PTUs[1] = &llvm::cantFail(Interp->Parse(TestProgram2));
   ASSERT_TRUE(PTUs[1]->TheModule);
   ASSERT_TRUE(PTUs[1]->TheModule->getFunction("funcForProg2"));

clang/unittests/Interpreter/InterpreterTest.cpp

 #include "llvm/ExecutionEngine/Orc/LLJIT.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/TargetSelect.h"
 
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
 using namespace clang;
+using namespace caas;
 
 #if defined(_AIX)
 #define CLANG_INTERPRETER_NO_SUPPORT_EXEC
 #endif
 
 int Global = 42;
 // JIT reports symbol not found on Windows without the visibility attribute.
 REPL_EXTERNAL_VISIBILITY int getGlobal() { return Global; }
 REPL_EXTERNAL_VISIBILITY void setGlobal(int val) { Global = val; }
 
 namespace {
 using Args = std::vector<const char *>;
 static std::unique_ptr<Interpreter>
 createInterpreter(const Args &ExtraArgs = {},
                   DiagnosticConsumer *Client = nullptr) {
   Args ClangArgs = {"-Xclang", "-emit-llvm-only"};
   ClangArgs.insert(ClangArgs.end(), ExtraArgs.begin(), ExtraArgs.end());
-  auto CI = cantFail(clang::IncrementalCompilerBuilder::create(ClangArgs));
+  auto CI =
+      cantFail(clang::caas::IncrementalCompilerBuilder::create(ClangArgs));
   if (Client)
     CI->getDiagnostics().setClient(Client, /*ShouldOwnClient=*/false);
-  return cantFail(clang::Interpreter::create(std::move(CI)));
+  return cantFail(clang::caas::Interpreter::create(std::move(CI)));
 }
 
 static size_t DeclsSize(TranslationUnitDecl *PTUDecl) {
   return std::distance(PTUDecl->decls().begin(), PTUDecl->decls().end());
 }
 
 TEST(InterpreterTest, Sanity) {
   std::unique_ptr<Interpreter> Interp = createInterpreter();