Add "operator bool" to SB APIs

Summary:
Our python version of the SB API has (the python equivalent of)
operator bool, but the C++ version doesn't.

This is because our python operators are added by modify-python-lldb.py,
which performs postprocessing on the swig-generated interface files.

In this patch, I add the "operator bool" to all SB classes which have an
IsValid method (which is the same logic used by modify-python-lldb.py).
This way, we make the two interfaces more constent, and it allows us to
rely on swig's automatic syntesis of python __nonzero__ methods instead
of doing manual fixups.

Reviewers: zturner, jingham, clayborg, jfb, serge-sans-paille

Subscribers: jdoerfert, lldb-commits

Differential Revision: https://reviews.llvm.org/D58792

llvm-svn: 355824

1 files changed, 61 insertions, 0 deletions

diff --git a/lldb/source/API/SBReproducer.cpp b/lldb/source/API/SBReproducer.cpp
index 7980f1505b0..c3dad774d7f 100644
--- a/lldb/source/API/SBReproducer.cpp
+++ b/lldb/source/API/SBReproducer.cpp
@@ -62,6 +62,7 @@ SBRegistry::SBRegistry() {
     LLDB_REGISTER_METHOD(const lldb::SBAddress &,
                          SBAddress, operator=,(const lldb::SBAddress &));
     LLDB_REGISTER_METHOD_CONST(bool, SBAddress, IsValid, ());
+    LLDB_REGISTER_METHOD_CONST(bool, SBAddress, operator bool, ());
     LLDB_REGISTER_METHOD(void, SBAddress, Clear, ());
     LLDB_REGISTER_METHOD(void, SBAddress, SetAddress,
                          (lldb::SBSection, lldb::addr_t));
@@ -129,6 +130,7 @@ SBRegistry::SBRegistry() {
     LLDB_REGISTER_METHOD(const lldb::SBBlock &,
                          SBBlock, operator=,(const lldb::SBBlock &));
     LLDB_REGISTER_METHOD_CONST(bool, SBBlock, IsValid, ());
+    LLDB_REGISTER_METHOD_CONST(bool, SBBlock, operator bool, ());
     LLDB_REGISTER_METHOD_CONST(bool, SBBlock, IsInlined, ());
     LLDB_REGISTER_METHOD_CONST(const char *, SBBlock, GetInlinedName, ());
     LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBBlock,
@@ -165,6 +167,7 @@ SBRegistry::SBRegistry() {
                          SBBreakpoint, operator!=,(const lldb::SBBreakpoint &));
     LLDB_REGISTER_METHOD_CONST(lldb::break_id_t, SBBreakpoint, GetID, ());
     LLDB_REGISTER_METHOD_CONST(bool, SBBreakpoint, IsValid, ());
+    LLDB_REGISTER_METHOD_CONST(bool, SBBreakpoint, operator bool, ());
     LLDB_REGISTER_METHOD(void, SBBreakpoint, ClearAllBreakpointSites, ());
     LLDB_REGISTER_METHOD(lldb::SBBreakpointLocation, SBBreakpoint,
                          FindLocationByAddress, (lldb::addr_t));
@@ -254,6 +257,7 @@ SBRegistry::SBRegistry() {
         const lldb::SBBreakpointLocation &,
         SBBreakpointLocation, operator=,(const lldb::SBBreakpointLocation &));
     LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointLocation, IsValid, ());
+    LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointLocation, operator bool, ());
     LLDB_REGISTER_METHOD(lldb::SBAddress, SBBreakpointLocation, GetAddress, ());
     LLDB_REGISTER_METHOD(lldb::addr_t, SBBreakpointLocation, GetLoadAddress,
                          ());
@@ -314,6 +318,7 @@ SBRegistry::SBRegistry() {
     LLDB_REGISTER_METHOD(
         bool, SBBreakpointName, operator!=,(const lldb::SBBreakpointName &));
     LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointName, IsValid, ());
+    LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointName, operator bool, ());
     LLDB_REGISTER_METHOD_CONST(const char *, SBBreakpointName, GetName, ());
     LLDB_REGISTER_METHOD(void, SBBreakpointName, SetEnabled, (bool));
     LLDB_REGISTER_METHOD(bool, SBBreakpointName, IsEnabled, ());
@@ -376,6 +381,7 @@ SBRegistry::SBRegistry() {
     LLDB_REGISTER_METHOD(bool, SBBroadcaster, RemoveListener,
                          (const lldb::SBListener &, uint32_t));
     LLDB_REGISTER_METHOD_CONST(bool, SBBroadcaster, IsValid, ());
+    LLDB_REGISTER_METHOD_CONST(bool, SBBroadcaster, operator bool, ());
     LLDB_REGISTER_METHOD(void, SBBroadcaster, Clear, ());
     LLDB_REGISTER_METHOD_CONST(
         bool, SBBroadcaster, operator==,(const lldb::SBBroadcaster &));
@@ -422,6 +428,7 @@ SBRegistry::SBRegistry() {
         const lldb::SBCommandInterpreter &,
         SBCommandInterpreter, operator=,(const lldb::SBCommandInterpreter &));
     LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreter, IsValid, ());
+    LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreter, operator bool, ());
     LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, CommandExists,
                          (const char *));
     LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, AliasExists,
