Fix -Wunused-result warnings in LLDB

[rnk]

Summary

Three uses of try_lock intentionally ignore the result. Make that
explicit with a void cast.

Add what appears to be a missing return in the clang expression parser
code. It's a functional change, but presumably the right one.

[amccarth]

LGTM.

It's too bad that pattern is repeated three times, including the explanatory comment.

[jingham]

There's a PP above each instance of this code explaining why it's okay if we don't get the API lock, since that's a bit of a tricky point. So if you want to add a comment, it would be better to say "see explanation above".

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.h

private:
   class ParserVars {
   public:
     ParserVars() {}
 
     Target *GetTarget() {
       if (m_exe_ctx.GetTargetPtr())
         return m_exe_ctx.GetTargetPtr();
       else if (m_sym_ctx.target_sp)
-        m_sym_ctx.target_sp.get();
+        return m_sym_ctx.target_sp.get();
       return nullptr;
     }
 
     ExecutionContext m_exe_ctx; ///< The execution context to use when parsing.
     SymbolContext m_sym_ctx; ///< The symbol context to use in finding variables
                              ///and types.
     ClangPersistentVariables *m_persistent_vars =
         nullptr; ///< The persistent variables for the process.

lldb/source/Plugins/OperatingSystem/Python/OperatingSystemPython.cpp

bool OperatingSystemPython::UpdateThreadList(ThreadList &old_thread_list,
   // If someone already has the API lock, that is ok, we just want to avoid
   // external code from making new API calls while this call is happening.
   //
   // This is a recursive lock so we can grant it to any Python code called on
   // the stack below us.
   Target &target = m_process->GetTarget();
   std::unique_lock<std::recursive_mutex> api_lock(target.GetAPIMutex(),
                                                   std::defer_lock);
-  api_lock.try_lock();
+  (void)api_lock.try_lock(); // See above.
   auto interpreter_lock = m_interpreter->AcquireInterpreterLock();
 
   LLDB_LOGF(log,
             "OperatingSystemPython::UpdateThreadList() fetching thread "
             "data from python for pid %" PRIu64,
             m_process->GetID());
 
   // The threads that are in "core_thread_list" upon entry are the threads from
OperatingSystemPython::CreateRegisterContextForThread(Thread *thread,
   // If someone already has the API lock, that is ok, we just want to avoid
   // external code from making new API calls while this call is happening.
   //
   // This is a recursive lock so we can grant it to any Python code called on
   // the stack below us.
   Target &target = m_process->GetTarget();
   std::unique_lock<std::recursive_mutex> api_lock(target.GetAPIMutex(),
                                                   std::defer_lock);
-  api_lock.try_lock();
+  (void)api_lock.try_lock(); // See above.
   auto interpreter_lock = m_interpreter->AcquireInterpreterLock();
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_THREAD));
 
   if (reg_data_addr != LLDB_INVALID_ADDRESS) {
     // The registers data is in contiguous memory, just create the register
     // context using the address provided
     LLDB_LOGF(log,
if (m_interpreter && m_python_object_sp) {
     // If someone already has the API lock, that is ok, we just want to avoid
     // external code from making new API calls while this call is happening.
     //
     // This is a recursive lock so we can grant it to any Python code called on
     // the stack below us.
     Target &target = m_process->GetTarget();
     std::unique_lock<std::recursive_mutex> api_lock(target.GetAPIMutex(),
                                                     std::defer_lock);
-    api_lock.try_lock();
+    (void)api_lock.try_lock(); // See above.
     auto interpreter_lock = m_interpreter->AcquireInterpreterLock();
 
     StructuredData::DictionarySP thread_info_dict =
         m_interpreter->OSPlugin_CreateThread(m_python_object_sp, tid, context);
     std::vector<bool> core_used_map;
     if (thread_info_dict) {
       ThreadList core_threads(m_process);
       ThreadList &thread_list = m_process->GetThreadList();