[lldb][NFCI] Change return type of REPL::GetSourceFileBasename

[bulbazord]

Summary

These don't really need to be in the ConstString StringPool. I've
changed the return type to StringRef because on llvm.org and downstream
in the swift fork, this returns a constant value. We could change it to
return a std::string or something else if it needs to be able to change
between calls.

[wallace]

LGTM. It also works with the mojo REPL.

lldb/include/lldb/Expression/REPL.h

protected:
   }
 
   static int CalculateActualIndentation(const StringList &lines);
 
   // Subclasses should override these functions to implement a functional REPL.
 
   virtual Status DoInitialization() = 0;
 
-  virtual ConstString GetSourceFileBasename() = 0;
+  virtual llvm::StringRef GetSourceFileBasename() = 0;
 
   virtual const char *GetAutoIndentCharacters() = 0;
 
   virtual bool SourceIsComplete(const std::string &source) = 0;
 
   virtual lldb::offset_t GetDesiredIndentation(
       const StringList &lines, int cursor_position,
       int tab_size) = 0; // LLDB_INVALID_OFFSET means no change

lldb/source/Expression/REPL.cpp

if (ret) {
       break;
     }
   }
 
   return ret;
 }
 
 std::string REPL::GetSourcePath() {
-  ConstString file_basename = GetSourceFileBasename();
+  llvm::StringRef file_basename = GetSourceFileBasename();
   FileSpec tmpdir_file_spec = HostInfo::GetProcessTempDir();
   if (tmpdir_file_spec) {
     tmpdir_file_spec.SetFilename(file_basename);
     m_repl_source_path = tmpdir_file_spec.GetPath();
   } else {
     tmpdir_file_spec = FileSpec("/tmp");
-    tmpdir_file_spec.AppendPathComponent(file_basename.GetStringRef());
+    tmpdir_file_spec.AppendPathComponent(file_basename);
   }
 
   return tmpdir_file_spec.GetPath();
 }
 
 lldb::IOHandlerSP REPL::GetIOHandler() {
   if (!m_io_handler_sp) {
     Debugger &debugger = m_target.GetDebugger();

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

static lldb::REPLSP CreateInstance(Status &error, lldb::LanguageType language,
                                      Debugger *debugger, Target *target,
                                      const char *repl_options);
 
   static llvm::StringRef GetPluginNameStatic() { return "ClangREPL"; }
 
 protected:
   Status DoInitialization() override;
 
-  ConstString GetSourceFileBasename() override;
+  llvm::StringRef GetSourceFileBasename() override;
 
   const char *GetAutoIndentCharacters() override;
 
   bool SourceIsComplete(const std::string &source) override;
 
   lldb::offset_t GetDesiredIndentation(const StringList &lines,
                                        int cursor_position,
                                        int tab_size) override;

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

lldb::REPLSP ClangREPL::CreateInstance(Status &error,
   lldb::REPLSP result = std::make_shared<ClangREPL>(language, *target);
   target->SetREPL(language, result);
   error = Status();
   return result;
 }
 
 Status ClangREPL::DoInitialization() { return Status(); }
 
-ConstString ClangREPL::GetSourceFileBasename() {
-  return ConstString("repl.c");
+llvm::StringRef ClangREPL::GetSourceFileBasename() {
+  static constexpr llvm::StringLiteral g_repl("repl.c");
+  return g_repl;
 }
 
 const char *ClangREPL::GetAutoIndentCharacters() { return "  "; }
 
 bool ClangREPL::SourceIsComplete(const std::string &source) {
   // FIXME: There isn't a good way to know if the input source is complete or
   // not, so just say that every single REPL line is ready to be parsed.
   return !source.empty();