@@ -498,6 +505,7 @@ SBRegistry::SBRegistry() {
                           const char *, const char *));
     LLDB_REGISTER_CONSTRUCTOR(SBCommand, ());
     LLDB_REGISTER_METHOD(bool, SBCommand, IsValid, ());
+    LLDB_REGISTER_METHOD_CONST(bool, SBCommand, operator bool, ());
     LLDB_REGISTER_METHOD(const char *, SBCommand, GetName, ());
     LLDB_REGISTER_METHOD(const char *, SBCommand, GetHelp, ());
     LLDB_REGISTER_METHOD(const char *, SBCommand, GetHelpLong, ());
@@ -526,6 +534,7 @@ SBRegistry::SBRegistry() {
         const lldb::SBCommandReturnObject &,
         SBCommandReturnObject, operator=,(const lldb::SBCommandReturnObject &));
     LLDB_REGISTER_METHOD_CONST(bool, SBCommandReturnObject, IsValid, ());
+    LLDB_REGISTER_METHOD_CONST(bool, SBCommandReturnObject, operator bool, ());
     LLDB_REGISTER_METHOD(const char *, SBCommandReturnObject, GetOutput, ());
     LLDB_REGISTER_METHOD(const char *, SBCommandReturnObject, GetError, ());
     LLDB_REGISTER_METHOD(size_t, SBCommandReturnObject, GetOutputSize, ());
