[lldb][Module] Document ModuleList::ForEach and assert nullness

[Michael137]

Summary

Currently all callsites already assume the pointer is non-null.
This patch just asserts this assumption.

This is practically enforced by ModuleList::Append
which won't add nullptrs to m_modules.

[aprantl]

If we assert non-null, why still pass a shared pointer? Could we have the lambda take a Module &?

[Michael137]

In D139082#3965316, @aprantl wrote:

If we assert non-null, why still pass a shared pointer? Could we have the lambda take a Module &?

I took a stab at changing it to pass a reference but turns out there's several places where we end up storing the shared_ptr. If we changed this to a reference we'd have to call shared_from_this for those cases. Which is a bit iffy considering calling it on references that are not shared_ptr owned would throw (which can't happen currently but seems similarly awkward to the current API).

lldb/include/lldb/Core/ModuleList.h

static void FindSharedModules(const ModuleSpec &module_spec,
                                 ModuleList &matching_module_list);
 
   static lldb::ModuleSP FindSharedModule(const UUID &uuid);
 
   static size_t RemoveOrphanSharedModules(bool mandatory);
 
   static bool RemoveSharedModuleIfOrphaned(const Module *module_ptr);
 
+  /// Applies 'callback' to each module in this ModuleList.
+  /// If 'callback' returns false, iteration terminates.
+  /// The 'module_sp' passed to 'callback' is guaranteed to
+  /// be non-null.
+  ///
+  /// This function is thread-safe.
   void ForEach(std::function<bool(const lldb::ModuleSP &module_sp)> const
                    &callback) const;
 
 protected:
   // Class typedefs.
   typedef std::vector<lldb::ModuleSP>
       collection; ///< The module collection type.
 

lldb/source/Core/ModuleList.cpp

for (auto module : m_modules) {
     }
   }
   return errors.empty();
 }
 
 void ModuleList::ForEach(
     std::function<bool(const ModuleSP &module_sp)> const &callback) const {
   std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
-  for (const auto &module : m_modules) {
+  for (const auto &module_sp : m_modules) {
+    assert(module_sp != nullptr);
     // If the callback returns false, then stop iterating and break out
-    if (!callback(module))
+    if (!callback(module_sp))
       break;
   }
 }