[lldb][NFCI] Methods to load scripting resources should take a Stream by reference

[bulbazord]

Summary

These methods all take a Stream * to get feedback about what's going
on. By default, it's a nullptr, but we always feed it with a valid
pointer. It would therefore make more sense to have this take a
reference.

lldb/include/lldb/Core/Module.h

public:
   /// \param[in] target
   ///    The target to check whether this is loaded in.
   ///
   /// \return
   ///     \b true if it is, \b false otherwise.
   bool IsLoadedInTarget(Target *target);
 
   bool LoadScriptingResourceInTarget(Target *target, Status &error,
-                                     Stream *feedback_stream = nullptr);
+                                     Stream &feedback_stream);
 
   /// Get the number of compile units for this module.
   ///
   /// \return
   ///     The number of compile units that the symbol vendor plug-in
   ///     finds.
   size_t GetNumCompileUnits();
 

lldb/include/lldb/Core/ModuleList.h

public:
   /// Gets the size of the module list.
   ///
   /// \return
   ///     The number of modules in the module list.
   size_t GetSize() const;
   bool IsEmpty() const { return !GetSize(); }
 
   bool LoadScriptingResourcesInTarget(Target *target, std::list<Status> &errors,
-                                      Stream *feedback_stream = nullptr,
+                                      Stream &feedback_stream,
                                       bool continue_on_error = true);
 
   static ModuleListProperties &GetGlobalModuleListProperties();
 
   static bool ModuleIsInCache(const Module *module_ptr);
 
   static Status
   GetSharedModule(const ModuleSpec &module_spec, lldb::ModuleSP &module_sp,

lldb/include/lldb/Target/Platform.h

virtual Status GetFileWithUUID(const FileSpec &platform_file,
                                  const UUID *uuid_ptr, FileSpec &local_file);
 
   // Locate the scripting resource given a module specification.
   //
   // Locating the file should happen only on the local computer or using the
   // current computers global settings.
   virtual FileSpecList
   LocateExecutableScriptingResources(Target *target, Module &module,
-                                     Stream *feedback_stream);
+                                     Stream &feedback_stream);
 
   virtual Status GetSharedModule(
       const ModuleSpec &module_spec, Process *process,
       lldb::ModuleSP &module_sp, const FileSpecList *module_search_paths_ptr,
       llvm::SmallVectorImpl<lldb::ModuleSP> *old_modules, bool *did_create_ptr);
 
   virtual bool GetModuleSpec(const FileSpec &module_file_spec,
                              const ArchSpec &arch, ModuleSpec &module_spec);

lldb/include/lldb/Target/Target.h

public:
   ///
   /// \see ObjectFile::GetDependentModules (FileSpecList&)
   /// \see Process::GetImages()
   void SetExecutableModule(
       lldb::ModuleSP &module_sp,
       LoadDependentFiles load_dependent_files = eLoadDependentsDefault);
 
   bool LoadScriptingResources(std::list<Status> &errors,
-                              Stream *feedback_stream = nullptr,
+                              Stream &feedback_stream,
                               bool continue_on_error = true) {
     return m_images.LoadScriptingResourcesInTarget(
         this, errors, feedback_stream, continue_on_error);
   }
 
   /// Get accessor for the images for this process.
   ///
   /// Each process has a notion of a main executable that is the file

lldb/source/Commands/CommandObjectTarget.cpp

if (matching_modules.GetSize() == 1) {
           module_list.Append(module_sp);
           target->SymbolsDidLoad(module_list);
 
           // Make sure we load any scripting resources that may be embedded
           // in the debug info files in case the platform supports that.
           Status error;
           StreamString feedback_stream;
           module_sp->LoadScriptingResourceInTarget(target, error,
-                                                   &feedback_stream);
+                                                   feedback_stream);
           if (error.Fail() && error.AsCString())
             result.AppendWarningWithFormat(
                 "unable to load scripting data for module %s - error "
                 "reported was %s",
                 module_sp->GetFileSpec()
                     .GetFileNameStrippingExtension()
                     .GetCString(),
                 error.AsCString());

lldb/source/Core/Debugger.cpp