@@ -566,6 +575,7 @@ SBRegistry::SBRegistry() {
     LLDB_REGISTER_CONSTRUCTOR(SBCommunication, ());
     LLDB_REGISTER_CONSTRUCTOR(SBCommunication, (const char *));
     LLDB_REGISTER_METHOD_CONST(bool, SBCommunication, IsValid, ());
+    LLDB_REGISTER_METHOD_CONST(bool, SBCommunication, operator bool, ());
     LLDB_REGISTER_METHOD(bool, SBCommunication, GetCloseOnEOF, ());
     LLDB_REGISTER_METHOD(void, SBCommunication, SetCloseOnEOF, (bool));
     LLDB_REGISTER_METHOD(lldb::ConnectionStatus, SBCommunication, Connect,
@@ -606,6 +616,7 @@ SBRegistry::SBRegistry() {
                          (uint32_t, const lldb::SBFileSpec &, bool));
     LLDB_REGISTER_METHOD(lldb::LanguageType, SBCompileUnit, GetLanguage, ());
     LLDB_REGISTER_METHOD_CONST(bool, SBCompileUnit, IsValid, ());
+    LLDB_REGISTER_METHOD_CONST(bool, SBCompileUnit, operator bool, ());
     LLDB_REGISTER_METHOD_CONST(
         bool, SBCompileUnit, operator==,(const lldb::SBCompileUnit &));
     LLDB_REGISTER_METHOD_CONST(
@@ -619,6 +630,7 @@ SBRegistry::SBRegistry() {
     LLDB_REGISTER_METHOD(const lldb::SBData &,
                          SBData, operator=,(const lldb::SBData &));
     LLDB_REGISTER_METHOD(bool, SBData, IsValid, ());
+    LLDB_REGISTER_METHOD_CONST(bool, SBData, operator bool, ());
     LLDB_REGISTER_METHOD(uint8_t, SBData, GetAddressByteSize, ());
     LLDB_REGISTER_METHOD(void, SBData, SetAddressByteSize, (uint8_t));
     LLDB_REGISTER_METHOD(void, SBData, Clear, ());
@@ -699,6 +711,7 @@ SBRegistry::SBRegistry() {
                                 (lldb::SBDebugger &));
     LLDB_REGISTER_STATIC_METHOD(void, SBDebugger, MemoryPressureDetected, ());
     LLDB_REGISTER_METHOD_CONST(bool, SBDebugger, IsValid, ());
+    LLDB_REGISTER_METHOD_CONST(bool, SBDebugger, operator bool, ());
     LLDB_REGISTER_METHOD(void, SBDebugger, SetAsync, (bool));
     LLDB_REGISTER_METHOD(bool, SBDebugger, GetAsync, ());
     LLDB_REGISTER_METHOD(void, SBDebugger, SkipLLDBInitFiles, (bool));
@@ -836,6 +849,7 @@ SBRegistry::SBRegistry() {
         const lldb::SBDeclaration &,
         SBDeclaration, operator=,(const lldb::SBDeclaration &));
     LLDB_REGISTER_METHOD_CONST(bool, SBDeclaration, IsValid, ());
+    LLDB_REGISTER_METHOD_CONST(bool, SBDeclaration, operator bool, ());
     LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBDeclaration, GetFileSpec,
                                ());
     LLDB_REGISTER_METHOD_CONST(uint32_t, SBDeclaration, GetLine, ());
@@ -866,6 +880,7 @@ SBRegistry::SBRegistry() {
     LLDB_REGISTER_METHOD(void, SBError, SetErrorToGenericError, ());
     LLDB_REGISTER_METHOD(void, SBError, SetErrorString, (const char *));
     LLDB_REGISTER_METHOD_CONST(bool, SBError, IsValid, ());
+    LLDB_REGISTER_METHOD_CONST(bool, SBError, operator bool, ());
     LLDB_REGISTER_METHOD(bool, SBError, GetDescription, (lldb::SBStream &));
   }
   {
@@ -887,6 +902,7 @@ SBRegistry::SBRegistry() {
                          (const lldb::SBBroadcaster &));
     LLDB_REGISTER_METHOD(void, SBEvent, Clear, ());
     LLDB_REGISTER_METHOD_CONST(bool, SBEvent, IsValid, ());
+    LLDB_REGISTER_METHOD_CONST(bool, SBEvent, operator bool, ());
     LLDB_REGISTER_STATIC_METHOD(const char *, SBEvent, GetCStringFromEvent,
                                 (const lldb::SBEvent &));
     LLDB_REGISTER_METHOD(bool, SBEvent, GetDescription, (lldb::SBStream &));
@@ -977,6 +993,7 @@ SBRegistry::SBRegistry() {
     LLDB_REGISTER_METHOD(const lldb::SBFileSpec &,
                          SBFileSpec, operator=,(const lldb::SBFileSpec &));
     LLDB_REGISTER_METHOD_CONST(bool, SBFileSpec, IsValid, ());
+    LLDB_REGISTER_METHOD_CONST(bool, SBFileSpec, operator bool, ());
     LLDB_REGISTER_METHOD_CONST(bool, SBFileSpec, Exists, ());
     LLDB_REGISTER_METHOD(bool, SBFileSpec, ResolveExecutableLocation, ());
     LLDB_REGISTER_STATIC_METHOD(int, SBFileSpec, ResolvePath,
@@ -1016,6 +1033,7 @@ SBRegistry::SBRegistry() {
     LLDB_REGISTER_METHOD(const lldb::SBFrame &,
                          SBFrame, operator=,(const lldb::SBFrame &));
     LLDB_REGISTER_METHOD_CONST(bool, SBFrame, IsValid, ());
+    LLDB_REGISTER_METHOD_CONST(bool, SBFrame, operator bool, ());
     LLDB_REGISTER_METHOD_CONST(lldb::SBSymbolContext, SBFrame, GetSymbolContext,
                                (uint32_t));
     LLDB_REGISTER_METHOD_CONST(lldb::SBModule, SBFrame, GetModule, ());
@@ -1085,6 +1103,7 @@ SBRegistry::SBRegistry() {
     LLDB_REGISTER_METHOD(const lldb::SBFunction &,
                          SBFunction, operator=,(const lldb::SBFunction &));
     LLDB_REGISTER_METHOD_CONST(bool, SBFunction, IsValid, ());
+    LLDB_REGISTER_METHOD_CONST(bool, SBFunction, operator bool, ());
     LLDB_REGISTER_METHOD_CONST(const char *, SBFunction, GetName, ());
     LLDB_REGISTER_METHOD_CONST(const char *, SBFunction, GetDisplayName, ());
     LLDB_REGISTER_METHOD_CONST(const char *, SBFunction, GetMangledName, ());
@@ -1124,6 +1143,7 @@ SBRegistry::SBRegistry() {
         const lldb::SBInstruction &,
         SBInstruction, operator=,(const lldb::SBInstruction &));
     LLDB_REGISTER_METHOD(bool, SBInstruction, IsValid, ());
+    LLDB_REGISTER_METHOD_CONST(bool, SBInstruction, operator bool, ());
     LLDB_REGISTER_METHOD(lldb::SBAddress, SBInstruction, GetAddress, ());
     LLDB_REGISTER_METHOD(const char *, SBInstruction, GetMnemonic,
                          (lldb::SBTarget));
@@ -1154,6 +1174,7 @@ SBRegistry::SBRegistry() {
         const lldb::SBInstructionList &,
         SBInstructionList, operator=,(const lldb::SBInstructionList &));
     LLDB_REGISTER_METHOD_CONST(bool, SBInstructionList, IsValid, ());
+    LLDB_REGISTER_METHOD_CONST(bool, SBInstructionList, operator bool, ());
     LLDB_REGISTER_METHOD(size_t, SBInstructionList, GetSize, ());
     LLDB_REGISTER_METHOD(lldb::SBInstruction, SBInstructionList,
                          GetInstructionAtIndex, (uint32_t));
@@ -1238,6 +1259,7 @@ SBRegistry::SBRegistry() {
                                ());
     LLDB_REGISTER_METHOD_CONST(lldb::SBAddress, SBLineEntry, GetEndAddress, ());
     LLDB_REGISTER_METHOD_CONST(bool, SBLineEntry, IsValid, ());
+    LLDB_REGISTER_METHOD_CONST(bool, SBLineEntry, operator bool, ());
     LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBLineEntry, GetFileSpec, ());
     LLDB_REGISTER_METHOD_CONST(uint32_t, SBLineEntry, GetLine, ());
     LLDB_REGISTER_METHOD_CONST(uint32_t, SBLineEntry, GetColumn, ());
@@ -1257,6 +1279,7 @@ SBRegistry::SBRegistry() {
     LLDB_REGISTER_METHOD(const lldb::SBListener &,
                          SBListener, operator=,(const lldb::SBListener &));
     LLDB_REGISTER_METHOD_CONST(bool, SBListener, IsValid, ());
+    LLDB_REGISTER_METHOD_CONST(bool, SBListener, operator bool, ());
     LLDB_REGISTER_METHOD(void, SBListener, AddEvent, (const lldb::SBEvent &));
     LLDB_REGISTER_METHOD(void, SBListener, Clear, ());
     LLDB_REGISTER_METHOD(uint32_t, SBListener, StartListeningForEventClass,
@@ -1339,6 +1362,7 @@ SBRegistry::SBRegistry() {
     LLDB_REGISTER_METHOD(const lldb::SBModule &,
                          SBModule, operator=,(const lldb::SBModule &));
     LLDB_REGISTER_METHOD_CONST(bool, SBModule, IsValid, ());
+    LLDB_REGISTER_METHOD_CONST(bool, SBModule, operator bool, ());
     LLDB_REGISTER_METHOD(void, SBModule, Clear, ());
     LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBModule, GetFileSpec, ());
     LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBModule, GetPlatformFileSpec,
@@ -1407,6 +1431,7 @@ SBRegistry::SBRegistry() {
     LLDB_REGISTER_METHOD(const lldb::SBModuleSpec &,
                          SBModuleSpec, operator=,(const lldb::SBModuleSpec &));
     LLDB_REGISTER_METHOD_CONST(bool, SBModuleSpec, IsValid, ());
+    LLDB_REGISTER_METHOD_CONST(bool, SBModuleSpec, operator bool, ());
     LLDB_REGISTER_METHOD(void, SBModuleSpec, Clear, ());
     LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBModuleSpec, GetFileSpec, ());
     LLDB_REGISTER_METHOD(void, SBModuleSpec, SetFileSpec,
@@ -1487,6 +1512,7 @@ SBRegistry::SBRegistry() {
     LLDB_REGISTER_CONSTRUCTOR(SBPlatform, ());
     LLDB_REGISTER_CONSTRUCTOR(SBPlatform, (const char *));
     LLDB_REGISTER_METHOD_CONST(bool, SBPlatform, IsValid, ());
+    LLDB_REGISTER_METHOD_CONST(bool, SBPlatform, operator bool, ());
     LLDB_REGISTER_METHOD(void, SBPlatform, Clear, ());
     LLDB_REGISTER_METHOD(const char *, SBPlatform, GetName, ());
     LLDB_REGISTER_METHOD(const char *, SBPlatform, GetWorkingDirectory, ());
@@ -1534,6 +1560,7 @@ SBRegistry::SBRegistry() {
     LLDB_REGISTER_METHOD(const char *, SBProcess, GetShortPluginName, ());
     LLDB_REGISTER_METHOD(void, SBProcess, Clear, ());
     LLDB_REGISTER_METHOD_CONST(bool, SBProcess, IsValid, ());
+    LLDB_REGISTER_METHOD_CONST(bool, SBProcess, operator bool, ());
     LLDB_REGISTER_METHOD(bool, SBProcess, RemoteLaunch,
                          (const char **, const char **, const char *,
                           const char *, const char *, const char *, uint32_t,
@@ -1654,6 +1681,7 @@ SBRegistry::SBRegistry() {
         lldb::SBProcessInfo &,
         SBProcessInfo, operator=,(const lldb::SBProcessInfo &));
     LLDB_REGISTER_METHOD_CONST(bool, SBProcessInfo, IsValid, ());
+    LLDB_REGISTER_METHOD_CONST(bool, SBProcessInfo, operator bool, ());
     LLDB_REGISTER_METHOD(const char *, SBProcessInfo, GetName, ());
     LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBProcessInfo, GetExecutableFile,
                          ());
@@ -1675,6 +1703,7 @@ SBRegistry::SBRegistry() {
     LLDB_REGISTER_METHOD(const lldb::SBQueue &,
                          SBQueue, operator=,(const lldb::SBQueue &));
     LLDB_REGISTER_METHOD_CONST(bool, SBQueue, IsValid, ());
+    LLDB_REGISTER_METHOD_CONST(bool, SBQueue, operator bool, ());
     LLDB_REGISTER_METHOD(void, SBQueue, Clear, ());
     LLDB_REGISTER_METHOD_CONST(lldb::queue_id_t, SBQueue, GetQueueID, ());
     LLDB_REGISTER_METHOD_CONST(uint32_t, SBQueue, GetIndexID, ());
@@ -1692,6 +1721,7 @@ SBRegistry::SBRegistry() {
     LLDB_REGISTER_CONSTRUCTOR(SBQueueItem, ());
     LLDB_REGISTER_CONSTRUCTOR(SBQueueItem, (const lldb::QueueItemSP &));
     LLDB_REGISTER_METHOD_CONST(bool, SBQueueItem, IsValid, ());
+    LLDB_REGISTER_METHOD_CONST(bool, SBQueueItem, operator bool, ());
     LLDB_REGISTER_METHOD(void, SBQueueItem, Clear, ());
     LLDB_REGISTER_METHOD(void, SBQueueItem, SetQueueItem,
                          (const lldb::QueueItemSP &));
@@ -1708,6 +1738,7 @@ SBRegistry::SBRegistry() {
     LLDB_REGISTER_METHOD(const lldb::SBSection &,
                          SBSection, operator=,(const lldb::SBSection &));
     LLDB_REGISTER_METHOD_CONST(bool, SBSection, IsValid, ());
+    LLDB_REGISTER_METHOD_CONST(bool, SBSection, operator bool, ());
     LLDB_REGISTER_METHOD(const char *, SBSection, GetName, ());
     LLDB_REGISTER_METHOD(lldb::SBSection, SBSection, GetParent, ());
     LLDB_REGISTER_METHOD(lldb::SBSection, SBSection, FindSubSection,
@@ -1750,6 +1781,7 @@ SBRegistry::SBRegistry() {
   {
     LLDB_REGISTER_CONSTRUCTOR(SBStream, ());
     LLDB_REGISTER_METHOD_CONST(bool, SBStream, IsValid, ());
+    LLDB_REGISTER_METHOD_CONST(bool, SBStream, operator bool, ());
     LLDB_REGISTER_METHOD(const char *, SBStream, GetData, ());
     LLDB_REGISTER_METHOD(size_t, SBStream, GetSize, ());
     LLDB_REGISTER_METHOD(void, SBStream, RedirectToFile, (const char *, bool));
@@ -1763,6 +1795,7 @@ SBRegistry::SBRegistry() {
     LLDB_REGISTER_METHOD(const lldb::SBStringList &,
                          SBStringList, operator=,(const lldb::SBStringList &));
     LLDB_REGISTER_METHOD_CONST(bool, SBStringList, IsValid, ());
+    LLDB_REGISTER_METHOD_CONST(bool, SBStringList, operator bool, ());
     LLDB_REGISTER_METHOD(void, SBStringList, AppendString, (const char *));
     LLDB_REGISTER_METHOD(void, SBStringList, AppendList, (const char **, int));
     LLDB_REGISTER_METHOD(void, SBStringList, AppendList,
@@ -1787,6 +1820,7 @@ SBRegistry::SBRegistry() {
     LLDB_REGISTER_METHOD(lldb::SBError, SBStructuredData, SetFromJSON,
                          (lldb::SBStream &));
     LLDB_REGISTER_METHOD_CONST(bool, SBStructuredData, IsValid, ());
+    LLDB_REGISTER_METHOD_CONST(bool, SBStructuredData, operator bool, ());
     LLDB_REGISTER_METHOD(void, SBStructuredData, Clear, ());
     LLDB_REGISTER_METHOD_CONST(lldb::SBError, SBStructuredData, GetAsJSON,
                                (lldb::SBStream &));
@@ -1815,6 +1849,7 @@ SBRegistry::SBRegistry() {
     LLDB_REGISTER_METHOD(const lldb::SBSymbol &,
                          SBSymbol, operator=,(const lldb::SBSymbol &));
     LLDB_REGISTER_METHOD_CONST(bool, SBSymbol, IsValid, ());
+    LLDB_REGISTER_METHOD_CONST(bool, SBSymbol, operator bool, ());
     LLDB_REGISTER_METHOD_CONST(const char *, SBSymbol, GetName, ());
     LLDB_REGISTER_METHOD_CONST(const char *, SBSymbol, GetDisplayName, ());
     LLDB_REGISTER_METHOD_CONST(const char *, SBSymbol, GetMangledName, ());
@@ -1843,6 +1878,7 @@ SBRegistry::SBRegistry() {
         const lldb::SBSymbolContext &,
         SBSymbolContext, operator=,(const lldb::SBSymbolContext &));
     LLDB_REGISTER_METHOD_CONST(bool, SBSymbolContext, IsValid, ());
+    LLDB_REGISTER_METHOD_CONST(bool, SBSymbolContext, operator bool, ());
     LLDB_REGISTER_METHOD(lldb::SBModule, SBSymbolContext, GetModule, ());
     LLDB_REGISTER_METHOD(lldb::SBCompileUnit, SBSymbolContext, GetCompileUnit,
                          ());
@@ -1881,6 +1917,7 @@ SBRegistry::SBRegistry() {
     LLDB_REGISTER_METHOD(void, SBSymbolContextList, Append,
                          (lldb::SBSymbolContextList &));
     LLDB_REGISTER_METHOD_CONST(bool, SBSymbolContextList, IsValid, ());
+    LLDB_REGISTER_METHOD_CONST(bool, SBSymbolContextList, operator bool, ());
     LLDB_REGISTER_METHOD(bool, SBSymbolContextList, GetDescription,
                          (lldb::SBStream &));
   }
@@ -1902,6 +1939,7 @@ SBRegistry::SBRegistry() {
     LLDB_REGISTER_STATIC_METHOD(const char *, SBTarget, GetBroadcasterClassName,
                                 ());
     LLDB_REGISTER_METHOD_CONST(bool, SBTarget, IsValid, ());
+    LLDB_REGISTER_METHOD_CONST(bool, SBTarget, operator bool, ());
     LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, GetProcess, ());
     LLDB_REGISTER_METHOD(lldb::SBPlatform, SBTarget, GetPlatform, ());
     LLDB_REGISTER_METHOD_CONST(lldb::SBDebugger, SBTarget, GetDebugger, ());
@@ -2132,6 +2170,7 @@ SBRegistry::SBRegistry() {
                          SBThread, operator=,(const lldb::SBThread &));
     LLDB_REGISTER_METHOD_CONST(lldb::SBQueue, SBThread, GetQueue, ());
     LLDB_REGISTER_METHOD_CONST(bool, SBThread, IsValid, ());
+    LLDB_REGISTER_METHOD_CONST(bool, SBThread, operator bool, ());
     LLDB_REGISTER_METHOD(void, SBThread, Clear, ());
     LLDB_REGISTER_METHOD(lldb::StopReason, SBThread, GetStopReason, ());
     LLDB_REGISTER_METHOD(size_t, SBThread, GetStopReasonDataCount, ());
@@ -2229,6 +2268,7 @@ SBRegistry::SBRegistry() {
         const lldb::SBThreadCollection &,
         SBThreadCollection, operator=,(const lldb::SBThreadCollection &));
     LLDB_REGISTER_METHOD_CONST(bool, SBThreadCollection, IsValid, ());
+    LLDB_REGISTER_METHOD_CONST(bool, SBThreadCollection, operator bool, ());
     LLDB_REGISTER_METHOD(size_t, SBThreadCollection, GetSize, ());
     LLDB_REGISTER_METHOD(lldb::SBThread, SBThreadCollection, GetThreadAtIndex,
                          (size_t));
@@ -2242,6 +2282,7 @@ SBRegistry::SBRegistry() {
                          SBThreadPlan, operator=,(const lldb::SBThreadPlan &));
     LLDB_REGISTER_METHOD(lldb_private::ThreadPlan *, SBThreadPlan, get, ());
     LLDB_REGISTER_METHOD_CONST(bool, SBThreadPlan, IsValid, ());
+    LLDB_REGISTER_METHOD_CONST(bool, SBThreadPlan, operator bool, ());
     LLDB_REGISTER_METHOD(void, SBThreadPlan, Clear, ());
     LLDB_REGISTER_METHOD(lldb::StopReason, SBThreadPlan, GetStopReason, ());
     LLDB_REGISTER_METHOD(size_t, SBThreadPlan, GetStopReasonDataCount, ());
@@ -2290,6 +2331,7 @@ SBRegistry::SBRegistry() {
     LLDB_REGISTER_METHOD(lldb::user_id_t, SBTrace, GetTraceUID, ());
     LLDB_REGISTER_CONSTRUCTOR(SBTrace, ());
     LLDB_REGISTER_METHOD(bool, SBTrace, IsValid, ());
+    LLDB_REGISTER_METHOD_CONST(bool, SBTrace, operator bool, ());
   }
   {
     LLDB_REGISTER_CONSTRUCTOR(SBTraceOptions, ());
@@ -2307,6 +2349,7 @@ SBRegistry::SBRegistry() {
     LLDB_REGISTER_METHOD(void, SBTraceOptions, setMetaDataBufferSize,
                          (uint64_t));
     LLDB_REGISTER_METHOD(bool, SBTraceOptions, IsValid, ());
+    LLDB_REGISTER_METHOD_CONST(bool, SBTraceOptions, operator bool, ());
     LLDB_REGISTER_METHOD(void, SBTraceOptions, setThreadID, (lldb::tid_t));
     LLDB_REGISTER_METHOD(lldb::tid_t, SBTraceOptions, getThreadID, ());
   }
@@ -2318,6 +2361,7 @@ SBRegistry::SBRegistry() {
     LLDB_REGISTER_METHOD(lldb::SBType &,
                          SBType, operator=,(const lldb::SBType &));
     LLDB_REGISTER_METHOD_CONST(bool, SBType, IsValid, ());
+    LLDB_REGISTER_METHOD_CONST(bool, SBType, operator bool, ());
     LLDB_REGISTER_METHOD(uint64_t, SBType, GetByteSize, ());
     LLDB_REGISTER_METHOD(bool, SBType, IsPointerType, ());
     LLDB_REGISTER_METHOD(bool, SBType, IsArrayType, ());
@@ -2371,6 +2415,7 @@ SBRegistry::SBRegistry() {
     LLDB_REGISTER_CONSTRUCTOR(SBTypeList, ());
     LLDB_REGISTER_CONSTRUCTOR(SBTypeList, (const lldb::SBTypeList &));
     LLDB_REGISTER_METHOD(bool, SBTypeList, IsValid, ());
+    LLDB_REGISTER_METHOD_CONST(bool, SBTypeList, operator bool, ());
     LLDB_REGISTER_METHOD(lldb::SBTypeList &,
                          SBTypeList, operator=,(const lldb::SBTypeList &));
     LLDB_REGISTER_METHOD(void, SBTypeList, Append, (lldb::SBType));
@@ -2381,6 +2426,7 @@ SBRegistry::SBRegistry() {
     LLDB_REGISTER_METHOD(lldb::SBTypeMember &,
                          SBTypeMember, operator=,(const lldb::SBTypeMember &));
     LLDB_REGISTER_METHOD_CONST(bool, SBTypeMember, IsValid, ());
+    LLDB_REGISTER_METHOD_CONST(bool, SBTypeMember, operator bool, ());
     LLDB_REGISTER_METHOD(const char *, SBTypeMember, GetName, ());
     LLDB_REGISTER_METHOD(lldb::SBType, SBTypeMember, GetType, ());
     LLDB_REGISTER_METHOD(uint64_t, SBTypeMember, GetOffsetInBytes, ());
@@ -2396,6 +2442,7 @@ SBRegistry::SBRegistry() {
         lldb::SBTypeMemberFunction &,
         SBTypeMemberFunction, operator=,(const lldb::SBTypeMemberFunction &));
     LLDB_REGISTER_METHOD_CONST(bool, SBTypeMemberFunction, IsValid, ());
+    LLDB_REGISTER_METHOD_CONST(bool, SBTypeMemberFunction, operator bool, ());
     LLDB_REGISTER_METHOD(const char *, SBTypeMemberFunction, GetName, ());
     LLDB_REGISTER_METHOD(const char *, SBTypeMemberFunction, GetDemangledName,
                          ());
@@ -2416,6 +2463,7 @@ SBRegistry::SBRegistry() {
     LLDB_REGISTER_CONSTRUCTOR(SBTypeCategory, ());
     LLDB_REGISTER_CONSTRUCTOR(SBTypeCategory, (const lldb::SBTypeCategory &));
     LLDB_REGISTER_METHOD_CONST(bool, SBTypeCategory, IsValid, ());
+    LLDB_REGISTER_METHOD_CONST(bool, SBTypeCategory, operator bool, ());
     LLDB_REGISTER_METHOD(bool, SBTypeCategory, GetEnabled, ());
     LLDB_REGISTER_METHOD(void, SBTypeCategory, SetEnabled, (bool));
     LLDB_REGISTER_METHOD(const char *, SBTypeCategory, GetName, ());
@@ -2488,6 +2536,7 @@ SBRegistry::SBRegistry() {
         lldb::SBTypeEnumMember &,
         SBTypeEnumMember, operator=,(const lldb::SBTypeEnumMember &));
     LLDB_REGISTER_METHOD_CONST(bool, SBTypeEnumMember, IsValid, ());
+    LLDB_REGISTER_METHOD_CONST(bool, SBTypeEnumMember, operator bool, ());
     LLDB_REGISTER_METHOD(const char *, SBTypeEnumMember, GetName, ());
     LLDB_REGISTER_METHOD(int64_t, SBTypeEnumMember, GetValueAsSigned, ());
     LLDB_REGISTER_METHOD(uint64_t, SBTypeEnumMember, GetValueAsUnsigned, ());
@@ -2496,6 +2545,7 @@ SBRegistry::SBRegistry() {
     LLDB_REGISTER_CONSTRUCTOR(SBTypeEnumMemberList,
                               (const lldb::SBTypeEnumMemberList &));
     LLDB_REGISTER_METHOD(bool, SBTypeEnumMemberList, IsValid, ());
+    LLDB_REGISTER_METHOD_CONST(bool, SBTypeEnumMemberList, operator bool, ());
     LLDB_REGISTER_METHOD(
         lldb::SBTypeEnumMemberList &,
         SBTypeEnumMemberList, operator=,(const lldb::SBTypeEnumMemberList &));
@@ -2512,6 +2562,7 @@ SBRegistry::SBRegistry() {
     LLDB_REGISTER_CONSTRUCTOR(SBTypeFilter, (uint32_t));
     LLDB_REGISTER_CONSTRUCTOR(SBTypeFilter, (const lldb::SBTypeFilter &));
     LLDB_REGISTER_METHOD_CONST(bool, SBTypeFilter, IsValid, ());
+    LLDB_REGISTER_METHOD_CONST(bool, SBTypeFilter, operator bool, ());
     LLDB_REGISTER_METHOD(uint32_t, SBTypeFilter, GetOptions, ());
     LLDB_REGISTER_METHOD(void, SBTypeFilter, SetOptions, (uint32_t));
     LLDB_REGISTER_METHOD(bool, SBTypeFilter, GetDescription,
@@ -2537,6 +2588,7 @@ SBRegistry::SBRegistry() {
     LLDB_REGISTER_CONSTRUCTOR(SBTypeFormat, (const char *, uint32_t));
     LLDB_REGISTER_CONSTRUCTOR(SBTypeFormat, (const lldb::SBTypeFormat &));
     LLDB_REGISTER_METHOD_CONST(bool, SBTypeFormat, IsValid, ());
+    LLDB_REGISTER_METHOD_CONST(bool, SBTypeFormat, operator bool, ());
     LLDB_REGISTER_METHOD(lldb::Format, SBTypeFormat, GetFormat, ());
     LLDB_REGISTER_METHOD(const char *, SBTypeFormat, GetTypeName, ());
     LLDB_REGISTER_METHOD(uint32_t, SBTypeFormat, GetOptions, ());
@@ -2558,6 +2610,7 @@ SBRegistry::SBRegistry() {
     LLDB_REGISTER_CONSTRUCTOR(SBTypeNameSpecifier,
                               (const lldb::SBTypeNameSpecifier &));
     LLDB_REGISTER_METHOD_CONST(bool, SBTypeNameSpecifier, IsValid, ());
+    LLDB_REGISTER_METHOD_CONST(bool, SBTypeNameSpecifier, operator bool, ());
     LLDB_REGISTER_METHOD(const char *, SBTypeNameSpecifier, GetName, ());
     LLDB_REGISTER_METHOD(lldb::SBType, SBTypeNameSpecifier, GetType, ());
     LLDB_REGISTER_METHOD(bool, SBTypeNameSpecifier, IsRegex, ());
@@ -2578,6 +2631,7 @@ SBRegistry::SBRegistry() {
     LLDB_REGISTER_CONSTRUCTOR(SBTypeSummaryOptions,
                               (const lldb::SBTypeSummaryOptions &));
     LLDB_REGISTER_METHOD(bool, SBTypeSummaryOptions, IsValid, ());
+    LLDB_REGISTER_METHOD_CONST(bool, SBTypeSummaryOptions, operator bool, ());
     LLDB_REGISTER_METHOD(lldb::LanguageType, SBTypeSummaryOptions, GetLanguage,
                          ());
     LLDB_REGISTER_METHOD(lldb::TypeSummaryCapping, SBTypeSummaryOptions,
@@ -2599,6 +2653,7 @@ SBRegistry::SBRegistry() {
                                 CreateWithScriptCode, (const char *, uint32_t));
     LLDB_REGISTER_CONSTRUCTOR(SBTypeSummary, (const lldb::SBTypeSummary &));
     LLDB_REGISTER_METHOD_CONST(bool, SBTypeSummary, IsValid, ());
+    LLDB_REGISTER_METHOD_CONST(bool, SBTypeSummary, operator bool, ());
     LLDB_REGISTER_METHOD(bool, SBTypeSummary, IsFunctionCode, ());
     LLDB_REGISTER_METHOD(bool, SBTypeSummary, IsFunctionName, ());
     LLDB_REGISTER_METHOD(bool, SBTypeSummary, IsSummaryString, ());
@@ -2630,6 +2685,7 @@ SBRegistry::SBRegistry() {
                                 CreateWithScriptCode, (const char *, uint32_t));
     LLDB_REGISTER_CONSTRUCTOR(SBTypeSynthetic, (const lldb::SBTypeSynthetic &));
     LLDB_REGISTER_METHOD_CONST(bool, SBTypeSynthetic, IsValid, ());
+    LLDB_REGISTER_METHOD_CONST(bool, SBTypeSynthetic, operator bool, ());
     LLDB_REGISTER_METHOD(bool, SBTypeSynthetic, IsClassCode, ());
     LLDB_REGISTER_METHOD(bool, SBTypeSynthetic, IsClassName, ());
     LLDB_REGISTER_METHOD(const char *, SBTypeSynthetic, GetData, ());
@@ -2658,6 +2714,7 @@ SBRegistry::SBRegistry() {
         SBUnixSignals, operator=,(const lldb::SBUnixSignals &));
     LLDB_REGISTER_METHOD(void, SBUnixSignals, Clear, ());
     LLDB_REGISTER_METHOD_CONST(bool, SBUnixSignals, IsValid, ());
+    LLDB_REGISTER_METHOD_CONST(bool, SBUnixSignals, operator bool, ());
     LLDB_REGISTER_METHOD_CONST(const char *, SBUnixSignals, GetSignalAsCString,
                                (int32_t));
     LLDB_REGISTER_METHOD_CONST(int32_t, SBUnixSignals, GetSignalNumberFromName,
@@ -2681,6 +2738,7 @@ SBRegistry::SBRegistry() {
     LLDB_REGISTER_METHOD(lldb::SBValue &,
                          SBValue, operator=,(const lldb::SBValue &));
     LLDB_REGISTER_METHOD(bool, SBValue, IsValid, ());
+    LLDB_REGISTER_METHOD_CONST(bool, SBValue, operator bool, ());
     LLDB_REGISTER_METHOD(void, SBValue, Clear, ());
     LLDB_REGISTER_METHOD(lldb::SBError, SBValue, GetError, ());
     LLDB_REGISTER_METHOD(lldb::user_id_t, SBValue, GetID, ());
@@ -2798,6 +2856,7 @@ SBRegistry::SBRegistry() {
     LLDB_REGISTER_CONSTRUCTOR(SBValueList, ());
     LLDB_REGISTER_CONSTRUCTOR(SBValueList, (const lldb::SBValueList &));
     LLDB_REGISTER_METHOD_CONST(bool, SBValueList, IsValid, ());
+    LLDB_REGISTER_METHOD_CONST(bool, SBValueList, operator bool, ());
     LLDB_REGISTER_METHOD(void, SBValueList, Clear, ());
     LLDB_REGISTER_METHOD(const lldb::SBValueList &,
                          SBValueList, operator=,(const lldb::SBValueList &));
@@ -2820,6 +2879,7 @@ SBRegistry::SBRegistry() {
         lldb::SBVariablesOptions &,
         SBVariablesOptions, operator=,(const lldb::SBVariablesOptions &));
     LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions, IsValid, ());
+    LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions, operator bool, ());
     LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions, GetIncludeArguments,
                                ());
     LLDB_REGISTER_METHOD(void, SBVariablesOptions, SetIncludeArguments, (bool));
@@ -2851,6 +2911,7 @@ SBRegistry::SBRegistry() {
                          SBWatchpoint, operator=,(const lldb::SBWatchpoint &));
     LLDB_REGISTER_METHOD(lldb::watch_id_t, SBWatchpoint, GetID, ());
     LLDB_REGISTER_METHOD_CONST(bool, SBWatchpoint, IsValid, ());
+    LLDB_REGISTER_METHOD_CONST(bool, SBWatchpoint, operator bool, ());
     LLDB_REGISTER_METHOD(lldb::SBError, SBWatchpoint, GetError, ());
     LLDB_REGISTER_METHOD(int32_t, SBWatchpoint, GetHardwareIndex, ());
     LLDB_REGISTER_METHOD(lldb::addr_t, SBWatchpoint, GetWatchAddress, ());