*** This commit represents a complete reformatting of the LLDB source code

*** to conform to clang-format’s LLVM style.  This kind of mass change has
*** two obvious implications:

Firstly, merging this particular commit into a downstream fork may be a huge
effort.  Alternatively, it may be worth merging all changes up to this commit,
performing the same reformatting operation locally, and then discarding the
merge for this particular commit.  The commands used to accomplish this
reformatting were as follows (with current working directory as the root of
the repository):

    find . \( -iname "*.c" -or -iname "*.cpp" -or -iname "*.h" -or -iname "*.mm" \) -exec clang-format -i {} +
    find . -iname "*.py" -exec autopep8 --in-place --aggressive --aggressive {} + ;

The version of clang-format used was 3.9.0, and autopep8 was 1.2.4.

Secondly, “blame” style tools will generally point to this commit instead of
a meaningful prior commit.  There are alternatives available that will attempt
to look through this change and find the appropriate prior commit.  YMMV.

llvm-svn: 280751

1 files changed, 269 insertions, 386 deletions

diff --git a/lldb/source/Breakpoint/Watchpoint.cpp b/lldb/source/Breakpoint/Watchpoint.cpp
index 00a328e..15fcff6 100644
--- a/lldb/source/Breakpoint/Watchpoint.cpp
+++ b/lldb/source/Breakpoint/Watchpoint.cpp
@@ -18,487 +18,370 @@
 #include "lldb/Core/Value.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectMemory.h"
