[lldb] Create a property to store the REPL language

[JDevlieghere]

Summary

Until the introduction of the C++ REPL, there was always a single REPL language. The code relied on this assumption through repl_languages.GetSingularLanguage. Now that this is no longer the case, we need a way to specify a selected/preferred REPL language. This patch does that with the help of a debugger property, taking inspiration from how we store the scripting language.

[JDevlieghere]

No test because this is NFC (NOC, non observable change?) upstream where there's only one supported REPL language. This is tested downstream in the Swift fork.

[aprantl]

lldb/source/Core/Debugger.cpp

1777

As you said in the description, this is effectively dead code. Is this to be removed in a subsequent patch?

lldb/source/Interpreter/CommandInterpreter.cpp

2265

Is this case used by anyone? Should we just error out if it's unknown?

[JDevlieghere]

lldb/source/Core/Debugger.cpp

1777

It's still relevant here (upstream) where there's only a single REPL language. The way the plugin mechanism works, anyone downstream could build LLDB with just a single REPL plugin. Because this is all done through plugins, the default REPL language is unknown. I vote to keep it around until there's a good way to set it. The latter isn't hard technically, it's just a matter of doing it in an organized way. E.g. who wins if two plugins want to be the default?

lldb/source/Interpreter/CommandInterpreter.cpp

2265

Similar answer to above.

lldb/include/lldb/API/SBDebugger.h

public:
   void SetPrompt(const char *prompt);
 
   const char *GetReproducerPath() const;
 
   lldb::ScriptLanguage GetScriptLanguage() const;
 
   void SetScriptLanguage(lldb::ScriptLanguage script_lang);
 
+  lldb::LanguageType GetREPLLanguage() const;
+
+  void SetREPLLanguage(lldb::LanguageType repl_lang);
+
   bool GetCloseInputOnEOF() const;
 
   void SetCloseInputOnEOF(bool b);
 
   SBTypeCategory GetCategory(const char *category_name);
 
   SBTypeCategory GetCategory(lldb::LanguageType lang_type);
 

lldb/include/lldb/Core/Debugger.h

public:
   const FormatEntity::Entry *GetThreadFormat() const;
 
   const FormatEntity::Entry *GetThreadStopFormat() const;
 
   lldb::ScriptLanguage GetScriptLanguage() const;
 
   bool SetScriptLanguage(lldb::ScriptLanguage script_lang);
 
+  lldb::LanguageType GetREPLLanguage() const;
+
+  bool SetREPLLanguage(lldb::LanguageType repl_lang);
+
   uint32_t GetTerminalWidth() const;
 
   bool SetTerminalWidth(uint32_t term_width);
 
   llvm::StringRef GetPrompt() const;
 
   void SetPrompt(llvm::StringRef p);
   void SetPrompt(const char *) = delete;

lldb/include/lldb/Interpreter/OptionValueProperties.h

public:
   OptionValueArch *
   GetPropertyAtIndexAsOptionValueArch(const ExecutionContext *exe_ctx,
                                       uint32_t idx) const;
 
   OptionValueLanguage *
   GetPropertyAtIndexAsOptionValueLanguage(const ExecutionContext *exe_ctx,
                                           uint32_t idx) const;
 
+  bool SetPropertyAtIndexAsLanguage(const ExecutionContext *exe_ctx,
+                                    uint32_t idx, lldb::LanguageType lang);
+
   bool GetPropertyAtIndexAsArgs(const ExecutionContext *exe_ctx, uint32_t idx,
                                 Args &args) const;
 
   bool SetPropertyAtIndexFromArgs(const ExecutionContext *exe_ctx, uint32_t idx,
                                   const Args &args);
 
   bool GetPropertyAtIndexAsBoolean(const ExecutionContext *exe_ctx,
                                    uint32_t idx, bool fail_value) const;

lldb/source/API/SBDebugger.cpp

void SBDebugger::SetScriptLanguage(ScriptLanguage script_lang) {
   LLDB_RECORD_METHOD(void, SBDebugger, SetScriptLanguage,
                      (lldb::ScriptLanguage), script_lang);
 
   if (m_opaque_sp) {
     m_opaque_sp->SetScriptLanguage(script_lang);
   }
 }
 
