[LLDB] Add some declarations related to REPL support for mojo

[wallace]

Summary

This simple diff declares some enum values needed to create a REPL for the mojo language.

[rriddle]

Could we switch the RTTI to use the llvm RTTI extension mechanism, instead of enums? Other classes have started doing this, and it'd be really nice if users can write REPLS without needing to touch upstream LLDB.

[bulbazord]

In D150303#4333215, @rriddle wrote:

Could we switch the RTTI to use the llvm RTTI extension mechanism, instead of enums? Other classes have started doing this, and it'd be really nice if users can write REPLS without needing to touch upstream LLDB.

+1, LLVM's RTTI mechanism would make it easier to add new things without needing to change base classes.

[wallace]

address comments

[bzcheeseman]

lldb/include/lldb/Expression/ExpressionTypeSystemHelper.h

32

I was expecting you'd just use RTTIExtends from Support/ExtensibleRTTI.h, any reason not to use that?

[wallace]

Sure, I can use it. I just didn't know it exists :)

[wallace]

Use RTTIExtends

[wallace]

nit

[bzcheeseman]

LGTM

lldb/include/lldb/Expression/ExpressionTypeSystemHelper.h

 //===-- ExpressionTypeSystemHelper.h ---------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_EXPRESSION_EXPRESSIONTYPESYSTEMHELPER_H
 #define LLDB_EXPRESSION_EXPRESSIONTYPESYSTEMHELPER_H
 
 #include "llvm/Support/Casting.h"
