[lldb] Rename SetResultIsInternal to SetSuppressPersistentResult (NFC)

[kastiglione]

Summary

Rename SetResultIsInternal and GetResultIsInternal to SetSuppressPersistentResult
and GetSuppressPersistentResult respectively. Also rename m_result_is_internal.

This matches the naming in the SB API.

A separate change calls SetSuppressPersistentResult, where the name
SetResultIsInternal doesn't quite fit.

lldb/include/lldb/Target/Target.h

#endif
   }
 
   const char *GetPoundLineFilePath() const {
     return (m_pound_line_file.empty() ? nullptr : m_pound_line_file.c_str());
   }
 
   uint32_t GetPoundLineLine() const { return m_pound_line_line; }
 
-  void SetResultIsInternal(bool b) { m_result_is_internal = b; }
+  void SetSuppressPersistentResult(bool b) { m_suppress_persistent_result = b; }
 
-  bool GetResultIsInternal() const { return m_result_is_internal; }
+  bool GetSuppressPersistentResult() const {
+    return m_suppress_persistent_result;
+  }
 
   void SetAutoApplyFixIts(bool b) { m_auto_apply_fixits = b; }
 
   bool GetAutoApplyFixIts() const { return m_auto_apply_fixits; }
 
   void SetRetriesWithFixIts(uint64_t number_of_retries) {
     m_retries_with_fixits = number_of_retries;
   }
private:
   bool m_keep_in_memory = false;
   bool m_try_others = true;
   bool m_stop_others = true;
   bool m_debug = false;
   bool m_trap_exceptions = true;
   bool m_repl = false;
   bool m_generate_debug_info = false;
   bool m_ansi_color_errors = false;
-  bool m_result_is_internal = false;
+  bool m_suppress_persistent_result = false;
   bool m_auto_apply_fixits = true;
   uint64_t m_retries_with_fixits = 1;
   /// True if the executed code should be treated as utility code that is only
   /// used by LLDB internally.
   bool m_running_utility_expression = false;
 
   lldb::DynamicValueType m_use_dynamic = lldb::eNoDynamicValues;
   Timeout<std::micro> m_timeout = default_timeout;

lldb/source/API/SBExpressionOptions.cpp

void SBExpressionOptions::SetGenerateDebugInfo(bool b) {
   LLDB_INSTRUMENT_VA(this, b);
 
   return m_opaque_up->SetGenerateDebugInfo(b);
 }
 
 bool SBExpressionOptions::GetSuppressPersistentResult() {
   LLDB_INSTRUMENT_VA(this);
 
-  return m_opaque_up->GetResultIsInternal();
+  return m_opaque_up->GetSuppressPersistentResult();
 }
 
 void SBExpressionOptions::SetSuppressPersistentResult(bool b) {
   LLDB_INSTRUMENT_VA(this, b);
 
-  return m_opaque_up->SetResultIsInternal(b);
+  return m_opaque_up->SetSuppressPersistentResult(b);
 }
 
 const char *SBExpressionOptions::GetPrefix() const {
   LLDB_INSTRUMENT_VA(this);
 
   return m_opaque_up->GetPrefix();
 }
 

lldb/source/Breakpoint/BreakpointLocation.cpp

bool BreakpointLocation::ConditionSaysStop(ExecutionContext &exe_ctx,
   // we'll hook the constructor errors up to the debugger's Async I/O.
 
   ValueObjectSP result_value_sp;
 
   EvaluateExpressionOptions options;
   options.SetUnwindOnError(true);
   options.SetIgnoreBreakpoints(true);
   options.SetTryAllThreads(true);
-  options.SetResultIsInternal(
+  options.SetSuppressPersistentResult(
       true); // Don't generate a user variable for condition expressions.
 
   Status expr_error;
 
   diagnostics.Clear();
 
   ExpressionVariableSP result_variable_sp;
 

lldb/source/Expression/UserExpression.cpp

 UserExpression::Execute(DiagnosticManager &diagnostic_manager,
                         ExecutionContext &exe_ctx,
                         const EvaluateExpressionOptions &options,
                         lldb::UserExpressionSP &shared_ptr_to_me,
                         lldb::ExpressionVariableSP &result_var) {
   lldb::ExpressionResults expr_result = DoExecute(
       diagnostic_manager, exe_ctx, options, shared_ptr_to_me, result_var);
   Target *target = exe_ctx.GetTargetPtr();
-  if (options.GetResultIsInternal() && result_var && target) {
+  if (options.GetSuppressPersistentResult() && result_var && target) {
     if (auto *persistent_state =
             target->GetPersistentExpressionStateForLanguage(m_language))
       persistent_state->RemovePersistentVariable(result_var);
   }
   return expr_result;
 }