+LanguageType SBDebugger::GetREPLLanguage() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::LanguageType, SBDebugger,
+                                   GetREPLLanguage);
+
+  return (m_opaque_sp ? m_opaque_sp->GetREPLLanguage() : eLanguageTypeUnknown);
+}
+
+void SBDebugger::SetREPLLanguage(LanguageType repl_lang) {
+  LLDB_RECORD_METHOD(void, SBDebugger, SetREPLLanguage, (lldb::LanguageType),
+                     repl_lang);
+
+  if (m_opaque_sp) {
+    m_opaque_sp->SetREPLLanguage(repl_lang);
+  }
+}
+
 bool SBDebugger::SetUseExternalEditor(bool value) {
   LLDB_RECORD_METHOD(bool, SBDebugger, SetUseExternalEditor, (bool), value);
 
   return (m_opaque_sp ? m_opaque_sp->SetUseExternalEditor(value) : false);
 }
 
 bool SBDebugger::GetUseExternalEditor() {
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBDebugger, GetUseExternalEditor);
template <> void RegisterMethods<SBDebugger>(Registry &R) {
   LLDB_REGISTER_METHOD(void, SBDebugger, SetTerminalWidth, (uint32_t));
   LLDB_REGISTER_METHOD_CONST(const char *, SBDebugger, GetPrompt, ());
   LLDB_REGISTER_METHOD(void, SBDebugger, SetPrompt, (const char *));
   LLDB_REGISTER_METHOD_CONST(const char *, SBDebugger, GetReproducerPath, ());
   LLDB_REGISTER_METHOD_CONST(lldb::ScriptLanguage, SBDebugger,
                              GetScriptLanguage, ());
   LLDB_REGISTER_METHOD(void, SBDebugger, SetScriptLanguage,
                        (lldb::ScriptLanguage));
+  LLDB_REGISTER_METHOD_CONST(lldb::LanguageType, SBDebugger, GetREPLLanguage,
+                             ());
+  LLDB_REGISTER_METHOD(void, SBDebugger, SetREPLLanguage, (lldb::LanguageType));
   LLDB_REGISTER_METHOD(bool, SBDebugger, SetUseExternalEditor, (bool));
   LLDB_REGISTER_METHOD(bool, SBDebugger, GetUseExternalEditor, ());
   LLDB_REGISTER_METHOD(bool, SBDebugger, SetUseColor, (bool));
   LLDB_REGISTER_METHOD_CONST(bool, SBDebugger, GetUseColor, ());
   LLDB_REGISTER_METHOD(bool, SBDebugger, GetDescription, (lldb::SBStream &));
   LLDB_REGISTER_METHOD(lldb::user_id_t, SBDebugger, GetID, ());
   LLDB_REGISTER_METHOD(lldb::SBError, SBDebugger, SetCurrentPlatform,
                        (const char *));

lldb/source/Core/CoreProperties.td

def Prompt: Property<"prompt", "String">,
     DefaultEnumValue<"OptionValueString::eOptionEncodeCharacterEscapeSequences">,
     DefaultStringValue<"(lldb) ">,
     Desc<"The debugger command line prompt displayed for the user.">;
   def ScriptLanguage: Property<"script-lang", "Enum">,
     Global,
     DefaultEnumValue<"eScriptLanguagePython">,
     EnumValues<"OptionEnumValues(g_language_enumerators)">,
     Desc<"The script language to be used for evaluating user-written scripts.">;
+  def REPLLanguage: Property<"repl-lang", "Language">,
+    Global,
+    DefaultEnumValue<"eLanguageTypeUnknown">,
+    Desc<"The language to use for the REPL.">;
   def StopDisassemblyCount: Property<"stop-disassembly-count", "SInt64">,
     Global,
     DefaultUnsignedValue<4>,
     Desc<"The number of disassembly lines to show when displaying a stopped context.">;
   def StopDisassemblyDisplay: Property<"stop-disassembly-display", "Enum">,
     Global,
     DefaultEnumValue<"Debugger::eStopDisassemblyTypeNoDebugInfo">,
     EnumValues<"OptionEnumValues(g_show_disassembly_enum_values)">,

lldb/source/Core/Debugger.cpp

 #include "lldb/Host/File.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Host/Terminal.h"
 #include "lldb/Host/ThreadLauncher.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Interpreter/OptionValue.h"
+#include "lldb/Interpreter/OptionValueLanguage.h"
 #include "lldb/Interpreter/OptionValueProperties.h"
 #include "lldb/Interpreter/OptionValueSInt64.h"
 #include "lldb/Interpreter/OptionValueString.h"
 #include "lldb/Interpreter/Property.h"
 #include "lldb/Interpreter/ScriptInterpreter.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Symbol/SymbolContext.h"

 }
 
 bool Debugger::SetScriptLanguage(lldb::ScriptLanguage script_lang) {
   const uint32_t idx = ePropertyScriptLanguage;
   return m_collection_sp->SetPropertyAtIndexAsEnumeration(nullptr, idx,
                                                           script_lang);
 }
 