+#include "lldb/Expression/UserExpression.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/ThreadSpec.h"
-#include "lldb/Expression/UserExpression.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
-Watchpoint::Watchpoint (Target& target, lldb::addr_t addr, uint32_t size, const CompilerType *type, bool hardware) :
-    StoppointLocation (0, addr, size, hardware),
-    m_target(target),
-    m_enabled(false),
-    m_is_hardware(hardware),
-    m_is_watch_variable(false),
-    m_is_ephemeral(false),
-    m_disabled_count(0),
-    m_watch_read(0),
-    m_watch_write(0),
-    m_watch_was_read(0),
-    m_watch_was_written(0),
-    m_ignore_count(0),
-    m_false_alarms(0),
-    m_decl_str(),
-    m_watch_spec_str(),
-    m_type(),
-    m_error(),
-    m_options (),
-    m_being_created(true)
-{
-    if (type && type->IsValid())
-        m_type = *type;
-    else
-    {
-        // If we don't have a known type, then we force it to unsigned int of the right size.
-        ClangASTContext *ast_context = target.GetScratchClangASTContext();
-        m_type = ast_context->GetBuiltinTypeForEncodingAndBitSize(eEncodingUint, 8 * size);
-    }
-    
-    // Set the initial value of the watched variable:
-    if (m_target.GetProcessSP())
-    {
-        ExecutionContext exe_ctx;
-        m_target.GetProcessSP()->CalculateExecutionContext(exe_ctx);
-        CaptureWatchedValue (exe_ctx);
-    }
-    m_being_created = false;
+Watchpoint::Watchpoint(Target &target, lldb::addr_t addr, uint32_t size,
+                       const CompilerType *type, bool hardware)
+    : StoppointLocation(0, addr, size, hardware), m_target(target),
+      m_enabled(false), m_is_hardware(hardware), m_is_watch_variable(false),
+      m_is_ephemeral(false), m_disabled_count(0), m_watch_read(0),
+      m_watch_write(0), m_watch_was_read(0), m_watch_was_written(0),
+      m_ignore_count(0), m_false_alarms(0), m_decl_str(), m_watch_spec_str(),
+      m_type(), m_error(), m_options(), m_being_created(true) {
+  if (type && type->IsValid())
+    m_type = *type;
+  else {
+    // If we don't have a known type, then we force it to unsigned int of the
+    // right size.
+    ClangASTContext *ast_context = target.GetScratchClangASTContext();
+    m_type = ast_context->GetBuiltinTypeForEncodingAndBitSize(eEncodingUint,
+                                                              8 * size);
+  }
+
+  // Set the initial value of the watched variable:
+  if (m_target.GetProcessSP()) {
+    ExecutionContext exe_ctx;
+    m_target.GetProcessSP()->CalculateExecutionContext(exe_ctx);
+    CaptureWatchedValue(exe_ctx);
+  }
+  m_being_created = false;
 }
 
 Watchpoint::~Watchpoint() = default;
 
 // This function is used when "baton" doesn't need to be freed
-void
-Watchpoint::SetCallback (WatchpointHitCallback callback, void *baton, bool is_synchronous)
-{
-    // The default "Baton" class will keep a copy of "baton" and won't free
-    // or delete it when it goes goes out of scope.
-    m_options.SetCallback(callback, BatonSP (new Baton(baton)), is_synchronous);
-    
-    SendWatchpointChangedEvent (eWatchpointEventTypeCommandChanged);
+void Watchpoint::SetCallback(WatchpointHitCallback callback, void *baton,
+                             bool is_synchronous) {
+  // The default "Baton" class will keep a copy of "baton" and won't free
+  // or delete it when it goes goes out of scope.
+  m_options.SetCallback(callback, BatonSP(new Baton(baton)), is_synchronous);
+
+  SendWatchpointChangedEvent(eWatchpointEventTypeCommandChanged);
 }
 
-// This function is used when a baton needs to be freed and therefore is 
+// This function is used when a baton needs to be freed and therefore is
 // contained in a "Baton" subclass.
-void
-Watchpoint::SetCallback (WatchpointHitCallback callback, const BatonSP &callback_baton_sp, bool is_synchronous)
-{
-    m_options.SetCallback(callback, callback_baton_sp, is_synchronous);
-    SendWatchpointChangedEvent (eWatchpointEventTypeCommandChanged);
+void Watchpoint::SetCallback(WatchpointHitCallback callback,
+                             const BatonSP &callback_baton_sp,
+                             bool is_synchronous) {
+  m_options.SetCallback(callback, callback_baton_sp, is_synchronous);
+  SendWatchpointChangedEvent(eWatchpointEventTypeCommandChanged);
 }
 
-void
-Watchpoint::ClearCallback ()
-{
-    m_options.ClearCallback ();
-    SendWatchpointChangedEvent (eWatchpointEventTypeCommandChanged);
+void Watchpoint::ClearCallback() {
+  m_options.ClearCallback();
+  SendWatchpointChangedEvent(eWatchpointEventTypeCommandChanged);
 }
 
-void
-Watchpoint::SetDeclInfo (const std::string &str)
-{
-    m_decl_str = str;
-}
+void Watchpoint::SetDeclInfo(const std::string &str) { m_decl_str = str; }
 
-std::string
-Watchpoint::GetWatchSpec()
-{
-    return m_watch_spec_str;
-}
+std::string Watchpoint::GetWatchSpec() { return m_watch_spec_str; }
 
-void
-Watchpoint::SetWatchSpec (const std::string &str)
-{
-    m_watch_spec_str = str;
+void Watchpoint::SetWatchSpec(const std::string &str) {
+  m_watch_spec_str = str;
 }
 
 // Override default impl of StoppointLocation::IsHardware() since m_is_hardware
 // member field is more accurate.
-bool
-Watchpoint::IsHardware () const
-{
-    return m_is_hardware;
-}
-
-bool
-Watchpoint::IsWatchVariable() const
-{
-    return m_is_watch_variable;
-}
-
-void
-Watchpoint::SetWatchVariable(bool val)
-{
-    m_is_watch_variable = val;
-}
-
-bool
-Watchpoint::CaptureWatchedValue (const ExecutionContext &exe_ctx)
-{
-    ConstString watch_name("$__lldb__watch_value");
-    m_old_value_sp = m_new_value_sp;
-    Address watch_address(GetLoadAddress());
-    if (!m_type.IsValid())
-    {
-        // Don't know how to report new & old values, since we couldn't make a scalar type for this watchpoint.
-        // This works around an assert in ValueObjectMemory::Create.
-        // FIXME: This should not happen, but if it does in some case we care about,
-        // we can go grab the value raw and print it as unsigned.
-        return false;
-    }
-    m_new_value_sp = ValueObjectMemory::Create (exe_ctx.GetBestExecutionContextScope(), watch_name.AsCString(), watch_address, m_type);
-    m_new_value_sp = m_new_value_sp->CreateConstantValue(watch_name);
-    return (m_new_value_sp && m_new_value_sp->GetError().Success());
-}
-
-void
-Watchpoint::IncrementFalseAlarmsAndReviseHitCount()
-{
-    ++m_false_alarms;
-    if (m_false_alarms)
-    {
-        if (m_hit_count >= m_false_alarms)
-        {
-            m_hit_count -= m_false_alarms;
-            m_false_alarms = 0;
-        }
-        else
-        {
-            m_false_alarms -= m_hit_count;
-            m_hit_count = 0;
-        }
+bool Watchpoint::IsHardware() const { return m_is_hardware; }
+
+bool Watchpoint::IsWatchVariable() const { return m_is_watch_variable; }
+
+void Watchpoint::SetWatchVariable(bool val) { m_is_watch_variable = val; }
+
+bool Watchpoint::CaptureWatchedValue(const ExecutionContext &exe_ctx) {
+  ConstString watch_name("$__lldb__watch_value");
+  m_old_value_sp = m_new_value_sp;
+  Address watch_address(GetLoadAddress());
+  if (!m_type.IsValid()) {
+    // Don't know how to report new & old values, since we couldn't make a
+    // scalar type for this watchpoint.
+    // This works around an assert in ValueObjectMemory::Create.
+    // FIXME: This should not happen, but if it does in some case we care about,
+    // we can go grab the value raw and print it as unsigned.
+    return false;
+  }
+  m_new_value_sp =
+      ValueObjectMemory::Create(exe_ctx.GetBestExecutionContextScope(),
+                                watch_name.AsCString(), watch_address, m_type);
+  m_new_value_sp = m_new_value_sp->CreateConstantValue(watch_name);
+  return (m_new_value_sp && m_new_value_sp->GetError().Success());
+}
+
+void Watchpoint::IncrementFalseAlarmsAndReviseHitCount() {
+  ++m_false_alarms;
+  if (m_false_alarms) {
+    if (m_hit_count >= m_false_alarms) {
+      m_hit_count -= m_false_alarms;
+      m_false_alarms = 0;
+    } else {
+      m_false_alarms -= m_hit_count;
+      m_hit_count = 0;
     }
+  }
 }
 
 // RETURNS - true if we should stop at this breakpoint, false if we
 // should continue.
 
-bool
-Watchpoint::ShouldStop (StoppointCallbackContext *context)
-{
-    IncrementHitCount();
+bool Watchpoint::ShouldStop(StoppointCallbackContext *context) {
+  IncrementHitCount();
 
-    if (!IsEnabled())
-        return false;
+  if (!IsEnabled())
+    return false;
 
-    return true;
+  return true;
 }
 
-void
-Watchpoint::GetDescription (Stream *s, lldb::DescriptionLevel level)
-{
-    DumpWithLevel(s, level);
+void Watchpoint::GetDescription(Stream *s, lldb::DescriptionLevel level) {
+  DumpWithLevel(s, level);
 }
 
-void
-Watchpoint::Dump(Stream *s) const
-{
-    DumpWithLevel(s, lldb::eDescriptionLevelBrief);
+void Watchpoint::Dump(Stream *s) const {
+  DumpWithLevel(s, lldb::eDescriptionLevelBrief);
 }
 
-// If prefix is nullptr, we display the watch id and ignore the prefix altogether.
-void
-Watchpoint::DumpSnapshots(Stream *s, const char *prefix) const
-{
-    if (!prefix)
-    {
-        s->Printf("\nWatchpoint %u hit:", GetID());
-        prefix = "";
-    }
+// If prefix is nullptr, we display the watch id and ignore the prefix
+// altogether.
+void Watchpoint::DumpSnapshots(Stream *s, const char *prefix) const {
+  if (!prefix) {
+    s->Printf("\nWatchpoint %u hit:", GetID());
+    prefix = "";
+  }
 
-    if (m_old_value_sp)
-    {
-        const char *old_value_cstr =  m_old_value_sp->GetValueAsCString();
-        if (old_value_cstr && old_value_cstr[0])
-            s->Printf("\n%sold value: %s", prefix, old_value_cstr);
-        else
-        {
-            const char *old_summary_cstr =  m_old_value_sp-> GetSummaryAsCString();
-            if (old_summary_cstr && old_summary_cstr[0])
-                s->Printf("\n%sold value: %s", prefix, old_summary_cstr);
-        }
+  if (m_old_value_sp) {
+    const char *old_value_cstr = m_old_value_sp->GetValueAsCString();
+    if (old_value_cstr && old_value_cstr[0])
+      s->Printf("\n%sold value: %s", prefix, old_value_cstr);
+    else {
+      const char *old_summary_cstr = m_old_value_sp->GetSummaryAsCString();
+      if (old_summary_cstr && old_summary_cstr[0])
+        s->Printf("\n%sold value: %s", prefix, old_summary_cstr);
     }
-
-    if (m_new_value_sp)
-    {
-        const char *new_value_cstr =  m_new_value_sp->GetValueAsCString();
-        if (new_value_cstr && new_value_cstr[0])
-            s->Printf("\n%snew value: %s", prefix, new_value_cstr);
-        else
-        {
-            const char *new_summary_cstr =  m_new_value_sp-> GetSummaryAsCString();
-            if (new_summary_cstr && new_summary_cstr[0])
-                s->Printf("\n%snew value: %s", prefix, new_summary_cstr);
-        }
+  }
+
+  if (m_new_value_sp) {
+    const char *new_value_cstr = m_new_value_sp->GetValueAsCString();
+    if (new_value_cstr && new_value_cstr[0])
+      s->Printf("\n%snew value: %s", prefix, new_value_cstr);
+    else {
+      const char *new_summary_cstr = m_new_value_sp->GetSummaryAsCString();
+      if (new_summary_cstr && new_summary_cstr[0])
+        s->Printf("\n%snew value: %s", prefix, new_summary_cstr);
     }
+  }
 }
 
-void
-Watchpoint::DumpWithLevel(Stream *s, lldb::DescriptionLevel description_level) const
-{
-    if (s == nullptr)
-        return;
-
-    assert(description_level >= lldb::eDescriptionLevelBrief &&
-           description_level <= lldb::eDescriptionLevelVerbose);
-
-    s->Printf("Watchpoint %u: addr = 0x%8.8" PRIx64 " size = %u state = %s type = %s%s",
-              GetID(),
-              GetLoadAddress(),
-              m_byte_size,
-              IsEnabled() ? "enabled" : "disabled",
-              m_watch_read ? "r" : "",
-              m_watch_write ? "w" : "");
-
-    if (description_level >= lldb::eDescriptionLevelFull) {
-        if (!m_decl_str.empty())
-            s->Printf("\n    declare @ '%s'", m_decl_str.c_str());
-        if (!m_watch_spec_str.empty())
-            s->Printf("\n    watchpoint spec = '%s'", m_watch_spec_str.c_str());
-
-        // Dump the snapshots we have taken.
-        DumpSnapshots(s, "    ");
-
-        if (GetConditionText())
-            s->Printf("\n    condition = '%s'", GetConditionText());
-        m_options.GetCallbackDescription(s, description_level);
-    }
+void Watchpoint::DumpWithLevel(Stream *s,
+                               lldb::DescriptionLevel description_level) const {
+  if (s == nullptr)
+    return;
 
-    if (description_level >= lldb::eDescriptionLevelVerbose)
-    {
-        s->Printf("\n    hw_index = %i  hit_count = %-4u  ignore_count = %-4u",
-                  GetHardwareIndex(),
-                  GetHitCount(),
-                  GetIgnoreCount());
-    }
-}
+  assert(description_level >= lldb::eDescriptionLevelBrief &&
+         description_level <= lldb::eDescriptionLevelVerbose);
 
-bool
-Watchpoint::IsEnabled() const
-{
-    return m_enabled;
-}
+  s->Printf("Watchpoint %u: addr = 0x%8.8" PRIx64
+            " size = %u state = %s type = %s%s",
+            GetID(), GetLoadAddress(), m_byte_size,
+            IsEnabled() ? "enabled" : "disabled", m_watch_read ? "r" : "",
+            m_watch_write ? "w" : "");
 
-// Within StopInfo.cpp, we purposely turn on the ephemeral mode right before temporarily disable the watchpoint
-// in order to perform possible watchpoint actions without triggering further watchpoint events.
-// After the temporary disabled watchpoint is enabled, we then turn off the ephemeral mode.
+  if (description_level >= lldb::eDescriptionLevelFull) {
+    if (!m_decl_str.empty())
+      s->Printf("\n    declare @ '%s'", m_decl_str.c_str());
+    if (!m_watch_spec_str.empty())
+      s->Printf("\n    watchpoint spec = '%s'", m_watch_spec_str.c_str());
 
-void
-Watchpoint::TurnOnEphemeralMode()
-{
-    m_is_ephemeral = true;
-}
+    // Dump the snapshots we have taken.
+    DumpSnapshots(s, "    ");
 
-void
-Watchpoint::TurnOffEphemeralMode()
-{
-    m_is_ephemeral = false;
-    // Leaving ephemeral mode, reset the m_disabled_count!
-    m_disabled_count = 0;
-}
+    if (GetConditionText())
+      s->Printf("\n    condition = '%s'", GetConditionText());
+    m_options.GetCallbackDescription(s, description_level);
+  }
 
-bool
-Watchpoint::IsDisabledDuringEphemeralMode()
-{
-    return m_disabled_count > 1;
+  if (description_level >= lldb::eDescriptionLevelVerbose) {
+    s->Printf("\n    hw_index = %i  hit_count = %-4u  ignore_count = %-4u",
+              GetHardwareIndex(), GetHitCount(), GetIgnoreCount());
+  }
 }
 
-void
-Watchpoint::SetEnabled(bool enabled, bool notify)
-{
-    if (!enabled)
-    {
-        if (!m_is_ephemeral)
-            SetHardwareIndex(LLDB_INVALID_INDEX32);
-        else
-            ++m_disabled_count;
-
-        // Don't clear the snapshots for now.
-        // Within StopInfo.cpp, we purposely do disable/enable watchpoint while performing watchpoint actions.
-    }
-    bool changed = enabled != m_enabled;
-    m_enabled = enabled;
-    if (notify && !m_is_ephemeral && changed)
-        SendWatchpointChangedEvent (enabled ? eWatchpointEventTypeEnabled : eWatchpointEventTypeDisabled);
-}
+bool Watchpoint::IsEnabled() const { return m_enabled; }
 
-void
-Watchpoint::SetWatchpointType (uint32_t type, bool notify)
-{
-    int old_watch_read = m_watch_read;
-    int old_watch_write = m_watch_write;
-    m_watch_read = (type & LLDB_WATCH_TYPE_READ) != 0;
-    m_watch_write = (type & LLDB_WATCH_TYPE_WRITE) != 0;
-    if (notify && (old_watch_read != m_watch_read || old_watch_write != m_watch_write))
-        SendWatchpointChangedEvent (eWatchpointEventTypeTypeChanged);
-}
+// Within StopInfo.cpp, we purposely turn on the ephemeral mode right before
+// temporarily disable the watchpoint
+// in order to perform possible watchpoint actions without triggering further
+// watchpoint events.
+// After the temporary disabled watchpoint is enabled, we then turn off the
+// ephemeral mode.
+
+void Watchpoint::TurnOnEphemeralMode() { m_is_ephemeral = true; }
 
-bool
-Watchpoint::WatchpointRead () const
-{
-    return m_watch_read != 0;
+void Watchpoint::TurnOffEphemeralMode() {
+  m_is_ephemeral = false;
+  // Leaving ephemeral mode, reset the m_disabled_count!
+  m_disabled_count = 0;
 }
 
-bool
-Watchpoint::WatchpointWrite () const
-{
-    return m_watch_write != 0;
+bool Watchpoint::IsDisabledDuringEphemeralMode() {
+  return m_disabled_count > 1;
 }
 
-uint32_t
-Watchpoint::GetIgnoreCount () const
-{
-    return m_ignore_count;
+void Watchpoint::SetEnabled(bool enabled, bool notify) {
+  if (!enabled) {
+    if (!m_is_ephemeral)
+      SetHardwareIndex(LLDB_INVALID_INDEX32);
+    else
+      ++m_disabled_count;
+
+    // Don't clear the snapshots for now.
+    // Within StopInfo.cpp, we purposely do disable/enable watchpoint while
+    // performing watchpoint actions.
+  }
+  bool changed = enabled != m_enabled;
+  m_enabled = enabled;
+  if (notify && !m_is_ephemeral && changed)
+    SendWatchpointChangedEvent(enabled ? eWatchpointEventTypeEnabled
+                                       : eWatchpointEventTypeDisabled);
 }
 
-void
-Watchpoint::SetIgnoreCount (uint32_t n)
-{
-    bool changed = m_ignore_count != n;
-    m_ignore_count = n;
-    if (changed)
-        SendWatchpointChangedEvent (eWatchpointEventTypeIgnoreChanged);
+void Watchpoint::SetWatchpointType(uint32_t type, bool notify) {
+  int old_watch_read = m_watch_read;
+  int old_watch_write = m_watch_write;
+  m_watch_read = (type & LLDB_WATCH_TYPE_READ) != 0;
+  m_watch_write = (type & LLDB_WATCH_TYPE_WRITE) != 0;
+  if (notify &&
+      (old_watch_read != m_watch_read || old_watch_write != m_watch_write))
+    SendWatchpointChangedEvent(eWatchpointEventTypeTypeChanged);
 }
 
-bool
-Watchpoint::InvokeCallback (StoppointCallbackContext *context)
-{
-    return m_options.InvokeCallback (context, GetID());
+bool Watchpoint::WatchpointRead() const { return m_watch_read != 0; }
+
+bool Watchpoint::WatchpointWrite() const { return m_watch_write != 0; }
+
+uint32_t Watchpoint::GetIgnoreCount() const { return m_ignore_count; }
+
+void Watchpoint::SetIgnoreCount(uint32_t n) {
+  bool changed = m_ignore_count != n;
+  m_ignore_count = n;
+  if (changed)
+    SendWatchpointChangedEvent(eWatchpointEventTypeIgnoreChanged);
 }
 
-void 
-Watchpoint::SetCondition (const char *condition)
-{
-    if (condition == nullptr || condition[0] == '\0')
-    {
-        if (m_condition_ap.get())
-            m_condition_ap.reset();
-    }
-    else
-    {
-        // Pass nullptr for expr_prefix (no translation-unit level definitions).
-        Error error;
-        m_condition_ap.reset(m_target.GetUserExpressionForLanguage(condition,
-                                                                   nullptr,
-                                                                   lldb::eLanguageTypeUnknown,
-                                                                   UserExpression::eResultTypeAny,
-                                                                   EvaluateExpressionOptions(),
-                                                                   error));
-        if (error.Fail())
-        {
-            // FIXME: Log something...
-            m_condition_ap.reset();
-        }
-    }
-    SendWatchpointChangedEvent (eWatchpointEventTypeConditionChanged);
+bool Watchpoint::InvokeCallback(StoppointCallbackContext *context) {
+  return m_options.InvokeCallback(context, GetID());
 }
 
-const char *
-Watchpoint::GetConditionText () const
-{
+void Watchpoint::SetCondition(const char *condition) {
+  if (condition == nullptr || condition[0] == '\0') {
     if (m_condition_ap.get())
-        return m_condition_ap->GetUserText();
-    else
-        return nullptr;
+      m_condition_ap.reset();
+  } else {
+    // Pass nullptr for expr_prefix (no translation-unit level definitions).
+    Error error;
+    m_condition_ap.reset(m_target.GetUserExpressionForLanguage(
+        condition, nullptr, lldb::eLanguageTypeUnknown,
+        UserExpression::eResultTypeAny, EvaluateExpressionOptions(), error));
+    if (error.Fail()) {
+      // FIXME: Log something...
+      m_condition_ap.reset();
+    }
+  }
+  SendWatchpointChangedEvent(eWatchpointEventTypeConditionChanged);
 }
 
-void
-Watchpoint::SendWatchpointChangedEvent (lldb::WatchpointEventType eventKind)
-{
-    if (!m_being_created
-        && GetTarget().EventTypeHasListeners(Target::eBroadcastBitWatchpointChanged))
-    {
-        WatchpointEventData *data = new Watchpoint::WatchpointEventData (eventKind, shared_from_this());
-        GetTarget().BroadcastEvent (Target::eBroadcastBitWatchpointChanged, data);
-    }
+const char *Watchpoint::GetConditionText() const {
+  if (m_condition_ap.get())
+    return m_condition_ap->GetUserText();
+  else
+    return nullptr;
 }
 
-void
-Watchpoint::SendWatchpointChangedEvent (WatchpointEventData *data)
-{
-    if (data == nullptr)
-        return;
-        
-    if (!m_being_created
-        && GetTarget().EventTypeHasListeners(Target::eBroadcastBitWatchpointChanged))
-        GetTarget().BroadcastEvent (Target::eBroadcastBitWatchpointChanged, data);
-    else
-        delete data;
+void Watchpoint::SendWatchpointChangedEvent(
+    lldb::WatchpointEventType eventKind) {
+  if (!m_being_created &&
+      GetTarget().EventTypeHasListeners(
+          Target::eBroadcastBitWatchpointChanged)) {
+    WatchpointEventData *data =
+        new Watchpoint::WatchpointEventData(eventKind, shared_from_this());
+    GetTarget().BroadcastEvent(Target::eBroadcastBitWatchpointChanged, data);
+  }
 }
 
-Watchpoint::WatchpointEventData::WatchpointEventData (WatchpointEventType sub_type, 
-                                                      const WatchpointSP &new_watchpoint_sp) :
-    EventData (),
-    m_watchpoint_event (sub_type),
-    m_new_watchpoint_sp (new_watchpoint_sp)
-{
+void Watchpoint::SendWatchpointChangedEvent(WatchpointEventData *data) {
+  if (data == nullptr)
+    return;
+
+  if (!m_being_created &&
+      GetTarget().EventTypeHasListeners(Target::eBroadcastBitWatchpointChanged))
+    GetTarget().BroadcastEvent(Target::eBroadcastBitWatchpointChanged, data);
+  else
+    delete data;
 }
 
+Watchpoint::WatchpointEventData::WatchpointEventData(
+    WatchpointEventType sub_type, const WatchpointSP &new_watchpoint_sp)
+    : EventData(), m_watchpoint_event(sub_type),
+      m_new_watchpoint_sp(new_watchpoint_sp) {}
+
 Watchpoint::WatchpointEventData::~WatchpointEventData() = default;
 
-const ConstString &
-Watchpoint::WatchpointEventData::GetFlavorString ()
-{
-    static ConstString g_flavor ("Watchpoint::WatchpointEventData");
-    return g_flavor;
+const ConstString &Watchpoint::WatchpointEventData::GetFlavorString() {
+  static ConstString g_flavor("Watchpoint::WatchpointEventData");
+  return g_flavor;
 }
 
-const ConstString &
-Watchpoint::WatchpointEventData::GetFlavor () const
-{
-    return WatchpointEventData::GetFlavorString ();
+const ConstString &Watchpoint::WatchpointEventData::GetFlavor() const {
+  return WatchpointEventData::GetFlavorString();
 }
 
-WatchpointSP &
-Watchpoint::WatchpointEventData::GetWatchpoint ()
-{
-    return m_new_watchpoint_sp;
+WatchpointSP &Watchpoint::WatchpointEventData::GetWatchpoint() {
+  return m_new_watchpoint_sp;
 }
 
 WatchpointEventType
-Watchpoint::WatchpointEventData::GetWatchpointEventType () const
-{
-    return m_watchpoint_event;
+Watchpoint::WatchpointEventData::GetWatchpointEventType() const {
+  return m_watchpoint_event;
 }
 
-void
-Watchpoint::WatchpointEventData::Dump (Stream *s) const
-{
-}
+void Watchpoint::WatchpointEventData::Dump(Stream *s) const {}
 
 const Watchpoint::WatchpointEventData *
-Watchpoint::WatchpointEventData::GetEventDataFromEvent (const Event *event)
-{
-    if (event)
-    {
-        const EventData *event_data = event->GetData();
-        if (event_data && event_data->GetFlavor() == WatchpointEventData::GetFlavorString())
-            return static_cast <const WatchpointEventData *> (event->GetData());
-    }
-    return nullptr;
+Watchpoint::WatchpointEventData::GetEventDataFromEvent(const Event *event) {
+  if (event) {
+    const EventData *event_data = event->GetData();
+    if (event_data &&
+        event_data->GetFlavor() == WatchpointEventData::GetFlavorString())
+      return static_cast<const WatchpointEventData *>(event->GetData());
+  }
+  return nullptr;
 }
 
 WatchpointEventType
-Watchpoint::WatchpointEventData::GetWatchpointEventTypeFromEvent (const EventSP &event_sp)
-{
-    const WatchpointEventData *data = GetEventDataFromEvent (event_sp.get());
+Watchpoint::WatchpointEventData::GetWatchpointEventTypeFromEvent(
+    const EventSP &event_sp) {
+  const WatchpointEventData *data = GetEventDataFromEvent(event_sp.get());
 
-    if (data == nullptr)
-        return eWatchpointEventTypeInvalidType;
-    else
-        return data->GetWatchpointEventType();
+  if (data == nullptr)
+    return eWatchpointEventTypeInvalidType;
+  else
+    return data->GetWatchpointEventType();
 }
 
-WatchpointSP
-Watchpoint::WatchpointEventData::GetWatchpointFromEvent (const EventSP &event_sp)
-{
-    WatchpointSP wp_sp;
+WatchpointSP Watchpoint::WatchpointEventData::GetWatchpointFromEvent(
+    const EventSP &event_sp) {
+  WatchpointSP wp_sp;
 
-    const WatchpointEventData *data = GetEventDataFromEvent (event_sp.get());
-    if (data)
-        wp_sp = data->m_new_watchpoint_sp;
+  const WatchpointEventData *data = GetEventDataFromEvent(event_sp.get());
+  if (data)
+    wp_sp = data->m_new_watchpoint_sp;
 
-    return wp_sp;
+  return wp_sp;
 }