if (property_path == g_debugger_properties[ePropertyPrompt].name) {
         m_source_file_cache.Clear();
       }
     } else if (is_load_script && target_sp &&
                load_script_old_value == eLoadScriptFromSymFileWarn) {
       if (target_sp->TargetProperties::GetLoadScriptFromSymbolFile() ==
           eLoadScriptFromSymFileTrue) {
         std::list<Status> errors;
         StreamString feedback_stream;
-        if (!target_sp->LoadScriptingResources(errors, &feedback_stream)) {
+        if (!target_sp->LoadScriptingResources(errors, feedback_stream)) {
           Stream &s = GetErrorStream();
           for (auto error : errors) {
             s.Printf("%s\n", error.AsCString());
           }
           if (feedback_stream.GetSize())
             s.PutCString(feedback_stream.GetString());
         }
       }

lldb/source/Core/Module.cpp

if (sections != nullptr) {
         }
       }
     }
   }
   return false;
 }
 
 bool Module::LoadScriptingResourceInTarget(Target *target, Status &error,
-                                           Stream *feedback_stream) {
+                                           Stream &feedback_stream) {
   if (!target) {
     error.SetErrorString("invalid destination Target");
     return false;
   }
 
   LoadScriptFromSymFile should_load =
       target->TargetProperties::GetLoadScriptFromSymbolFile();
 
if (script_language != eScriptLanguageNone) {
     if (num_specs) {
       ScriptInterpreter *script_interpreter = debugger.GetScriptInterpreter();
       if (script_interpreter) {
         for (uint32_t i = 0; i < num_specs; ++i) {
           FileSpec scripting_fspec(file_specs.GetFileSpecAtIndex(i));
           if (scripting_fspec &&
               FileSystem::Instance().Exists(scripting_fspec)) {
             if (should_load == eLoadScriptFromSymFileWarn) {
-              if (feedback_stream)
-                feedback_stream->Printf(
-                    "warning: '%s' contains a debug script. To run this script "
-                    "in "
-                    "this debug session:\n\n    command script import "
-                    "\"%s\"\n\n"
-                    "To run all discovered debug scripts in this session:\n\n"
-                    "    settings set target.load-script-from-symbol-file "
-                    "true\n",
-                    GetFileSpec().GetFileNameStrippingExtension().GetCString(),
-                    scripting_fspec.GetPath().c_str());
+              feedback_stream.Printf(
               return false;
             }
             StreamString scripting_stream;
             scripting_fspec.Dump(scripting_stream.AsRawOstream());
             LoadScriptOptions options;
             bool did_load = script_interpreter->LoadScriptingModule(
                 scripting_stream.GetData(), options, error);
             if (!did_load)

lldb/source/Core/ModuleList.cpp

 }
 
 bool ModuleList::RemoveSharedModuleIfOrphaned(const Module *module_ptr) {
   return GetSharedModuleList().RemoveIfOrphaned(module_ptr);
 }
 
 bool ModuleList::LoadScriptingResourcesInTarget(Target *target,
                                                 std::list<Status> &errors,
-                                                Stream *feedback_stream,
+                                                Stream &feedback_stream,
                                                 bool continue_on_error) {
   if (!target)
     return false;
   std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
   for (auto module : m_modules) {
     Status error;
     if (module) {
       if (!module->LoadScriptingResourceInTarget(target, error,

lldb/source/Plugins/Platform/MacOSX/PlatformDarwin.h

Status PutFile(const FileSpec &source, const FileSpec &destination,
                  uint32_t uid = UINT32_MAX, uint32_t gid = UINT32_MAX) override;
 
   // Platform functions
   Status ResolveSymbolFile(Target &target, const ModuleSpec &sym_spec,
                            FileSpec &sym_file) override;
 
   FileSpecList
   LocateExecutableScriptingResources(Target *target, Module &module,
-                                     Stream *feedback_stream) override;
+                                     Stream &feedback_stream) override;
 
   Status GetSharedModule(const ModuleSpec &module_spec, Process *process,
                          lldb::ModuleSP &module_sp,
                          const FileSpecList *module_search_paths_ptr,
                          llvm::SmallVectorImpl<lldb::ModuleSP> *old_modules,
                          bool *did_create_ptr) override;
 
   size_t GetSoftwareBreakpointTrapOpcode(Target &target,

lldb/source/Plugins/Platform/MacOSX/PlatformDarwin.cpp

PlatformDarwin::PutFile(const lldb_private::FileSpec &source,
   // Unconditionally unlink the destination. If it is an executable,
   // simply opening it and truncating its contents would invalidate
   // its cached code signature.
   Unlink(destination);
   return PlatformPOSIX::PutFile(source, destination, uid, gid);
 }
 
 FileSpecList PlatformDarwin::LocateExecutableScriptingResources(
-    Target *target, Module &module, Stream *feedback_stream) {
+    Target *target, Module &module, Stream &feedback_stream) {
   FileSpecList file_list;
   if (target &&
       target->GetDebugger().GetScriptLanguage() == eScriptLanguagePython) {
     // NB some extensions might be meaningful and should not be stripped -
     // "this.binary.file"
     // should not lose ".file" but GetFileNameStrippingExtension() will do
     // precisely that. Ideally, we should have a per-platform list of
     // extensions (".exe", ".app", ".dSYM", ".framework") which should be
if (module_spec) {
               FileSpec script_fspec(path_string.GetString());
               FileSystem::Instance().Resolve(script_fspec);
               FileSpec orig_script_fspec(original_path_string.GetString());
               FileSystem::Instance().Resolve(orig_script_fspec);
 
               // if we did some replacements of reserved characters, and a
               // file with the untampered name exists, then warn the user
               // that the file as-is shall not be loaded
-              if (feedback_stream) {
-                if (module_basename != original_module_basename &&
-                    FileSystem::Instance().Exists(orig_script_fspec)) {
-                  const char *reason_for_complaint =
-                      was_keyword ? "conflicts with a keyword"
-                                  : "contains reserved characters";
-                  if (FileSystem::Instance().Exists(script_fspec))
-                    feedback_stream->Printf(
-                        "warning: the symbol file '%s' contains a debug "
-                        "script. However, its name"
-                        " '%s' %s and as such cannot be loaded. LLDB will"
-                        " load '%s' instead. Consider removing the file with "
-                        "the malformed name to"
-                        " eliminate this warning.\n",
-                        symfile_spec.GetPath().c_str(),
-                        original_path_string.GetData(), reason_for_complaint,
-                        path_string.GetData());
-                  else
-                    feedback_stream->Printf(
-                        "warning: the symbol file '%s' contains a debug "
-                        "script. However, its name"
-                        " %s and as such cannot be loaded. If you intend"
-                        " to have this script loaded, please rename '%s' to "
-                        "'%s' and retry.\n",
-                        symfile_spec.GetPath().c_str(), reason_for_complaint,
-                        original_path_string.GetData(), path_string.GetData());
-                }
-              }
+                  feedback_stream.Printf(
+                  feedback_stream.Printf(
 
               if (FileSystem::Instance().Exists(script_fspec)) {
                 file_list.Append(script_fspec);
                 break;
               }
 
               // If we didn't find the python file, then keep stripping the
               // extensions and try again

lldb/source/Target/Platform.cpp

Status Platform::GetFileWithUUID(const FileSpec &platform_file,
                                  const UUID *uuid_ptr, FileSpec &local_file) {
   // Default to the local case
   local_file = platform_file;
   return Status();
 }
 
 FileSpecList
 Platform::LocateExecutableScriptingResources(Target *target, Module &module,
-                                             Stream *feedback_stream) {
+                                             Stream &feedback_stream) {
   return FileSpecList();
 }
 
 // PlatformSP
 // Platform::FindPlugin (Process *process, ConstString plugin_name)
 //{
 //    PlatformCreateInstance create_callback = nullptr;
 //    if (plugin_name)

lldb/source/Target/Target.cpp

 Module *Target::GetExecutableModulePointer() {
   return GetExecutableModule().get();
 }
 
 static void LoadScriptingResourceForModule(const ModuleSP &module_sp,
                                            Target *target) {
   Status error;
   StreamString feedback_stream;
-  if (module_sp && !module_sp->LoadScriptingResourceInTarget(
-                       target, error, &feedback_stream)) {
+  if (module_sp && !module_sp->LoadScriptingResourceInTarget(target, error,
+                                                             feedback_stream)) {
     if (error.AsCString())
       target->GetDebugger().GetErrorStream().Printf(
           "unable to load scripting data for module %s - error reported was "
           "%s\n",
           module_sp->GetFileSpec().GetFileNameStrippingExtension().GetCString(),
           error.AsCString());
   }
   if (feedback_stream.GetSize())