[lldb/interpreter] Add REPL-specific init file

[mib]

Summary

This patch adds the infrastructure to have language specific REPL init
files. It's the foundation work to a following patch that will introduce
Swift REPL init file.

When lldb is launched with the --repl option, it will look for a REPL
init file in the home directory and source it. This overrides the
default ~/.lldbinit, which content might make the REPL behave
unexpectedly. If the REPL init file doesn't exists, lldb will fall back
to the default init file.

rdar://65836048

Signed-off-by: Med Ismail Bennani <[e-mail]>

[mib]

Fixed typo.

[JDevlieghere]

lldb/docs/man/lldb.rst

307–308

I wonder if we should have the description here, and refer to it from the REPL section.

lldb/include/lldb/API/SBCommandInterpreter.h

150

nit: How about is_repl as this is not really something you turn on and off?

150

I'd also give it a default argument (false).

lldb/source/API/SBDebugger.cpp

223

This can go with the default arg.

[mib]

lldb/docs/man/lldb.rst

307–308

Sounds good.

lldb/include/lldb/API/SBCommandInterpreter.h

150

Giving it a default argument caused ambiguity in some cases (mainly when generating the bindings) that's why I left it like this.

[mib]

Addressed @JDevlieghere comments.

[JDevlieghere]

lldb/source/Interpreter/CommandInterpreter.cpp

2183–2186

This is wrong, you check the REPL file first, fi that works you use that, otherwise you fall back to the app specific one, and finally to the global one.

[mib]

lldb/source/Interpreter/CommandInterpreter.cpp

2183–2186

Yes, but the application init file overrides the REPL init file that also override the global one, that's why I put it this way in the comment.

[mib]

Updated man page to reflect current implementation.

[JDevlieghere]

lldb/docs/man/lldb.rst

314

:program:lldb

323

Spurious newline

lldb/source/Interpreter/CommandInterpreter.cpp

2183–2186

Cool, now the docs and the comment are in sync. That code is really confusing though but I think I was the last to touch it so that's my bad :-)

lldb/docs/man/lldb.rst

 For instance, "apropos breakpoint" will list any command that has the word
 "breakpoint" in its help text.
 
 CONFIGURATION FILES
 -------------------
 
 :program:`lldb` reads things like settings, aliases and commands from the
 .lldbinit file.
 
-First, it will read the application specific init file whose name is
-~/.lldbinit followed by a "-" and the name of the current program. This would
-be ~/.lldbinit-lldb for the command line :program:`lldb` and ~/.lldbinit-Xcode
-for Xcode. If there is no application specific init file, the global
-~/.lldbinit is read.
+First, :program:`lldb` will try to read the application specific init file
+whose name is ~/.lldbinit followed by a "-" and the name of the current
+program. This would be ~/.lldbinit-lldb for the command line :program:`lldb`
+and ~/.lldbinit-Xcode for Xcode. If there is no application specific init
+file, :program:`lldb` will look for an init file in the home directory.
+If launched with a `REPL`_ option, it will first look for a REPL configuration
+file, specific to the REPL language. If this file doesn't exist, or `lldb`
+wasn't launch with `REPL`_, meaning there is neither a REPL init file nor an
+application specific init file, `lldb` will fallback to the global ~/.lldbinit.
 
 Secondly, it will look for an .lldbinit file in the current working directory.
 For security reasons, :program:`lldb` will print a warning and not source this
 file by default. This behavior can be changed by changing the
 target.load-cwd-lldbinit setting.
 
+
 To always load the .lldbinit file in the current working directory, add the
 following command to ~/.lldbinit:
 
   settings set target.load-cwd-lldbinit true
 
 To never load the .lldbinit file in the current working directory and silence
 the warning, add the following command to ~/.lldbinit:
 