+lldb::LanguageType Debugger::GetREPLLanguage() const {
+  const uint32_t idx = ePropertyREPLLanguage;
+  OptionValueLanguage *value =
+      m_collection_sp->GetPropertyAtIndexAsOptionValueLanguage(nullptr, idx);
+  if (value)
+    return value->GetCurrentValue();
+  return LanguageType();
+}
+
+bool Debugger::SetREPLLanguage(lldb::LanguageType repl_lang) {
+  const uint32_t idx = ePropertyREPLLanguage;
+  return m_collection_sp->SetPropertyAtIndexAsLanguage(nullptr, idx, repl_lang);
+}
+
 uint32_t Debugger::GetTerminalWidth() const {
   const uint32_t idx = ePropertyTerminalWidth;
   return m_collection_sp->GetPropertyAtIndexAsSInt64(
       nullptr, idx, g_debugger_properties[idx].default_uint_value);
 }
 
 bool Debugger::SetTerminalWidth(uint32_t term_width) {
   if (auto handler_sp = m_io_handler_stack.Top())
Target &Debugger::GetSelectedOrDummyTarget(bool prefer_dummy) {
   }
   return GetDummyTarget();
 }
 
 Status Debugger::RunREPL(LanguageType language, const char *repl_options) {
   Status err;
   FileSpec repl_executable;
 
+  if (language == eLanguageTypeUnknown)
+    language = GetREPLLanguage();
+
   if (language == eLanguageTypeUnknown) {
     LanguageSet repl_languages = Language::GetLanguagesSupportingREPLs();
 
     if (auto single_lang = repl_languages.GetSingularLanguage()) {
       language = *single_lang;
     } else if (repl_languages.Empty()) {
-      err.SetErrorStringWithFormat(
+      err.SetErrorString(
           "LLDB isn't configured with REPL support for any languages.");
       return err;
     } else {
-      err.SetErrorStringWithFormat(
+      err.SetErrorString(
           "Multiple possible REPL languages.  Please specify a language.");
       return err;
     }
   }
 
   Target *const target =
       nullptr; // passing in an empty target means the REPL must create one
 

lldb/source/Interpreter/CommandInterpreter.cpp

static void GetHomeInitFile(llvm::SmallVectorImpl<char> &init_file,
   }
 
   FileSystem::Instance().GetHomeDirectory(init_file);
   llvm::sys::path::append(init_file, init_file_name);
 
   FileSystem::Instance().Resolve(init_file);
 }
 
-static void GetHomeREPLInitFile(llvm::SmallVectorImpl<char> &init_file) {
+static void GetHomeREPLInitFile(llvm::SmallVectorImpl<char> &init_file,
+                                LanguageType language) {
+  if (language == eLanguageTypeUnknown) {
     LanguageSet repl_languages = Language::GetLanguagesSupportingREPLs();
-  LanguageType language = eLanguageTypeUnknown;
     if (auto main_repl_language = repl_languages.GetSingularLanguage())
       language = *main_repl_language;
     else
       return;
+  }
 
   std::string init_file_name =
       (llvm::Twine(".lldbinit-") +
        llvm::Twine(Language::GetNameForLanguageType(language)) +
        llvm::Twine("-repl"))
           .str();
   FileSystem::Instance().GetHomeDirectory(init_file);
   llvm::sys::path::append(init_file, init_file_name);
void CommandInterpreter::SourceInitFileHome(CommandReturnObject &result,
   if (m_skip_lldbinit_files) {
     result.SetStatus(eReturnStatusSuccessFinishNoResult);
     return;
   }
 
   llvm::SmallString<128> init_file;
 
   if (is_repl)
-    GetHomeREPLInitFile(init_file);
+    GetHomeREPLInitFile(init_file, GetDebugger().GetREPLLanguage());
 
   if (init_file.empty())
     GetHomeInitFile(init_file);
 
   if (!m_skip_app_init_files) {
     llvm::StringRef program_name =
         HostInfo::GetProgramFileSpec().GetFilename().GetStringRef();
     llvm::SmallString<128> program_init_file;

lldb/source/Interpreter/OptionValueProperties.cpp

 OptionValueProperties::GetPropertyAtIndexAsOptionValueLanguage(
     const ExecutionContext *exe_ctx, uint32_t idx) const {
   const Property *property = GetPropertyAtIndex(exe_ctx, false, idx);
   if (property)
     return property->GetValue()->GetAsLanguage();
   return nullptr;
 }
 
+bool OptionValueProperties::SetPropertyAtIndexAsLanguage(
+    const ExecutionContext *exe_ctx, uint32_t idx, const LanguageType lang) {
+  const Property *property = GetPropertyAtIndex(exe_ctx, true, idx);
+  if (property) {
+    OptionValue *value = property->GetValue().get();
+    if (value)
+      return value->SetLanguageValue(lang);
+  }
+  return false;
+}
+
 bool OptionValueProperties::GetPropertyAtIndexAsArgs(
     const ExecutionContext *exe_ctx, uint32_t idx, Args &args) const {
   const Property *property = GetPropertyAtIndex(exe_ctx, false, idx);
   if (!property)
     return false;
 
   OptionValue *value = property->GetValue().get();
   if (!value)

lldb/source/Target/Target.cpp

m_process_sp = Process::FindPlugin(shared_from_this(), plugin_name,
                                      listener_sp, crash_file, can_connect);
   return m_process_sp;
 }
 
 const lldb::ProcessSP &Target::GetProcessSP() const { return m_process_sp; }
 
 lldb::REPLSP Target::GetREPL(Status &err, lldb::LanguageType language,
                              const char *repl_options, bool can_create) {
+  if (language == eLanguageTypeUnknown)
+    language = m_debugger.GetREPLLanguage();
+
   if (language == eLanguageTypeUnknown) {
     LanguageSet repl_languages = Language::GetLanguagesSupportingREPLs();
 
     if (auto single_lang = repl_languages.GetSingularLanguage()) {
       language = *single_lang;
     } else if (repl_languages.Empty()) {
-      err.SetErrorStringWithFormat(
+      err.SetErrorString(
           "LLDB isn't configured with REPL support for any languages.");
       return REPLSP();
     } else {
-      err.SetErrorStringWithFormat(
+      err.SetErrorString(
           "Multiple possible REPL languages.  Please specify a language.");
       return REPLSP();
     }
   }
 
   REPLMap::iterator pos = m_repl_map.find(language);
 
   if (pos != m_repl_map.end()) {

lldb/tools/driver/Driver.cpp

if (auto *arg = args.getLastArg(OPT_repl_language)) {
     auto arg_value = arg->getValue();
     m_option_data.m_repl_lang =
         SBLanguageRuntime::GetLanguageTypeFromString(arg_value);
     if (m_option_data.m_repl_lang == eLanguageTypeUnknown) {
       error.SetErrorStringWithFormat("Unrecognized language name: \"%s\"",
                                      arg_value);
       return error;
     }
+    m_debugger.SetREPLLanguage(m_option_data.m_repl_lang);
   }
 
   if (args.hasArg(OPT_repl)) {
     m_option_data.m_repl = true;
   }
 
   if (auto *arg = args.getLastArg(OPT_repl_)) {
     m_option_data.m_repl = true;