+#include "llvm/Support/ExtensibleRTTI.h"
 
 namespace lldb_private {
 
 /// \class ExpressionTypeSystemHelper ExpressionTypeSystemHelper.h
 /// "lldb/Expression/ExpressionTypeSystemHelper.h"
 /// A helper object that the Expression can pass to its ExpressionParser
-/// to provide generic information that
-/// any type of expression will need to supply.  It's only job is to support
-/// dyn_cast so that the expression parser can cast it back to the requisite
-/// specific type.
+/// to provide generic information that any type of expression will need to
+/// supply.  It's only job is to support dyn_cast so that the expression parser
+/// can cast it back to the requisite specific type.
 ///
 
-class ExpressionTypeSystemHelper {
+class ExpressionTypeSystemHelper
+    : public llvm::RTTIExtends<ExpressionTypeSystemHelper, llvm::RTTIRoot> {
 public:
-  enum LLVMCastKind {
-    eKindClangHelper,
-    eKindSwiftHelper,
-    eKindGoHelper,
-    kNumKinds
-  };
-
-  LLVMCastKind getKind() const { return m_kind; }
-
-  ExpressionTypeSystemHelper(LLVMCastKind kind) : m_kind(kind) {}
-
-  ~ExpressionTypeSystemHelper() = default;
+  /// LLVM RTTI support
+  static char ID;
 
-protected:
-  LLVMCastKind m_kind;
+  virtual ~ExpressionTypeSystemHelper() = default;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_EXPRESSION_EXPRESSIONTYPESYSTEMHELPER_H

lldb/include/lldb/Expression/ExpressionVariable.h

 #include <optional>
 #include <vector>
 
 #include "llvm/ADT/DenseMap.h"
 
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/lldb-public.h"
+#include "llvm/Support/ExtensibleRTTI.h"
 
 namespace lldb_private {
 
 class ExpressionVariable
-    : public std::enable_shared_from_this<ExpressionVariable> {
+    : public std::enable_shared_from_this<ExpressionVariable>,
+      public llvm::RTTIExtends<ExpressionVariable, llvm::RTTIRoot> {
 public:
-  // See TypeSystem.h for how to add subclasses to this.
-  enum LLVMCastKind { eKindClang, eKindSwift, eKindGo, kNumKinds };
+  /// LLVM RTTI support
+  static char ID;
 
-  LLVMCastKind getKind() const { return m_kind; }
+  ExpressionVariable();
 
-  ExpressionVariable(LLVMCastKind kind);
-  virtual ~ExpressionVariable();
+  virtual ~ExpressionVariable() = default;
 
   std::optional<uint64_t> GetByteSize() { return m_frozen_sp->GetByteSize(); }
 
   ConstString GetName() { return m_frozen_sp->GetName(); }
 
   lldb::ValueObjectSP GetValueObject() { return m_frozen_sp; }
 
   uint8_t *GetValueBytes();
public:
 
   typedef uint16_t FlagType;
 
   FlagType m_flags; // takes elements of Flags
 
   // these should be private
   lldb::ValueObjectSP m_frozen_sp;
   lldb::ValueObjectSP m_live_sp;
-  LLVMCastKind m_kind;
 };
 
 /// \class ExpressionVariableList ExpressionVariable.h
 /// "lldb/Expression/ExpressionVariable.h"
 /// A list of variable references.
 ///
 /// This class stores variables internally, acting as the permanent store.
 class ExpressionVariableList {
public:
   }
 
   void Clear() { m_variables.clear(); }
 
 private:
   std::vector<lldb::ExpressionVariableSP> m_variables;
 };
 
-class PersistentExpressionState : public ExpressionVariableList {
+class PersistentExpressionState
+    : public ExpressionVariableList,
+      public llvm::RTTIExtends<PersistentExpressionState, llvm::RTTIRoot> {
 public:
-  // See TypeSystem.h for how to add subclasses to this.
-  enum LLVMCastKind { eKindClang, eKindSwift, eKindGo, kNumKinds };
+  /// LLVM RTTI support
+  static char ID;
 
-  LLVMCastKind getKind() const { return m_kind; }
-
-  PersistentExpressionState(LLVMCastKind kind);
   virtual ~PersistentExpressionState();
 
   virtual lldb::ExpressionVariableSP
   CreatePersistentVariable(const lldb::ValueObjectSP &valobj_sp) = 0;
 
   virtual lldb::ExpressionVariableSP
   CreatePersistentVariable(ExecutionContextScope *exe_scope,
                            ConstString name, const CompilerType &type,
public:
 
   void RegisterExecutionUnit(lldb::IRExecutionUnitSP &execution_unit_sp);
 
 protected:
   virtual llvm::StringRef
   GetPersistentVariablePrefix(bool is_error = false) const = 0;
 
 private:
-  LLVMCastKind m_kind;
-
   typedef std::set<lldb::IRExecutionUnitSP> ExecutionUnitSet;
   ExecutionUnitSet
       m_execution_units; ///< The execution units that contain valuable symbols.
 
   typedef llvm::DenseMap<const char *, lldb::addr_t> SymbolMap;
   SymbolMap
       m_symbol_map; ///< The addresses of the symbols in m_execution_units.
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_EXPRESSION_EXPRESSIONVARIABLE_H

lldb/include/lldb/Expression/REPL.h

 #define LLDB_EXPRESSION_REPL_H
 
 #include <string>
 
 #include "lldb/Core/IOHandler.h"
 #include "lldb/Interpreter/OptionGroupFormat.h"
 #include "lldb/Interpreter/OptionGroupValueObjectDisplay.h"
 #include "lldb/Target/Target.h"
+#include "llvm/Support/ExtensibleRTTI.h"
 
 namespace lldb_private {
 
-class REPL : public IOHandlerDelegate {
+class REPL : public IOHandlerDelegate,
+             public llvm::RTTIExtends<REPL, llvm::RTTIRoot> {
 public:
-  // See TypeSystem.h for how to add subclasses to this.
-  enum LLVMCastKind { eKindClang, eKindSwift, eKindGo, kNumKinds };
+  /// LLVM RTTI support
+  static char ID;
 
-  LLVMCastKind getKind() const { return m_kind; }
-
-  REPL(LLVMCastKind kind, Target &target);
+  REPL(Target &target);
 
   ~REPL() override;
 
   /// Get a REPL with an existing target (or, failing that, a debugger to use),
   /// and (optional) extra arguments for the compiler.
   ///
   /// \param[out] Status
   ///     If this language is supported but the REPL couldn't be created, this
protected:
 
   std::string m_repl_source_path;
   bool m_dedicated_repl_mode = false;
 
   StringList m_code; // All accumulated REPL statements are saved here
 
   Target &m_target;
   lldb::IOHandlerSP m_io_handler_sp;
-  LLVMCastKind m_kind;
 
 private:
   std::string GetSourcePath();
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_EXPRESSION_REPL_H

lldb/source/Expression/CMakeLists.txt

 add_lldb_library(lldbExpression NO_PLUGIN_DEPENDENCIES
   DiagnosticManager.cpp
   DWARFExpression.cpp
   DWARFExpressionList.cpp
   Expression.cpp
+  ExpressionTypeSystemHelper.cpp
   ExpressionVariable.cpp
   FunctionCaller.cpp
   IRExecutionUnit.cpp
   IRInterpreter.cpp
   IRMemoryMap.cpp
   LLVMUserExpression.cpp
   Materializer.cpp
   ObjectFileJIT.cpp

lldb/source/Expression/ExpressionTypeSystemHelper.cpp

+//===-- ExpressionTypeSystemHelper.cpp ------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Expression/ExpressionTypeSystemHelper.h"
+
+using namespace lldb_private;
+
+char ExpressionTypeSystemHelper::ID;

lldb/source/Expression/ExpressionVariable.cpp

 #include "lldb/Expression/IRExecutionUnit.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/LLDBLog.h"
 #include "lldb/Utility/Log.h"
 #include <optional>
 
 using namespace lldb_private;
 
-ExpressionVariable::ExpressionVariable(LLVMCastKind kind)
-    : m_flags(0), m_kind(kind) {}
-ExpressionVariable::~ExpressionVariable() = default;
+char ExpressionVariable::ID;
+
+ExpressionVariable::ExpressionVariable() : m_flags(0) {}
 
 uint8_t *ExpressionVariable::GetValueBytes() {
   std::optional<uint64_t> byte_size = m_frozen_sp->GetByteSize();
   if (byte_size && *byte_size) {
     if (m_frozen_sp->GetDataExtractor().GetByteSize() < *byte_size) {
       m_frozen_sp->GetValue().ResizeData(*byte_size);
       m_frozen_sp->GetValue().GetData(m_frozen_sp->GetDataExtractor());
     }
     return const_cast<uint8_t *>(
         m_frozen_sp->GetDataExtractor().GetDataStart());
   }
   return nullptr;
 }
 
-PersistentExpressionState::PersistentExpressionState(LLVMCastKind kind)
-    : m_kind(kind) {}
+char PersistentExpressionState::ID;
+
 PersistentExpressionState::~PersistentExpressionState() = default;
 
 lldb::addr_t PersistentExpressionState::LookupSymbol(ConstString name) {
   SymbolMap::iterator si = m_symbol_map.find(name.GetCString());
 
   if (si != m_symbol_map.end())
     return si->second;
   else

lldb/source/Expression/REPL.cpp

 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/AnsiTerminal.h"
 
 #include <memory>
 
 using namespace lldb_private;
 
-REPL::REPL(LLVMCastKind kind, Target &target) : m_target(target), m_kind(kind) {
+char REPL::ID;
+
+REPL::REPL(Target &target) : m_target(target) {
   // Make sure all option values have sane defaults
   Debugger &debugger = m_target.GetDebugger();
   debugger.SetShowProgress(false);
   auto exe_ctx = debugger.GetCommandInterpreter().GetExecutionContext();
   m_format_options.OptionParsingStarting(&exe_ctx);
   m_varobj_options.OptionParsingStarting(&exe_ctx);
 }
 

lldb/source/Plugins/ExpressionParser/Clang/CMakeLists.txt

 add_lldb_library(lldbPluginExpressionParserClang
   ASTResultSynthesizer.cpp
   ASTStructExtractor.cpp
   ASTUtils.cpp
   ClangASTImporter.cpp
   ClangASTMetadata.cpp
   ClangASTSource.cpp
   ClangDeclVendor.cpp
   ClangExpressionDeclMap.cpp
+  ClangExpressionHelper.cpp
   ClangExpressionParser.cpp
   ClangExpressionSourceCode.cpp
   ClangExpressionUtil.cpp
   ClangExpressionVariable.cpp
   ClangExternalASTSourceCallbacks.cpp
   ClangFunctionCaller.cpp
   ClangHost.cpp
   ClangModulesDeclVendor.cpp

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionHelper.h

 }
 
 namespace lldb_private {
 
 class ClangExpressionDeclMap;
 class RecordingMemoryManager;
 
 // ClangExpressionHelper
-class ClangExpressionHelper : public ExpressionTypeSystemHelper {
+class ClangExpressionHelper
+    : public llvm::RTTIExtends<ClangExpressionHelper,
+                               ExpressionTypeSystemHelper> {
 public:
-  static bool classof(const ExpressionTypeSystemHelper *ts) {
-    return ts->getKind() == eKindClangHelper;
-  }
-
-  ClangExpressionHelper()
-      : ExpressionTypeSystemHelper(
-            ExpressionTypeSystemHelper::LLVMCastKind::eKindClangHelper) {}
-
-  /// Destructor
-  virtual ~ClangExpressionHelper() = default;
+  // LLVM RTTI support
+  static char ID;
 
   /// Return the object that the parser should use when resolving external
   /// values.  May be NULL if everything should be self-contained.
   virtual ClangExpressionDeclMap *DeclMap() = 0;
 
   /// Return the object that the parser should allow to access ASTs.
   /// May be NULL if the ASTs do not need to be transformed.
   ///
   /// \param[in] passthrough
   ///     The ASTConsumer that the returned transformer should send
   ///     the ASTs to after transformation.
   virtual clang::ASTConsumer *
   ASTTransformer(clang::ASTConsumer *passthrough) = 0;
 
   virtual void CommitPersistentDecls() {}
-
-protected:
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_EXPRESSIONPARSER_CLANG_CLANGEXPRESSIONHELPER_H

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionHelper.cpp

+//===-- ClangExpressionHelper.cpp -----------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "ClangExpressionHelper.h"
+
+using namespace lldb_private;
+
+char ClangExpressionHelper::ID;

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionVariable.h

 /// own data and are typed.
 ///
 /// Third, in a JIT-compiled expression, it stores the variables that the
 /// expression needs to have materialized and dematerialized at each
 /// execution.  These do not contain their own data but are named and typed.
 ///
 /// This class supports all of these use cases using simple type polymorphism,
 /// and provides necessary support methods.  Its interface is RTTI-neutral.
-class ClangExpressionVariable : public ExpressionVariable {
+class ClangExpressionVariable
+    : public llvm::RTTIExtends<ClangExpressionVariable, ExpressionVariable> {
 public:
+  // LLVM RTTI support
+  static char ID;
+
   ClangExpressionVariable(ExecutionContextScope *exe_scope,
                           lldb::ByteOrder byte_order, uint32_t addr_byte_size);
 
   ClangExpressionVariable(ExecutionContextScope *exe_scope, Value &value,
                           ConstString name, uint16_t flags = EVNone);
 
   ClangExpressionVariable(const lldb::ValueObjectSP &valobj_sp);
 
JITVars *GetJITVars(uint64_t parser_id) {
     if (i == m_jit_vars.end())
       return nullptr;
     else
       return &i->second;
   }
 
   TypeFromUser GetTypeFromUser();
 
-  // llvm casting support
-  static bool classof(const ExpressionVariable *ev) {
-    return ev->getKind() == ExpressionVariable::eKindClang;
-  }
-
   /// Members
   ClangExpressionVariable(const ClangExpressionVariable &) = delete;
   const ClangExpressionVariable &
   operator=(const ClangExpressionVariable &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_EXPRESSIONPARSER_CLANG_CLANGEXPRESSIONVARIABLE_H

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionVariable.cpp

 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Stream.h"
 #include "clang/AST/ASTContext.h"
 
 using namespace lldb_private;
 using namespace clang;
 
+char ClangExpressionVariable::ID;
+
 ClangExpressionVariable::ClangExpressionVariable(
     ExecutionContextScope *exe_scope, lldb::ByteOrder byte_order,
     uint32_t addr_byte_size)
-    : ExpressionVariable(LLVMCastKind::eKindClang), m_parser_vars(),
-      m_jit_vars() {
+    : m_parser_vars(), m_jit_vars() {
   m_flags = EVNone;
   m_frozen_sp =
       ValueObjectConstResult::Create(exe_scope, byte_order, addr_byte_size);
 }
 
 ClangExpressionVariable::ClangExpressionVariable(
     ExecutionContextScope *exe_scope, Value &value, ConstString name,
     uint16_t flags)
-    : ExpressionVariable(LLVMCastKind::eKindClang), m_parser_vars(),
-      m_jit_vars() {
+    : m_parser_vars(), m_jit_vars() {
   m_flags = flags;
   m_frozen_sp = ValueObjectConstResult::Create(exe_scope, value, name);
 }
 
 ClangExpressionVariable::ClangExpressionVariable(
     const lldb::ValueObjectSP &valobj_sp)
-    : ExpressionVariable(LLVMCastKind::eKindClang), m_parser_vars(),
-      m_jit_vars() {
+    : m_parser_vars(), m_jit_vars() {
   m_flags = EVNone;
   m_frozen_sp = valobj_sp;
 }
 
 ClangExpressionVariable::ClangExpressionVariable(
     ExecutionContextScope *exe_scope, ConstString name,
     const TypeFromUser &user_type, lldb::ByteOrder byte_order,
     uint32_t addr_byte_size)
-    : ExpressionVariable(LLVMCastKind::eKindClang), m_parser_vars(),
-      m_jit_vars() {
+    : m_parser_vars(), m_jit_vars() {
   m_flags = EVNone;
   m_frozen_sp =
       ValueObjectConstResult::Create(exe_scope, byte_order, addr_byte_size);
   SetName(name);
   SetCompilerType(user_type);
 }
 
 TypeFromUser ClangExpressionVariable::GetTypeFromUser() {
   TypeFromUser tfu(m_frozen_sp->GetCompilerType());
   return tfu;
 }

lldb/source/Plugins/ExpressionParser/Clang/ClangFunctionCaller.h

 /// pointer set to LLDB_INVALID_ADDRESS and new structure will be allocated
 /// and its address returned in that variable.
 ///
 /// Any of the methods that take arg_addr_ptr can be passed NULL, and the
 /// argument space will be managed for you.
 class ClangFunctionCaller : public FunctionCaller {
   friend class ASTStructExtractor;
 
-  class ClangFunctionCallerHelper : public ClangExpressionHelper {
+  class ClangFunctionCallerHelper
+      : public llvm::RTTIExtends<ClangFunctionCallerHelper,
+                                 ClangExpressionHelper> {
   public:
-    ClangFunctionCallerHelper(ClangFunctionCaller &owner) : m_owner(owner) {}
+    // LLVM RTTI support
+    static char ID;
 
-    ~ClangFunctionCallerHelper() override = default;
+    ClangFunctionCallerHelper(ClangFunctionCaller &owner) : m_owner(owner) {}
 
     /// Return the object that the parser should use when resolving external
     /// values.  May be NULL if everything should be self-contained.
     ClangExpressionDeclMap *DeclMap() override { return nullptr; }
 
     /// Return the object that the parser should allow to access ASTs. May be
     /// NULL if the ASTs do not need to be transformed.
     ///

lldb/source/Plugins/ExpressionParser/Clang/ClangFunctionCaller.cpp

ClangFunctionCaller::CompileFunction(lldb::ThreadSP thread_to_use_sp,
   m_compiled = (num_errors == 0);
 
   if (!m_compiled)
     return num_errors;
 
   return num_errors;
 }
 
+char ClangFunctionCaller::ClangFunctionCallerHelper::ID;
+
 clang::ASTConsumer *
 ClangFunctionCaller::ClangFunctionCallerHelper::ASTTransformer(
     clang::ASTConsumer *passthrough) {
   m_struct_extractor = std::make_unique<ASTStructExtractor>(
       passthrough, m_owner.GetWrapperStructName(), m_owner);
 
   return m_struct_extractor.get();
 }

lldb/source/Plugins/ExpressionParser/Clang/ClangPersistentVariables.h

 
 /// \class ClangPersistentVariables ClangPersistentVariables.h
 /// "lldb/Expression/ClangPersistentVariables.h" Manages persistent values
 /// that need to be preserved between expression invocations.
 ///
 /// A list of variables that can be accessed and updated by any expression.  See
 /// ClangPersistentVariable for more discussion.  Also provides an increasing,
 /// 0-based counter for naming result variables.
-class ClangPersistentVariables : public PersistentExpressionState {
+class ClangPersistentVariables
+    : public llvm::RTTIExtends<ClangPersistentVariables,
+                               PersistentExpressionState> {
 public:
+  // LLVM RTTI support
+  static char ID;
+
   ClangPersistentVariables(std::shared_ptr<Target> target_sp);
 
   ~ClangPersistentVariables() override = default;
 
-  // llvm casting support
-  static bool classof(const PersistentExpressionState *pv) {
-    return pv->getKind() == PersistentExpressionState::eKindClang;
-  }
-
   std::shared_ptr<ClangASTImporter> GetClangASTImporter();
   std::shared_ptr<ClangModulesDeclVendor> GetClangModulesDeclVendor();
 
   lldb::ExpressionVariableSP
   CreatePersistentVariable(const lldb::ValueObjectSP &valobj_sp) override;
 
   lldb::ExpressionVariableSP CreatePersistentVariable(
       ExecutionContextScope *exe_scope, ConstString name,

lldb/source/Plugins/ExpressionParser/Clang/ClangPersistentVariables.cpp

 
 #include "llvm/ADT/StringMap.h"
 #include <optional>
 #include <memory>
 
 using namespace lldb;
 using namespace lldb_private;
 
+char ClangPersistentVariables::ID;
+
 ClangPersistentVariables::ClangPersistentVariables(
     std::shared_ptr<Target> target_sp)
-    : lldb_private::PersistentExpressionState(LLVMCastKind::eKindClang),
-      m_target_sp(target_sp) {}
+    : m_target_sp(target_sp) {}
 
 ExpressionVariableSP ClangPersistentVariables::CreatePersistentVariable(
     const lldb::ValueObjectSP &valobj_sp) {
   return AddNewlyConstructedVariable(new ClangExpressionVariable(valobj_sp));
 }
 
 ExpressionVariableSP ClangPersistentVariables::CreatePersistentVariable(
     ExecutionContextScope *exe_scope, ConstString name,

lldb/source/Plugins/ExpressionParser/Clang/ClangUserExpression.h

 public:
   bool isA(const void *ClassID) const override {
     return ClassID == &ID || LLVMUserExpression::isA(ClassID);
   }
   static bool classof(const Expression *obj) { return obj->isA(&ID); }
 
   enum { kDefaultTimeout = 500000u };
 
-  class ClangUserExpressionHelper : public ClangExpressionHelper {
+  class ClangUserExpressionHelper
+      : public llvm::RTTIExtends<ClangUserExpressionHelper,
+                                 ClangExpressionHelper> {
   public:
+    // LLVM RTTI support
+    static char ID;
+
     ClangUserExpressionHelper(Target &target, bool top_level)
         : m_target(target), m_top_level(top_level) {}
 
-    ~ClangUserExpressionHelper() override = default;
-
     /// Return the object that the parser should use when resolving external
     /// values.  May be NULL if everything should be self-contained.
     ClangExpressionDeclMap *DeclMap() override {
       return m_expr_decl_map_up.get();
     }
 
     void ResetDeclMap() { m_expr_decl_map_up.reset(); }
 

lldb/source/Plugins/ExpressionParser/Clang/ClangUserExpression.cpp

bool ClangUserExpression::AddArguments(ExecutionContext &exe_ctx,
   return true;
 }
 
 lldb::ExpressionVariableSP ClangUserExpression::GetResultAfterDematerialization(
     ExecutionContextScope *exe_scope) {
   return m_result_delegate.GetVariable();
 }
 
+char ClangUserExpression::ClangUserExpressionHelper::ID;
+
 void ClangUserExpression::ClangUserExpressionHelper::ResetDeclMap(
     ExecutionContext &exe_ctx,
     Materializer::PersistentVariableDelegate &delegate,
     bool keep_result_in_memory,
     ValueObject *ctx_obj) {
   std::shared_ptr<ClangASTImporter> ast_importer;
   auto *state = exe_ctx.GetTargetSP()->GetPersistentExpressionStateForLanguage(
       lldb::eLanguageTypeC);

lldb/source/Plugins/ExpressionParser/Clang/ClangUtilityFunction.h

public:
   void ResetDeclMap(ExecutionContext &exe_ctx, bool keep_result_in_memory) {
     m_type_system_helper.ResetDeclMap(exe_ctx, keep_result_in_memory);
   }
 
   bool Install(DiagnosticManager &diagnostic_manager,
                ExecutionContext &exe_ctx) override;
 
 private:
-  class ClangUtilityFunctionHelper : public ClangExpressionHelper {
+  class ClangUtilityFunctionHelper
+      : public llvm::RTTIExtends<ClangUtilityFunctionHelper,
+                                 ClangExpressionHelper> {
   public:
-    ClangUtilityFunctionHelper() = default;
-
-    ~ClangUtilityFunctionHelper() override = default;
+    // LLVM RTTI support
+    static char ID;
 
     /// Return the object that the parser should use when resolving external
     /// values.  May be NULL if everything should be self-contained.
     ClangExpressionDeclMap *DeclMap() override {
       return m_expr_decl_map_up.get();
     }
 
     void ResetDeclMap() { m_expr_decl_map_up.reset(); }

lldb/source/Plugins/ExpressionParser/Clang/ClangUtilityFunction.cpp

if (jit_error.Success()) {
     } else {
       diagnostic_manager.PutString(eDiagnosticSeverityError,
                                    "expression can't be interpreted or run");
     }
     return false;
   }
 }
 
+char ClangUtilityFunction::ClangUtilityFunctionHelper::ID;
+
 void ClangUtilityFunction::ClangUtilityFunctionHelper::ResetDeclMap(
     ExecutionContext &exe_ctx, bool keep_result_in_memory) {
   std::shared_ptr<ClangASTImporter> ast_importer;
   auto *state = exe_ctx.GetTargetSP()->GetPersistentExpressionStateForLanguage(
       lldb::eLanguageTypeC);
   if (state) {
     auto *persistent_vars = llvm::cast<ClangPersistentVariables>(state);
     ast_importer = persistent_vars->GetClangASTImporter();
   }
   m_expr_decl_map_up = std::make_unique<ClangExpressionDeclMap>(
       keep_result_in_memory, nullptr, exe_ctx.GetTargetSP(), ast_importer,
       nullptr);
 }

lldb/source/Plugins/REPL/Clang/ClangREPL.h

 //===-- ClangREPL.h ---------------------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_SOURCE_PLUGINS_REPL_CLANG_CLANGREPL_H
 #define LLDB_SOURCE_PLUGINS_REPL_CLANG_CLANGREPL_H
 
 #include "lldb/Expression/REPL.h"
 
 namespace lldb_private {
 /// Implements a Clang-based REPL for C languages on top of LLDB's REPL
 /// framework.
-class ClangREPL : public REPL {
+class ClangREPL : public llvm::RTTIExtends<ClangREPL, REPL> {
 public:
+  // LLVM RTTI support
+  static char ID;
+
   ClangREPL(lldb::LanguageType language, Target &target);
 
   ~ClangREPL() override;
 
   static void Initialize();
 
   static void Terminate();
 

lldb/source/Plugins/REPL/Clang/ClangREPL.cpp

 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Expression/ExpressionVariable.h"
 
 using namespace lldb_private;
 
 LLDB_PLUGIN_DEFINE(ClangREPL)
 
+char ClangREPL::ID;
+
 ClangREPL::ClangREPL(lldb::LanguageType language, Target &target)
-    : REPL(eKindClang, target), m_language(language),
+    : llvm::RTTIExtends<ClangREPL, REPL>(target), m_language(language),
       m_implicit_expr_result_regex("\\$[0-9]+") {}
 
 ClangREPL::~ClangREPL() = default;
 
 void ClangREPL::Initialize() {
   LanguageSet languages;
   // FIXME: There isn't a way to ask CPlusPlusLanguage and ObjCLanguage for
   // a list of languages they support.