lldb/include/lldb/API/SBCommandInterpreter.h

 //===-- SBCommandInterpreter.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_API_SBCOMMANDINTERPRETER_H
 #define LLDB_API_SBCOMMANDINTERPRETER_H
 
 #include <memory>
 
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBDefines.h"
 
 namespace lldb {
 
 class SBCommandInterpreter {
 public:
   enum {
     eBroadcastBitThreadShouldExit = (1 << 0),
public:
   /// \return
   ///     A lldb::SBCommand representing the newly created command.
   lldb::SBCommand AddCommand(const char *name,
                              lldb::SBCommandPluginInterface *impl,
                              const char *help, const char *syntax,
                              const char *auto_repeat_command);
 
   void SourceInitFileInHomeDirectory(lldb::SBCommandReturnObject &result);
+  void SourceInitFileInHomeDirectory(lldb::SBCommandReturnObject &result,
+                                     bool is_repl);
 
   void
   SourceInitFileInCurrentWorkingDirectory(lldb::SBCommandReturnObject &result);
 
   lldb::ReturnStatus HandleCommand(const char *command_line,
                                    lldb::SBCommandReturnObject &result,
                                    bool add_to_history = false);
 

lldb/include/lldb/Interpreter/CommandInterpreter.h

 //===-- CommandInterpreter.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_INTERPRETER_COMMANDINTERPRETER_H
 #define LLDB_INTERPRETER_COMMANDINTERPRETER_H
 
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/IOHandler.h"
 #include "lldb/Interpreter/CommandAlias.h"
 #include "lldb/Interpreter/CommandHistory.h"
 #include "lldb/Interpreter/CommandObject.h"
 #include "lldb/Interpreter/ScriptInterpreter.h"
 #include "lldb/Utility/Args.h"
 #include "lldb/Utility/Broadcaster.h"
 #include "lldb/Utility/CompletionRequest.h"
public:
 
   static ConstString &GetStaticBroadcasterClass();
 
   ConstString &GetBroadcasterClass() const override {
     return GetStaticBroadcasterClass();
   }
 
   void SourceInitFileCwd(CommandReturnObject &result);
-  void SourceInitFileHome(CommandReturnObject &result);
+  void SourceInitFileHome(CommandReturnObject &result, bool is_repl = false);
 
   bool AddCommand(llvm::StringRef name, const lldb::CommandObjectSP &cmd_sp,
                   bool can_replace);
 
   bool AddUserCommand(llvm::StringRef name, const lldb::CommandObjectSP &cmd_sp,
                       bool can_replace);
 
   lldb::CommandObjectSP GetCommandSPExact(llvm::StringRef cmd,

lldb/source/API/SBCommandInterpreter.cpp

 //===-- SBCommandInterpreter.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/lldb-types.h"
 
 #include "SBReproducerPrivate.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandObjectMultiword.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/Listener.h"
 
if (target_sp)
       lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex());
     m_opaque_ptr->SourceInitFileHome(result.ref());
   } else {
     result->AppendError("SBCommandInterpreter is not valid");
     result->SetStatus(eReturnStatusFailed);
   }
 }
 
+void SBCommandInterpreter::SourceInitFileInHomeDirectory(
+    SBCommandReturnObject &result, bool is_repl) {
+  LLDB_RECORD_METHOD(void, SBCommandInterpreter, SourceInitFileInHomeDirectory,
+                     (lldb::SBCommandReturnObject &, bool), result, is_repl);
+
+  result.Clear();
+  if (IsValid()) {
+    TargetSP target_sp(m_opaque_ptr->GetDebugger().GetSelectedTarget());
+    std::unique_lock<std::recursive_mutex> lock;
+    if (target_sp)
+      lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex());
+    m_opaque_ptr->SourceInitFileHome(result.ref(), is_repl);
+  } else {
+    result->AppendError("SBCommandInterpreter is not valid");
+    result->SetStatus(eReturnStatusFailed);
+  }
+}
+
 void SBCommandInterpreter::SourceInitFileInCurrentWorkingDirectory(
     SBCommandReturnObject &result) {
   LLDB_RECORD_METHOD(void, SBCommandInterpreter,
                      SourceInitFileInCurrentWorkingDirectory,
                      (lldb::SBCommandReturnObject &), result);
 
   result.Clear();
   if (IsValid()) {
template <> void RegisterMethods<SBCommandInterpreter>(Registry &R) {
   LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, HasCustomQuitExitCode, ());
   LLDB_REGISTER_METHOD(int, SBCommandInterpreter, GetQuitStatus, ());
   LLDB_REGISTER_METHOD(void, SBCommandInterpreter, ResolveCommand,
                        (const char *, lldb::SBCommandReturnObject &));
   LLDB_REGISTER_METHOD(void, SBCommandInterpreter,
                        SourceInitFileInHomeDirectory,
                        (lldb::SBCommandReturnObject &));
   LLDB_REGISTER_METHOD(void, SBCommandInterpreter,
+                       SourceInitFileInHomeDirectory,
+                       (lldb::SBCommandReturnObject &, bool));
+  LLDB_REGISTER_METHOD(void, SBCommandInterpreter,
                        SourceInitFileInCurrentWorkingDirectory,
                        (lldb::SBCommandReturnObject &));
   LLDB_REGISTER_METHOD(lldb::SBBroadcaster, SBCommandInterpreter,
                        GetBroadcaster, ());
   LLDB_REGISTER_STATIC_METHOD(const char *, SBCommandInterpreter,
                               GetBroadcasterClass, ());
   LLDB_REGISTER_STATIC_METHOD(const char *, SBCommandInterpreter,
                               GetArgumentTypeAsCString,

lldb/source/API/SBDebugger.cpp

SBDebugger SBDebugger::Create(bool source_init_files,
 
   debugger.reset(Debugger::CreateInstance(callback, baton));
 
   SBCommandInterpreter interp = debugger.GetCommandInterpreter();
   if (source_init_files) {
     interp.get()->SkipLLDBInitFiles(false);
     interp.get()->SkipAppInitFiles(false);
     SBCommandReturnObject result;
-    interp.SourceInitFileInHomeDirectory(result);
+    interp.SourceInitFileInHomeDirectory(result, false);
   } else {
     interp.get()->SkipLLDBInitFiles(true);
     interp.get()->SkipAppInitFiles(true);
   }
   return debugger;
 }
 
 void SBDebugger::Destroy(SBDebugger &debugger) {

lldb/source/Interpreter/CommandInterpreter.cpp

static void GetHomeInitFile(llvm::SmallVectorImpl<char> &init_file,
   }
 
   llvm::sys::path::home_directory(init_file);
   llvm::sys::path::append(init_file, init_file_name);
 
   FileSystem::Instance().Resolve(init_file);
 }
 
+static void GetHomeREPLInitFile(llvm::SmallVectorImpl<char> &init_file,
+                                LanguageType language) {
+  std::string init_file_name;
+
+  switch (language) {
+  // TODO: Add support for a language used with a REPL.
+  default:
+    return;
+  }
+
+  llvm::sys::path::home_directory(init_file);
+  llvm::sys::path::append(init_file, init_file_name);
+
+  FileSystem::Instance().Resolve(init_file);
+}
+
 static void GetCwdInitFile(llvm::SmallVectorImpl<char> &init_file) {
   llvm::StringRef s = ".lldbinit";
   init_file.assign(s.begin(), s.end());
   FileSystem::Instance().Resolve(init_file);
 }
 
 static LoadCWDlldbinitFile ShouldLoadCwdInitFile() {
   lldb::TargetPropertiesSP properties = Target::GetGlobalProperties();
if (llvm::sys::path::parent_path(init_file) ==
       result.SetStatus(eReturnStatusFailed);
     }
   }
   }
 }
 
 /// We will first see if there is an application specific ".lldbinit" file
 /// whose name is "~/.lldbinit" followed by a "-" and the name of the program.
-/// If this file doesn't exist, we fall back to just the "~/.lldbinit" file.
-void CommandInterpreter::SourceInitFileHome(CommandReturnObject &result) {
+/// If this file doesn't exist, we fall back to the REPL init file or the
+/// default home init file in "~/.lldbinit".
+void CommandInterpreter::SourceInitFileHome(CommandReturnObject &result,
+                                            bool is_repl) {
   if (m_skip_lldbinit_files) {
     result.SetStatus(eReturnStatusSuccessFinishNoResult);
     return;
   }
 
   llvm::SmallString<128> init_file;
+
+  if (is_repl) {
+    LanguageType language = {};
+    TargetSP target_sp = GetDebugger().GetSelectedTarget();
+    if (target_sp)
+      language = target_sp->GetLanguage();
+    GetHomeREPLInitFile(init_file, language);
+  }
+
+  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;
     GetHomeInitFile(program_init_file, program_name);
     if (FileSystem::Instance().Exists(program_init_file))
       init_file = program_init_file;

lldb/tools/driver/Driver.cpp

if (window_size.ws_col > 0)
       m_debugger.SetTerminalWidth(window_size.ws_col);
   }
 
   SBCommandInterpreter sb_interpreter = m_debugger.GetCommandInterpreter();
 
   // Before we handle any options from the command line, we parse the
   // .lldbinit file in the user's home directory.
   SBCommandReturnObject result;
-  sb_interpreter.SourceInitFileInHomeDirectory(result);
+  sb_interpreter.SourceInitFileInHomeDirectory(result, m_option_data.m_repl);
   if (m_option_data.m_debug_mode) {
     result.PutError(m_debugger.GetErrorFile());
     result.PutOutput(m_debugger.GetOutputFile());
   }
 
   // Source the local .lldbinit file if it exists and we're allowed to source.
   // Here we want to always print the return object because it contains the
   // warning and instructions to load local lldbinit files.