Add "operator bool" to SB APIs

[labath]

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.

[shafik]

It stood out to me that some of the conversions were not const and I can see that IsValid is not consistently const across the API but after talking to @jingham it is unfortunately something we can't change.

[labath]

In D58792#1414191, @shafik wrote:

It stood out to me that some of the conversions were not const and I can see that IsValid is not consistently const across the API but after talking to @jingham it is unfortunately something we can't change.

Yes, that is unfortunate. I can think of three things that we could do differently though:

1. add a const version of IsValid where it is missing, and have and always-const operator bool which uses that
2. give up on constness and just have a non-const operator bool everywhere
3. add a const operator bool everywhere, and have IsValid (const or non-const) call into that

Each option has different tradeoffs, and it's not really clear to me which one is better. I am happy to implement whichever you think is best.

[clayborg]

In D58792#1414964, @labath wrote:

In D58792#1414191, @shafik wrote:

It stood out to me that some of the conversions were not const and I can see that IsValid is not consistently const across the API but after talking to @jingham it is unfortunately something we can't change.

Yes, that is unfortunate. I can think of three things that we could do differently though:

1. add a const version of IsValid where it is missing, and have and always-const operator bool which uses that
2. give up on constness and just have a non-const operator bool everywhere
3. add a const operator bool everywhere, and have IsValid (const or non-const) call into that

"const" is useless when your class contains a shared pointer or a unique pointer. It also changes the API mangling which we can't do. So I vote for give up on const as you can call non const methods in any shared and unique pointers because const is only protecting the pointer from changing.

Each option has different tradeoffs, and it's not really clear to me which one is better. I am happy to implement whichever you think is best.

[labath]

Give up on constness and make all bool operators non-const.

[shafik]

In D58792#1415390, @clayborg wrote:

In D58792#1414964, @labath wrote:

In D58792#1414191, @shafik wrote:

It stood out to me that some of the conversions were not const and I can see that IsValid is not consistently const across the API but after talking to @jingham it is unfortunately something we can't change.

Yes, that is unfortunate. I can think of three things that we could do differently though:

1. add a const version of IsValid where it is missing, and have and always-const operator bool which uses that
2. give up on constness and just have a non-const operator bool everywhere
3. add a const operator bool everywhere, and have IsValid (const or non-const) call into that

"const" is useless when your class contains a shared pointer or a unique pointer. It also changes the API mangling which we can't do. So I vote for give up on const as you can call non const methods in any shared and unique pointers because const is only protecting the pointer from changing.

Each option has different tradeoffs, and it's not really clear to me which one is better. I am happy to implement whichever you think is best.

The goal of const is to communicate to the user that it does not mutate the underlying object, which in general is good practice to maintain if possible.

In this case I don't see any good trade-offs here. I don't feel like adding a const version along w/ a non-const version really helps since it still muddies the waters.

[zturner]

Out of curiosity, are there known, specific examples of users who rely on the exact mangling not changing?

[clayborg]

If this is new API I guess it is ok to have them all be const. I was mostly worried that you wouldn't be able to call a non const function from a const function. Do we have any IsValid() calls that are const? I believe we do. If so, how are we calling IsValid() if it is const from a non const conversion operator?

[jingham]

In D58792#1415629, @zturner wrote:

Out of curiosity, are there known, specific examples of users who rely on the exact mangling not changing?

Yes, both Xcode and lldb-rpc-server (an out-of-process dingus we made for Xcode) build against some particular version of the SB headers, but then expect to be able to load many different versions of LLDB.framework.

[clayborg]

In D58792#1415629, @zturner wrote:

Out of curiosity, are there known, specific examples of users who rely on the exact mangling not changing?

yes. Xcode. For Swift, Xcode runs the LLDBRPC.framework in process which runs lldb-rpc-server out of process with the DYLD_FRAMEWORK_PATH set to the directory that contains the LLDB.framework that lldb-rpc-server wants to run with. API is very important and without it this would not have been possible. So API is very important.

That being said, at some point we should make a lldb2 namespace and make a liblldb2.so and cull out all of the fluff we are keeping in there and get down to the exact API we want. We can then change things to be const where needed. remove redundant calls. In the name of backward compatibility we have functions that didn't return an error which now do so we have two versions of similar cal, one with error reporting and one without. Or the 5 flavors of CreateTarget in SBDebugger. There are many others. So at some point it would be nice to go through and reduce and improve the API. That will take time though cause if we do it, we should get it right.

[jingham]

In D58792#1415645, @clayborg wrote:

In D58792#1415629, @zturner wrote:

Out of curiosity, are there known, specific examples of users who rely on the exact mangling not changing?

yes. Xcode. For Swift, Xcode runs the LLDBRPC.framework in process which runs lldb-rpc-server out of process with the DYLD_FRAMEWORK_PATH set to the directory that contains the LLDB.framework that lldb-rpc-server wants to run with. API is very important and without it this would not have been possible. So API is very important.

That being said, at some point we should make a lldb2 namespace and make a liblldb2.so and cull out all of the fluff we are keeping in there and get down to the exact API we want. We can then change things to be const where needed. remove redundant calls. In the name of backward compatibility we have functions that didn't return an error which now do so we have two versions of similar cal, one with error reporting and one without. Or the 5 flavors of CreateTarget in SBDebugger. There are many others. So at some point it would be nice to go through and reduce and improve the API. That will take time though cause if we do it, we should get it right.

This would be a fun project, however we should not design this by ourselves. Though we are responsible for the SB API, and those of us who write dotest tests frequently use it some, I bet none of us has written a big application using it. Greg's probably the closest, with the heap.py and so forth scripts. However, there are folks out there who have used it extensively. At Apple, the kernel folks have written a pretty big set of utilities based on the Python API's, and of course the Xcode folks have done so using the C++ API's as well. And there are likely other folks around who have been using it more extensively. We could learn a lot from them.

Another really good way to drive the design process by actual example would be to take the opportunity of coming up with the SB2 API's to rewrite everything in source/Commands on top of the new API's. There are other reasons for doing this (removing duplicated code and testability) but I'm also sure we'd get a lot of good insights into how the design should go doing that.

[labath]

The version which makes "operator bool" const.

[labath]

In D58792#1415631, @clayborg wrote:

If this is new API I guess it is ok to have them all be const. I was mostly worried that you wouldn't be able to call a non const function from a const function. Do we have any IsValid() calls that are const? I believe we do. If so, how are we calling IsValid() if it is const from a non const conversion operator?

The easiest way to fix that is to invert the calling direction. We can make the "operator bool" (which I guess we have agreed we want to be const?) contain the "canonical" implementation of the validity check, and then have the IsValid function (const or non-const) call into that. Since the bool operator will always be const, this will work regardless of whether the IsValid operation is declared to be const or not. If we then wanted to, we could make the "IsValid" function deprecated and remove it in the hypothetical v2 API.

That latest version of the patch implements that idea (the first part of it, the APIv2 thingy is just an idea).

lldb/trunk/include/lldb/API/SBAddress.h

public:
 
   // Create an address by resolving a load address using the supplied target
   SBAddress(lldb::addr_t load_addr, lldb::SBTarget &target);
 
   ~SBAddress();
 
   const lldb::SBAddress &operator=(const lldb::SBAddress &rhs);
 
+  explicit operator bool() const;
+
   bool IsValid() const;
 
   void Clear();
 
   addr_t GetFileAddress() const;
 
   addr_t GetLoadAddress(const lldb::SBTarget &target) const;
 

lldb/trunk/include/lldb/API/SBBlock.h

public:
   SBBlock(const lldb::SBBlock &rhs);
 
   ~SBBlock();
 
   const lldb::SBBlock &operator=(const lldb::SBBlock &rhs);
 
   bool IsInlined() const;
 
+  explicit operator bool() const;
+
   bool IsValid() const;
 
   const char *GetInlinedName() const;
 
   lldb::SBFileSpec GetInlinedCallSiteFile() const;
 
   uint32_t GetInlinedCallSiteLine() const;
 

lldb/trunk/include/lldb/API/SBBreakpoint.h

public:
   // Tests to see if the opaque breakpoint object in this object matches the
   // opaque breakpoint object in "rhs".
   bool operator==(const lldb::SBBreakpoint &rhs);
 
   bool operator!=(const lldb::SBBreakpoint &rhs);
 
   break_id_t GetID() const;
 
+  explicit operator bool() const;
+
   bool IsValid() const;
 
   void ClearAllBreakpointSites();
 
   lldb::SBBreakpointLocation FindLocationByAddress(lldb::addr_t vm_addr);
 
   lldb::break_id_t FindLocationIDByAddress(lldb::addr_t vm_addr);
 

lldb/trunk/include/lldb/API/SBBreakpointLocation.h

public:
 
   ~SBBreakpointLocation();
 
   const lldb::SBBreakpointLocation &
   operator=(const lldb::SBBreakpointLocation &rhs);
 
   break_id_t GetID();
 
+  explicit operator bool() const;
+
   bool IsValid() const;
 
   lldb::SBAddress GetAddress();
 
   lldb::addr_t GetLoadAddress();
 
   void SetEnabled(bool enabled);
 

lldb/trunk/include/lldb/API/SBBreakpointName.h

//                                        lldb::SBBreakpointLocation &location);
   const lldb::SBBreakpointName &operator=(const lldb::SBBreakpointName &rhs);
 
   // Tests to see if the opaque breakpoint object in this object matches the
   // opaque breakpoint object in "rhs".
   bool operator==(const lldb::SBBreakpointName &rhs);
 
   bool operator!=(const lldb::SBBreakpointName &rhs);
 
+  explicit operator bool() const;
+
   bool IsValid() const;
   
   const char *GetName() const;
 
   void SetEnabled(bool enable);
 
   bool IsEnabled();
 

lldb/trunk/include/lldb/API/SBBroadcaster.h

public:
   SBBroadcaster(const char *name);
 
   SBBroadcaster(const SBBroadcaster &rhs);
 
   const SBBroadcaster &operator=(const SBBroadcaster &rhs);
 
   ~SBBroadcaster();
 
+  explicit operator bool() const;
+
   bool IsValid() const;
 
   void Clear();
 
   void BroadcastEventByType(uint32_t event_type, bool unique = false);
 
   void BroadcastEvent(const lldb::SBEvent &event, bool unique = false);
 

lldb/trunk/include/lldb/API/SBCommandInterpreter.h

public:
   static const char *
   GetArgumentTypeAsCString(const lldb::CommandArgumentType arg_type);
 
   static const char *
   GetArgumentDescriptionAsCString(const lldb::CommandArgumentType arg_type);
 
   static bool EventIsCommandInterpreterEvent(const lldb::SBEvent &event);
 
+  explicit operator bool() const;
+
   bool IsValid() const;
 
   bool CommandExists(const char *cmd);
 
   bool AliasExists(const char *cmd);
 
   lldb::SBBroadcaster GetBroadcaster();
 
virtual bool DoExecute(lldb::SBDebugger /*debugger*/, char ** /*command*/,
     return false;
   }
 };
 
 class SBCommand {
 public:
   SBCommand();
 
+  explicit operator bool() const;
+
   bool IsValid();
 
   const char *GetName();
 
   const char *GetHelp();
 
   const char *GetHelpLong();
 

lldb/trunk/include/lldb/API/SBCommandReturnObject.h

public:
 
   const lldb::SBCommandReturnObject &
   operator=(const lldb::SBCommandReturnObject &rhs);
 
   SBCommandReturnObject(lldb_private::CommandReturnObject *ptr);
 
   lldb_private::CommandReturnObject *Release();
 
+  explicit operator bool() const;
+
   bool IsValid() const;
 
   const char *GetOutput();
 
   const char *GetError();
 
   size_t PutOutput(FILE *fh);
 

lldb/trunk/include/lldb/API/SBCommunication.h

public:
 
   typedef void (*ReadThreadBytesReceived)(void *baton, const void *src,
                                           size_t src_len);
 
   SBCommunication();
   SBCommunication(const char *broadcaster_name);
   ~SBCommunication();
 
+  explicit operator bool() const;
+
   bool IsValid() const;
 
   lldb::SBBroadcaster GetBroadcaster();
 
   static const char *GetBroadcasterClass();
 
   lldb::ConnectionStatus AdoptFileDesriptor(int fd, bool owns_fd);
 

lldb/trunk/include/lldb/API/SBCompileUnit.h

public:
   SBCompileUnit();
 
   SBCompileUnit(const lldb::SBCompileUnit &rhs);
 
   ~SBCompileUnit();
 
   const lldb::SBCompileUnit &operator=(const lldb::SBCompileUnit &rhs);
 
+  explicit operator bool() const;
+
   bool IsValid() const;
 
   lldb::SBFileSpec GetFileSpec() const;
 
   uint32_t GetNumLineEntries() const;
 
   lldb::SBLineEntry GetLineEntryAtIndex(uint32_t idx) const;
 

lldb/trunk/include/lldb/API/SBData.h

public:
   ~SBData();
 
   uint8_t GetAddressByteSize();
 
   void SetAddressByteSize(uint8_t addr_byte_size);
 
   void Clear();
 
+  explicit operator bool() const;
+
   bool IsValid();
 
   size_t GetByteSize();
 
   lldb::ByteOrder GetByteOrder();
 
   void SetByteOrder(lldb::ByteOrder endian);
 

lldb/trunk/include/lldb/API/SBDebugger.h

public:
   static lldb::SBDebugger Create(bool source_init_files,
                                  lldb::LogOutputCallback log_callback,
                                  void *baton);
 
   static void Destroy(lldb::SBDebugger &debugger);
 
   static void MemoryPressureDetected();
 
+  explicit operator bool() const;
+
   bool IsValid() const;
 
   void Clear();
 
   void SetAsync(bool b);
 
   bool GetAsync();
 

lldb/trunk/include/lldb/API/SBDeclaration.h

public:
   SBDeclaration();
 
   SBDeclaration(const lldb::SBDeclaration &rhs);
 
   ~SBDeclaration();
 
   const lldb::SBDeclaration &operator=(const lldb::SBDeclaration &rhs);
 
+  explicit operator bool() const;
+
   bool IsValid() const;
 
   lldb::SBFileSpec GetFileSpec() const;
 
   uint32_t GetLine() const;
 
   uint32_t GetColumn() const;
 

lldb/trunk/include/lldb/API/SBError.h

public:
 
   void SetErrorToGenericError();
 
   void SetErrorString(const char *err_str);
 
   int SetErrorStringWithFormat(const char *format, ...)
       __attribute__((format(printf, 2, 3)));
 
+  explicit operator bool() const;
+
   bool IsValid() const;
 
   bool GetDescription(lldb::SBStream &description);
 
 protected:
   friend class SBBreakpoint;
   friend class SBBreakpointLocation;
   friend class SBBreakpointName;

lldb/trunk/include/lldb/API/SBEvent.h

public:
   SBEvent(lldb::EventSP &event_sp);
 
   SBEvent(lldb_private::Event *event_sp);
 
   ~SBEvent();
 
   const SBEvent &operator=(const lldb::SBEvent &rhs);
 
+  explicit operator bool() const;
+
   bool IsValid() const;
 
   const char *GetDataFlavor();
 
   uint32_t GetType() const;
 
   lldb::SBBroadcaster GetBroadcaster() const;
 

lldb/trunk/include/lldb/API/SBFileSpec.h

SBFileSpec(const char *path); // Deprecated, use SBFileSpec (const char *path,
                                 // bool resolve)
 
   SBFileSpec(const char *path, bool resolve);
 
   ~SBFileSpec();
 
   const SBFileSpec &operator=(const lldb::SBFileSpec &rhs);
 
+  explicit operator bool() const;
+
   bool IsValid() const;
 
   bool Exists() const;
 
   bool ResolveExecutableLocation();
 
   const char *GetFilename() const;
 

lldb/trunk/include/lldb/API/SBFrame.h

public:
   SBFrame(const lldb::SBFrame &rhs);
 
   const lldb::SBFrame &operator=(const lldb::SBFrame &rhs);
 
   ~SBFrame();
 
   bool IsEqual(const lldb::SBFrame &that) const;
 
+  explicit operator bool() const;
+
   bool IsValid() const;
 
   uint32_t GetFrameID() const;
 
   lldb::addr_t GetCFA() const;
 
   lldb::addr_t GetPC() const;
 

lldb/trunk/include/lldb/API/SBFunction.h

public:
   SBFunction();
 
   SBFunction(const lldb::SBFunction &rhs);
 
   const lldb::SBFunction &operator=(const lldb::SBFunction &rhs);
 
   ~SBFunction();
 
+  explicit operator bool() const;
+
   bool IsValid() const;
 
   const char *GetName() const;
 
   const char *GetDisplayName() const;
 
   const char *GetMangledName() const;
 

lldb/trunk/include/lldb/API/SBInstruction.h

public:
   SBInstruction();
 
   SBInstruction(const SBInstruction &rhs);
 
   const SBInstruction &operator=(const SBInstruction &rhs);
 
   ~SBInstruction();
 
+  explicit operator bool() const;
+
   bool IsValid();
 
   SBAddress GetAddress();
 
   const char *GetMnemonic(lldb::SBTarget target);
 
   const char *GetOperands(lldb::SBTarget target);
 

lldb/trunk/include/lldb/API/SBInstructionList.h

public:
   SBInstructionList();
 
   SBInstructionList(const SBInstructionList &rhs);
 
   const SBInstructionList &operator=(const SBInstructionList &rhs);
 
   ~SBInstructionList();
 
+  explicit operator bool() const;
+
   bool IsValid() const;
 
   size_t GetSize();
 
   lldb::SBInstruction GetInstructionAtIndex(uint32_t idx);
 
   // ----------------------------------------------------------------------
   // Returns the number of instructions between the start and end address. If

lldb/trunk/include/lldb/API/SBLineEntry.h

public:
   ~SBLineEntry();
 
   const lldb::SBLineEntry &operator=(const lldb::SBLineEntry &rhs);
 
   lldb::SBAddress GetStartAddress() const;
 
   lldb::SBAddress GetEndAddress() const;
 
+  explicit operator bool() const;
+
   bool IsValid() const;
 
   lldb::SBFileSpec GetFileSpec() const;
 
   uint32_t GetLine() const;
 
   uint32_t GetColumn() const;
 

lldb/trunk/include/lldb/API/SBListener.h

public:
   ~SBListener();
 
   const lldb::SBListener &operator=(const lldb::SBListener &rhs);
 
   void AddEvent(const lldb::SBEvent &event);
 
   void Clear();
 
+  explicit operator bool() const;
+
   bool IsValid() const;
 
   uint32_t StartListeningForEventClass(SBDebugger &debugger,
                                        const char *broadcaster_class,
                                        uint32_t event_mask);
 
   bool StopListeningForEventClass(SBDebugger &debugger,
                                   const char *broadcaster_class,

lldb/trunk/include/lldb/API/SBModule.h

public:
   SBModule(const SBModuleSpec &module_spec);
 
   const SBModule &operator=(const SBModule &rhs);
 
   SBModule(lldb::SBProcess &process, lldb::addr_t header_addr);
 
   ~SBModule();
 
+  explicit operator bool() const;
+
   bool IsValid() const;
 
   void Clear();
 
   //------------------------------------------------------------------
   /// Get const accessor for the module file specification.
   ///
   /// This function returns the file for the module on the host system

lldb/trunk/include/lldb/API/SBModuleSpec.h

public:
   SBModuleSpec();
 
   SBModuleSpec(const SBModuleSpec &rhs);
 
   ~SBModuleSpec();
 
   const SBModuleSpec &operator=(const SBModuleSpec &rhs);
 
+  explicit operator bool() const;
+
   bool IsValid() const;
 
   void Clear();
 
   //------------------------------------------------------------------
   /// Get const accessor for the module file.
   ///
   /// This function returns the file for the module on the host system

lldb/trunk/include/lldb/API/SBPlatform.h

 class LLDB_API SBPlatform {
 public:
   SBPlatform();
 
   SBPlatform(const char *platform_name);
 
   ~SBPlatform();
 
+  explicit operator bool() const;
+
   bool IsValid() const;
 
   void Clear();
 
   const char *GetWorkingDirectory();
 
   bool SetWorkingDirectory(const char *path);
 

lldb/trunk/include/lldb/API/SBProcess.h

public:
 
   const char *GetPluginName();
 
   // DEPRECATED: use GetPluginName()
   const char *GetShortPluginName();
 
   void Clear();
 
+  explicit operator bool() const;
+
   bool IsValid() const;
 
   lldb::SBTarget GetTarget() const;
 
   lldb::ByteOrder GetByteOrder() const;
 
   size_t PutSTDIN(const char *src, size_t src_len);
 

lldb/trunk/include/lldb/API/SBProcessInfo.h

 public:
   SBProcessInfo();
   SBProcessInfo(const SBProcessInfo &rhs);
 
   ~SBProcessInfo();
 
   SBProcessInfo &operator=(const SBProcessInfo &rhs);
 
+  explicit operator bool() const;
+
   bool IsValid() const;
 
   const char *GetName();
 
   SBFileSpec GetExecutableFile();
 
   lldb::pid_t GetProcessID();
 

lldb/trunk/include/lldb/API/SBQueue.h

public:
   SBQueue(const QueueSP &queue_sp);
 
   SBQueue(const SBQueue &rhs);
 
   const SBQueue &operator=(const lldb::SBQueue &rhs);
 
   ~SBQueue();
 
+  explicit operator bool() const;
+
   bool IsValid() const;
 
   void Clear();
 
   lldb::SBProcess GetProcess();
 
   lldb::queue_id_t GetQueueID() const;
 

lldb/trunk/include/lldb/API/SBQueueItem.h

 class LLDB_API SBQueueItem {
 public:
   SBQueueItem();
 
   SBQueueItem(const lldb::QueueItemSP &queue_item_sp);
 
   ~SBQueueItem();
 
+  explicit operator bool() const;
+
   bool IsValid() const;
 
   void Clear();
 
   lldb::QueueItemKind GetKind() const;
 
   void SetKind(lldb::QueueItemKind kind);
 

lldb/trunk/include/lldb/API/SBSection.h

public:
   SBSection();
 
   SBSection(const lldb::SBSection &rhs);
 
   ~SBSection();
 
   const lldb::SBSection &operator=(const lldb::SBSection &rhs);
 
+  explicit operator bool() const;
+
   bool IsValid() const;
 
   const char *GetName();
 
   lldb::SBSection GetParent();
 
   lldb::SBSection FindSubSection(const char *sect_name);
 

lldb/trunk/include/lldb/API/SBStream.h

 class LLDB_API SBStream {
 public:
   SBStream();
 
   SBStream(SBStream &&rhs);
 
   ~SBStream();
 
+  explicit operator bool() const;
+
   bool IsValid() const;
 
   // If this stream is not redirected to a file, it will maintain a local cache
   // for the stream data which can be accessed using this accessor.
   const char *GetData();
 
   // If this stream is not redirected to a file, it will maintain a local cache
   // for the stream output whose length can be accessed using this accessor.

lldb/trunk/include/lldb/API/SBStringList.h

public:
   SBStringList();
 
   SBStringList(const lldb::SBStringList &rhs);
 
   const SBStringList &operator=(const SBStringList &rhs);
 
   ~SBStringList();
 
+  explicit operator bool() const;
+
   bool IsValid() const;
 
   void AppendString(const char *str);
 
   void AppendList(const char **strv, int strc);
 
   void AppendList(const lldb::SBStringList &strings);
 

lldb/trunk/include/lldb/API/SBStructuredData.h

public:
   SBStructuredData(const lldb::EventSP &event_sp);
   
   SBStructuredData(lldb_private::StructuredDataImpl *impl);
 
   ~SBStructuredData();
 
   lldb::SBStructuredData &operator=(const lldb::SBStructuredData &rhs);
 
+  explicit operator bool() const;
+
   bool IsValid() const;
 
   lldb::SBError SetFromJSON(lldb::SBStream &stream);
 
   void Clear();
 
   lldb::SBError GetAsJSON(lldb::SBStream &stream) const;
 

lldb/trunk/include/lldb/API/SBSymbol.h

public:
   SBSymbol();
 
   ~SBSymbol();
 
   SBSymbol(const lldb::SBSymbol &rhs);
 
   const lldb::SBSymbol &operator=(const lldb::SBSymbol &rhs);
 
+  explicit operator bool() const;
+
   bool IsValid() const;
 
   const char *GetName() const;
 
   const char *GetDisplayName() const;
 
   const char *GetMangledName() const;
 

lldb/trunk/include/lldb/API/SBSymbolContext.h

public:
   SBSymbolContext();
 
   SBSymbolContext(const lldb::SBSymbolContext &rhs);
 
   SBSymbolContext(const lldb_private::SymbolContext *sc_ptr);
 
   ~SBSymbolContext();
 
+  explicit operator bool() const;
+
   bool IsValid() const;
 
   const lldb::SBSymbolContext &operator=(const lldb::SBSymbolContext &rhs);
 
   lldb::SBModule GetModule();
   lldb::SBCompileUnit GetCompileUnit();
   lldb::SBFunction GetFunction();
   lldb::SBBlock GetBlock();

lldb/trunk/include/lldb/API/SBSymbolContextList.h

public:
 
   SBSymbolContextList(const lldb::SBSymbolContextList &rhs);
 
   ~SBSymbolContextList();
 
   const lldb::SBSymbolContextList &
   operator=(const lldb::SBSymbolContextList &rhs);
 
+  explicit operator bool() const;
+
   bool IsValid() const;
 
   uint32_t GetSize() const;
 
   lldb::SBSymbolContext GetContextAtIndex(uint32_t idx);
 
   bool GetDescription(lldb::SBStream &description);
 

lldb/trunk/include/lldb/API/SBTarget.h

public:
 
   //------------------------------------------------------------------
   // Destructor
   //------------------------------------------------------------------
   ~SBTarget();
 
   const lldb::SBTarget &operator=(const lldb::SBTarget &rhs);
 
+  explicit operator bool() const;
+
   bool IsValid() const;
 
   static bool EventIsTargetEvent(const lldb::SBEvent &event);
 
   static lldb::SBTarget GetTargetFromEvent(const lldb::SBEvent &event);
 
   static uint32_t GetNumModulesFromEvent(const lldb::SBEvent &event);
 

lldb/trunk/include/lldb/API/SBThread.h

public:
   SBThread(const lldb::SBThread &thread);
 
   SBThread(const lldb::ThreadSP &lldb_object_sp);
 
   ~SBThread();
 
   lldb::SBQueue GetQueue() const;
 
+  explicit operator bool() const;
+
   bool IsValid() const;
 
   void Clear();
 
   lldb::StopReason GetStopReason();
 
   /// Get the number of words associated with the stop reason.
   /// See also GetStopReasonDataAtIndex().

lldb/trunk/include/lldb/API/SBThreadCollection.h

public:
   SBThreadCollection();
 
   SBThreadCollection(const SBThreadCollection &rhs);
 
   const SBThreadCollection &operator=(const SBThreadCollection &rhs);
 
   ~SBThreadCollection();
 
+  explicit operator bool() const;
+
   bool IsValid() const;
 
   size_t GetSize();
 
   lldb::SBThread GetThreadAtIndex(size_t idx);
 
 protected:
   // Mimic shared pointer...

lldb/trunk/include/lldb/API/SBThreadPlan.h

public:
   SBThreadPlan(const lldb::SBThreadPlan &threadPlan);
 
   SBThreadPlan(const lldb::ThreadPlanSP &lldb_object_sp);
 
   SBThreadPlan(lldb::SBThread &thread, const char *class_name);
 
   ~SBThreadPlan();
 
+  explicit operator bool() const;
+
   bool IsValid() const;
 
   void Clear();
 
   lldb::StopReason GetStopReason();
 
   /// Get the number of words associated with the stop reason.
   /// See also GetStopReasonDataAtIndex().

lldb/trunk/include/lldb/API/SBTrace.h

public:
   ///
   /// @param[out] error
   ///     An error explaining what went wrong.
   //------------------------------------------------------------------
   void GetTraceConfig(SBTraceOptions &options, SBError &error);
 
   lldb::user_id_t GetTraceUID();
 
+  explicit operator bool() const;
+
   bool IsValid();
 
 protected:
   typedef std::shared_ptr<TraceImpl> TraceImplSP;
 
   friend class SBProcess;
 
   void SetTraceUID(lldb::user_id_t uid);

lldb/trunk/include/lldb/API/SBTraceOptions.h

public:
   void setTraceBufferSize(uint64_t size);
 
   void setMetaDataBufferSize(uint64_t size);
 
   void setThreadID(lldb::tid_t thread_id);
 
   lldb::tid_t getThreadID();
 
+  explicit operator bool() const;
+
   bool IsValid();
 
 protected:
   friend class SBProcess;
   friend class SBTrace;
 
   lldb::TraceOptionsSP m_traceoptions_sp;
 };
 }
 
 #endif /* SBTRACEOPTIONS_H_ */

lldb/trunk/include/lldb/API/SBType.h

public:
   SBTypeMember();
 
   SBTypeMember(const lldb::SBTypeMember &rhs);
 
   ~SBTypeMember();
 
   lldb::SBTypeMember &operator=(const lldb::SBTypeMember &rhs);
 
+  explicit operator bool() const;
+
   bool IsValid() const;
 
   const char *GetName();
 
   lldb::SBType GetType();
 
   uint64_t GetOffsetInBytes();
 
public:
   SBTypeMemberFunction();
 
   SBTypeMemberFunction(const lldb::SBTypeMemberFunction &rhs);
 
   ~SBTypeMemberFunction();
 
   lldb::SBTypeMemberFunction &operator=(const lldb::SBTypeMemberFunction &rhs);
 
+  explicit operator bool() const;
+
   bool IsValid() const;
 
   const char *GetName();
 
   const char *GetDemangledName();
 
   const char *GetMangledName();
 

 class SBType {
 public:
   SBType();
 
   SBType(const lldb::SBType &rhs);
 
   ~SBType();
 
+  explicit operator bool() const;
+
   bool IsValid() const;
 
   uint64_t GetByteSize();
 
   bool IsPointerType();
 
   bool IsReferenceType();
 
public:
   SBTypeList();
 
   SBTypeList(const lldb::SBTypeList &rhs);
 
   ~SBTypeList();
 
   lldb::SBTypeList &operator=(const lldb::SBTypeList &rhs);
 
+  explicit operator bool() const;
+
   bool IsValid();
 
   void Append(lldb::SBType type);
 
   lldb::SBType GetTypeAtIndex(uint32_t index);
 
   uint32_t GetSize();
 

lldb/trunk/include/lldb/API/SBTypeCategory.h

 class LLDB_API SBTypeCategory {
 public:
   SBTypeCategory();
 
   SBTypeCategory(const lldb::SBTypeCategory &rhs);
 
   ~SBTypeCategory();
 
+  explicit operator bool() const;
+
   bool IsValid() const;
 
   bool GetEnabled();
 
   void SetEnabled(bool);
 
   const char *GetName();
 

lldb/trunk/include/lldb/API/SBTypeEnumMember.h

public:
   SBTypeEnumMember();
 
   SBTypeEnumMember(const SBTypeEnumMember &rhs);
 
   ~SBTypeEnumMember();
 
   SBTypeEnumMember &operator=(const SBTypeEnumMember &rhs);
 
+  explicit operator bool() const;
+
   bool IsValid() const;
 
   int64_t GetValueAsSigned();
 
   uint64_t GetValueAsUnsigned();
 
   const char *GetName();
 
public:
   SBTypeEnumMemberList();
 
   SBTypeEnumMemberList(const SBTypeEnumMemberList &rhs);
 
   ~SBTypeEnumMemberList();
 
   SBTypeEnumMemberList &operator=(const SBTypeEnumMemberList &rhs);
 
+  explicit operator bool() const;
+
   bool IsValid();
 
   void Append(SBTypeEnumMember entry);
 
   SBTypeEnumMember GetTypeEnumMemberAtIndex(uint32_t index);
 
   uint32_t GetSize();
 
 private:
   std::unique_ptr<lldb_private::TypeEnumMemberListImpl> m_opaque_up;
 };
 
 } // namespace lldb
 
 #endif // LLDB_SBTypeEnumMember_h_

lldb/trunk/include/lldb/API/SBTypeFilter.h

public:
   SBTypeFilter();
 
   SBTypeFilter(uint32_t options); // see lldb::eTypeOption values
 
   SBTypeFilter(const lldb::SBTypeFilter &rhs);
 
   ~SBTypeFilter();
 
+  explicit operator bool() const;
+
   bool IsValid() const;
 
   uint32_t GetNumberOfExpressionPaths();
 
   const char *GetExpressionPathAtIndex(uint32_t i);
 
   bool ReplaceExpressionPathAtIndex(uint32_t i, const char *item);
 

lldb/trunk/include/lldb/API/SBTypeFormat.h

public:
 
   SBTypeFormat(const char *type,
                uint32_t options = 0); // see lldb::eTypeOption values
 
   SBTypeFormat(const lldb::SBTypeFormat &rhs);
 
   ~SBTypeFormat();
 
+  explicit operator bool() const;
+
   bool IsValid() const;
 
   lldb::Format GetFormat();
 
   const char *GetTypeName();
 
   uint32_t GetOptions();
 

lldb/trunk/include/lldb/API/SBTypeNameSpecifier.h

public:
   SBTypeNameSpecifier(const char *name, bool is_regex = false);
 
   SBTypeNameSpecifier(SBType type);
 
   SBTypeNameSpecifier(const lldb::SBTypeNameSpecifier &rhs);
 
   ~SBTypeNameSpecifier();
 
+  explicit operator bool() const;
+
   bool IsValid() const;
 
   const char *GetName();
 
   SBType GetType();
 
   bool IsRegex();
 

lldb/trunk/include/lldb/API/SBTypeSummary.h

public:
   SBTypeSummaryOptions();
 
   SBTypeSummaryOptions(const lldb::SBTypeSummaryOptions &rhs);
 
   SBTypeSummaryOptions(const lldb_private::TypeSummaryOptions *lldb_object_ptr);
 
   ~SBTypeSummaryOptions();
 
+  explicit operator bool() const;
+
   bool IsValid();
 
   lldb::LanguageType GetLanguage();
 
   lldb::TypeSummaryCapping GetCapping();
 
   void SetLanguage(lldb::LanguageType);
 
public:
   static SBTypeSummary CreateWithCallback(FormatCallback cb,
                                           uint32_t options = 0,
                                           const char *description = nullptr);
 
   SBTypeSummary(const lldb::SBTypeSummary &rhs);
 
   ~SBTypeSummary();
 
+  explicit operator bool() const;
+
   bool IsValid() const;
 
   bool IsFunctionCode();
 
   bool IsFunctionName();
 
   bool IsSummaryString();
 

lldb/trunk/include/lldb/API/SBTypeSynthetic.h

public:
   static SBTypeSynthetic
   CreateWithScriptCode(const char *data,
                        uint32_t options = 0); // see lldb::eTypeOption values
 
   SBTypeSynthetic(const lldb::SBTypeSynthetic &rhs);
 
   ~SBTypeSynthetic();
 
+  explicit operator bool() const;
+
   bool IsValid() const;
 
   bool IsClassCode();
 
   bool IsClassName();
 
   const char *GetData();
 

lldb/trunk/include/lldb/API/SBUnixSignals.h

public:
   SBUnixSignals(const lldb::SBUnixSignals &rhs);
 
   ~SBUnixSignals();
 
   const SBUnixSignals &operator=(const lldb::SBUnixSignals &rhs);
 
   void Clear();
 
+  explicit operator bool() const;
+
   bool IsValid() const;
 
   const char *GetSignalAsCString(int32_t signo) const;
 
   int32_t GetSignalNumberFromName(const char *name) const;
 
   bool GetShouldSuppress(int32_t signo) const;
 

lldb/trunk/include/lldb/API/SBValue.h

public:
   SBValue();
 
   SBValue(const lldb::SBValue &rhs);
 
   lldb::SBValue &operator=(const lldb::SBValue &rhs);
 
   ~SBValue();
 
+  explicit operator bool() const;
+
   bool IsValid();
 
   void Clear();
 
   SBError GetError();
 
   lldb::user_id_t GetID();
 

lldb/trunk/include/lldb/API/SBValueList.h

 class LLDB_API SBValueList {
 public:
   SBValueList();
 
   SBValueList(const lldb::SBValueList &rhs);
 
   ~SBValueList();
 
+  explicit operator bool() const;
+
   bool IsValid() const;
 
   void Clear();
 
   void Append(const lldb::SBValue &val_obj);
 
   void Append(const lldb::SBValueList &value_list);
 

lldb/trunk/include/lldb/API/SBVariablesOptions.h

public:
   SBVariablesOptions();
 
   SBVariablesOptions(const SBVariablesOptions &options);
 
   SBVariablesOptions &operator=(const SBVariablesOptions &options);
 
   ~SBVariablesOptions();
 
+  explicit operator bool() const;
+
   bool IsValid() const;
 
   bool GetIncludeArguments() const;
 
   void SetIncludeArguments(bool);
 
   bool GetIncludeRecognizedArguments(const lldb::SBTarget &) const;
 

lldb/trunk/include/lldb/API/SBWatchpoint.h

public:
   SBWatchpoint(const lldb::SBWatchpoint &rhs);
 
   SBWatchpoint(const lldb::WatchpointSP &wp_sp);
 
   ~SBWatchpoint();
 
   const lldb::SBWatchpoint &operator=(const lldb::SBWatchpoint &rhs);
 
+  explicit operator bool() const;
+
   bool IsValid() const;
 
   SBError GetError();
 
   watch_id_t GetID();
 
   /// With -1 representing an invalid hardware index.
   int32_t GetHardwareIndex();

lldb/trunk/scripts/Python/modify-python-lldb.py

 # Called to implement the built-in function len().
 # Eligible objects are those containers with unambiguous iteration support.
 len_def = "    def __len__(self): return self.%s()"
 
 # This supports the rich comparison methods of __eq__ and __ne__.
 eq_def = "    def __eq__(self, other): return isinstance(other, %s) and %s"
 ne_def = "    def __ne__(self, other): return not self.__eq__(other)"
 
-# Called to implement truth value testing and the built-in operation bool();
-# Note that Python 2 uses __nonzero__(), whereas Python 3 uses __bool__()
-# should return False or True, or their integer equivalents 0 or 1.
-# Delegate to self.IsValid() if it is defined for the current lldb object.
-
-if six.PY2:
-    nonzero_def = "    def __nonzero__(self): return self.IsValid()"
-else:
-    nonzero_def = "    def __bool__(self): return self.IsValid()"
-
 # A convenience iterator for SBSymbol!
 symbol_in_section_iter_def = '''
     def symbol_in_section_iter(self, section):
         """Given a module and its contained section, returns an iterator on the
         symbols within the section."""
         for sym in self:
             if in_range(sym, section):
                 yield sym
if (state & CLEANUP_DOCSTRING):
         # Note that the transition out of CLEANUP_DOCSTRING is handled at the
         # beginning of this function already.
 
     # This deals with one-liner docstring, for example, SBThread.GetName:
     # """GetName(self) -> char""".
     if one_liner_docstring_pattern.match(line):
         line = char_to_str_xform(line)
 
-    # Look for 'def IsValid(*args):', and once located, add implementation
-    # of truth value testing for this object by delegation.
-    if isvalid_pattern.search(line):
-        new_content.add_line(nonzero_def)
-
     # Pass the original line of content to new_content.
     new_content.add_line(line)
 
 # We are finished with recording new content.
 new_content.finish()
 
 with open(output_name, 'w') as f_out:
     f_out.write(new_content.getvalue())
     f_out.write('''debugger_unique_id = 0
 SBDebugger.Initialize()
 debugger = None
 target = SBTarget()
 process = SBProcess()
 thread = SBThread()
 frame = SBFrame()''')

lldb/trunk/scripts/interface/SBAddress.i

public:
     ") SBAddress;
     SBAddress (lldb::addr_t load_addr, lldb::SBTarget &target);
 
     ~SBAddress ();
 
     bool
     IsValid () const;
 
+    explicit operator bool() const;
+
     void
     Clear ();
 
     addr_t
     GetFileAddress () const;
 
     addr_t
     GetLoadAddress (const lldb::SBTarget &target) const;

lldb/trunk/scripts/interface/SBBlock.i

public:
     "Does this block represent an inlined function?"
     ) IsInlined;
     bool
     IsInlined () const;
 
     bool
     IsValid () const;
 
+    explicit operator bool() const;
+
     %feature("docstring", "
     Get the function name if this block represents an inlined function;
     otherwise, return None.
     ") GetInlinedName;
     const char *
     GetInlinedName () const;
 
     %feature("docstring", "

lldb/trunk/scripts/interface/SBBreakpoint.i

public:
     ~SBBreakpoint();
 
     break_id_t
     GetID () const;
 
     bool
     IsValid() const;
 
+    explicit operator bool() const;
+
     void
     ClearAllBreakpointSites ();
 
     lldb::SBBreakpointLocation
     FindLocationByAddress (lldb::addr_t vm_addr);
 
     lldb::break_id_t
     FindLocationIDByAddress (lldb::addr_t vm_addr);

lldb/trunk/scripts/interface/SBBreakpointLocation.i

public:
     ~SBBreakpointLocation ();
 
     break_id_t
     GetID ();
     
     bool
     IsValid() const;
 
+    explicit operator bool() const;
+
     lldb::SBAddress
     GetAddress();
     
     lldb::addr_t
     GetLoadAddress ();
 
     void
     SetEnabled(bool enabled);

lldb/trunk/scripts/interface/SBBreakpointName.i

public:
   const lldb::SBBreakpointName &operator=(const lldb::SBBreakpointName &rhs);
 
   // Tests to see if the opaque breakpoint object in this object matches the
   // opaque breakpoint object in "rhs".
   bool operator==(const lldb::SBBreakpointName &rhs);
 
   bool operator!=(const lldb::SBBreakpointName &rhs);
 
+  explicit operator bool() const;
+
   bool IsValid() const;
   
   const char *GetName() const;
 
   void SetEnabled(bool enable);
 
   bool IsEnabled();
 

lldb/trunk/scripts/interface/SBBroadcaster.i

public:
 
     SBBroadcaster (const SBBroadcaster &rhs);
     
     ~SBBroadcaster();
 
     bool
     IsValid () const;
 
+    explicit operator bool() const;
+
     void
     Clear ();
 
     void
     BroadcastEventByType (uint32_t event_type, bool unique = false);
 
     void
     BroadcastEvent (const lldb::SBEvent &event, bool unique = false);

lldb/trunk/scripts/interface/SBCommandInterpreter.i

public:
     GetArgumentDescriptionAsCString (const lldb::CommandArgumentType arg_type);
 
     static bool
     EventIsCommandInterpreterEvent (const lldb::SBEvent &event);
 
     bool
     IsValid() const;
 
+    explicit operator bool() const;
+
     const char *
     GetIOHandlerControlSequence(char ch);
 
     bool
     GetPromptOnQuit();
 
     void
     SetPromptOnQuit(bool b);

lldb/trunk/scripts/interface/SBCommandReturnObject.i

public:
 
     SBCommandReturnObject (const lldb::SBCommandReturnObject &rhs);
 
     ~SBCommandReturnObject ();
 
     bool
     IsValid() const;
 
+    explicit operator bool() const;
+
     const char *
     GetOutput ();
 
     const char *
     GetError ();
 
     size_t
     GetOutputSize ();

lldb/trunk/scripts/interface/SBCommunication.i

public:
     SBCommunication ();
     SBCommunication (const char * broadcaster_name);
    ~SBCommunication ();
 
 
     bool
     IsValid () const;
 
+    explicit operator bool() const;
+
     lldb::SBBroadcaster
     GetBroadcaster ();
 
     static const char *GetBroadcasterClass();
 
     lldb::ConnectionStatus
     AdoptFileDesriptor (int fd, bool owns_fd);
 

lldb/trunk/scripts/interface/SBCompileUnit.i

public:
 
     SBCompileUnit (const lldb::SBCompileUnit &rhs);
 
     ~SBCompileUnit ();
 
     bool
     IsValid () const;
 
+    explicit operator bool() const;
+
     lldb::SBFileSpec
     GetFileSpec () const;
 
     uint32_t
     GetNumLineEntries () const;
 
     lldb::SBLineEntry
     GetLineEntryAtIndex (uint32_t idx) const;

lldb/trunk/scripts/interface/SBData.i

public:
     SetAddressByteSize (uint8_t addr_byte_size);
 
     void
     Clear ();
 
     bool
     IsValid();
 
+    explicit operator bool() const;
+
     size_t
     GetByteSize ();
 
     lldb::ByteOrder
     GetByteOrder();
     
     void
     SetByteOrder (lldb::ByteOrder endian);

lldb/trunk/scripts/interface/SBDebugger.i

public:
 
     SBDebugger(const lldb::SBDebugger &rhs);
 
     ~SBDebugger();
 
     bool
     IsValid() const;
 
+    explicit operator bool() const;
+
     void
     Clear ();
 
     void
     SetAsync (bool b);
 
     bool
     GetAsync ();

lldb/trunk/scripts/interface/SBDeclaration.i

class SBDeclaration
         SBDeclaration ();
         
         SBDeclaration (const lldb::SBDeclaration &rhs);
         
         ~SBDeclaration ();
         
         bool
         IsValid () const;
-        
+        explicit operator bool() const;
+        
         lldb::SBFileSpec
         GetFileSpec () const;
         
         uint32_t
         GetLine () const;
         
         uint32_t
         GetColumn () const;

lldb/trunk/scripts/interface/SBError.i

public:
 
     %varargs(3, char *str = NULL) SetErrorStringWithFormat;
     int
     SetErrorStringWithFormat (const char *format, ...);
 
     bool
     IsValid () const;
 
+    explicit operator bool() const;
+
     bool
     GetDescription (lldb::SBStream &description);
     
     %pythoncode %{
         __swig_getmethods__["value"] = GetError
         if _newclass: value = property(GetError, None, doc='''A read only property that returns the same result as GetError().''')
         
         __swig_getmethods__["fail"] = Fail

lldb/trunk/scripts/interface/SBEvent.i

public:
     ) SBEvent;
     SBEvent (uint32_t event, const char *cstr, uint32_t cstr_len);
 
     ~SBEvent();
 
     bool
     IsValid() const;
 
+    explicit operator bool() const;
+
     const char *
     GetDataFlavor ();
 
     uint32_t
     GetType () const;
 
     lldb::SBBroadcaster
     GetBroadcaster () const;

lldb/trunk/scripts/interface/SBFileSpec.i

public:
 
     SBFileSpec (const char *path, bool resolve);
 
     ~SBFileSpec ();
 
     bool
     IsValid() const;
 
+    explicit operator bool() const;
+
     bool
     Exists () const;
 
     bool
     ResolveExecutableLocation ();
 
     const char *
     GetFilename() const;

lldb/trunk/scripts/interface/SBFrame.i

public:
    ~SBFrame();
 
     bool
     IsEqual (const lldb::SBFrame &rhs) const;
 
     bool
     IsValid() const;
 
+    explicit operator bool() const;
+
     uint32_t
     GetFrameID () const;
 
     %feature("docstring", "
     Get the Canonical Frame Address for this stack frame.
     This is the DWARF standard's definition of a CFA, a stack address
     that remains constant throughout the lifetime of the function.
     Returns an lldb::addr_t stack address, or LLDB_INVALID_ADDRESS if

lldb/trunk/scripts/interface/SBFunction.i

public:
 
     SBFunction (const lldb::SBFunction &rhs);
 
     ~SBFunction ();
 
     bool
     IsValid () const;
 
+    explicit operator bool() const;
+
     const char *
     GetName() const;
     
     const char *
     GetDisplayName() const;
 
     const char *
     GetMangledName () const;

lldb/trunk/scripts/interface/SBInstruction.i

public:
 
     SBInstruction (const SBInstruction &rhs);
     
     ~SBInstruction ();
 
     bool
     IsValid();
 
+    explicit operator bool() const;
+
     lldb::SBAddress
     GetAddress();
 
     
     const char *
     GetMnemonic (lldb::SBTarget target);
     
     const char *

lldb/trunk/scripts/interface/SBInstructionList.i

public:
 
     SBInstructionList (const SBInstructionList &rhs);
     
     ~SBInstructionList ();
 
     bool
     IsValid () const;
 
+    explicit operator bool() const;
+
     size_t
     GetSize ();
 
     lldb::SBInstruction
     GetInstructionAtIndex (uint32_t idx);
 
     size_t GetInstructionsCount(const SBAddress &start, const SBAddress &end,
                                 bool canSetBreakpoint);

lldb/trunk/scripts/interface/SBLineEntry.i

public:
     GetStartAddress () const;
 
     lldb::SBAddress
     GetEndAddress () const;
 
     bool
     IsValid () const;
 
+    explicit operator bool() const;
+
     lldb::SBFileSpec
     GetFileSpec () const;
 
     uint32_t
     GetLine () const;
 
     uint32_t
     GetColumn () const;

lldb/trunk/scripts/interface/SBListener.i

public:
     AddEvent (const lldb::SBEvent &event);
 
     void
     Clear ();
 
     bool
     IsValid () const;
 
+    explicit operator bool() const;
+
     uint32_t
     StartListeningForEventClass (SBDebugger &debugger,
                                  const char *broadcaster_class, 
                                  uint32_t event_mask);
                                  
     uint32_t
     StopListeningForEventClass (SBDebugger &debugger,
                                 const char *broadcaster_class,

lldb/trunk/scripts/interface/SBModule.i

public:
     SBModule (lldb::SBProcess &process, 
               lldb::addr_t header_addr);
 
     ~SBModule ();
 
     bool
     IsValid () const;
 
+    explicit operator bool() const;
+
     void
     Clear();
 
     %feature("docstring", "
     //------------------------------------------------------------------
     /// Get const accessor for the module file specification.
     ///
     /// This function returns the file for the module on the host system

lldb/trunk/scripts/interface/SBModuleSpec.i

public:
     SBModuleSpec ();
     
     SBModuleSpec (const lldb::SBModuleSpec &rhs);
     
     ~SBModuleSpec ();
     
     bool
     IsValid () const;
-    
+    explicit operator bool() const;
+    
     void
     Clear();
     
     //------------------------------------------------------------------
     /// Get const accessor for the module file.
     ///
     /// This function returns the file for the module on the host system
     /// that is running LLDB. This can differ from the path on the

lldb/trunk/scripts/interface/SBPlatform.i

public:
 
     SBPlatform (const char *);
 
     ~SBPlatform();
     
     bool
     IsValid () const;
 
+    explicit operator bool() const;
+
     void
     Clear ();
 
     const char *
     GetWorkingDirectory();
     
     bool
     SetWorkingDirectory(const char *);

lldb/trunk/scripts/interface/SBProcess.i

public:
     GetShortPluginName ();
     
     void
     Clear ();
 
     bool
     IsValid() const;
 
+    explicit operator bool() const;
+
     lldb::SBTarget
     GetTarget() const;
 
     lldb::ByteOrder
     GetByteOrder() const;
 
     %feature("autodoc", "
     Writes data into the current process's stdin. API client specifies a Python

lldb/trunk/scripts/interface/SBProcessInfo.i

public:
 
     SBProcessInfo (const SBProcessInfo &rhs);
 
     ~SBProcessInfo ();
 
     bool
     IsValid ();
 
+    explicit operator bool() const;
+
     const char *
     GetName ();
 
     SBFileSpec
     GetExecutableFile ();
 
     lldb::pid_t
     GetProcessID ();

lldb/trunk/scripts/interface/SBQueue.i

public:
 
     SBQueue (const lldb::QueueSP& queue_sp);
     
    ~SBQueue();
 
     bool
     IsValid() const;
 
+    explicit operator bool() const;
+
     void
     Clear ();
 
     lldb::SBProcess
     GetProcess ();
 
     %feature("autodoc", "
     Returns an lldb::queue_id_t type unique identifier number for this

lldb/trunk/scripts/interface/SBQueueItem.i

public:
 
     SBQueueItem (const lldb::QueueItemSP& queue_item_sp);
     
    ~SBQueueItem();
 
     bool
     IsValid() const;
 
+    explicit operator bool() const;
+
     void
     Clear ();
 
     lldb::QueueItemKind
     GetKind () const;
 
     void
     SetKind (lldb::QueueItemKind kind);

lldb/trunk/scripts/interface/SBSection.i

public:
 
     SBSection (const lldb::SBSection &rhs);
 
     ~SBSection ();
 
     bool
     IsValid () const;
 
+    explicit operator bool() const;
+
     const char *
     GetName ();
 
     lldb::SBSection
     GetParent();
 
     lldb::SBSection
     FindSubSection (const char *sect_name);

lldb/trunk/scripts/interface/SBStream.i

public:
 
     SBStream ();
     
     ~SBStream ();
 
     bool
     IsValid() const;
 
+    explicit operator bool() const;
+
     %feature("docstring", "
     //--------------------------------------------------------------------------
     /// If this stream is not redirected to a file, it will maintain a local
     /// cache for the stream data which can be accessed using this accessor.
     //--------------------------------------------------------------------------
     ") GetData;
     const char *
     GetData ();

lldb/trunk/scripts/interface/SBStringList.i

public:
 
     SBStringList (const lldb::SBStringList &rhs);
     
     ~SBStringList ();
 
     bool
     IsValid() const;
 
+    explicit operator bool() const;
+
     void
     AppendString (const char *str);
 
     void
     AppendList (const char **strv, int strc);
 
     void
     AppendList (const lldb::SBStringList &strings);

lldb/trunk/scripts/interface/SBStructuredData.i

public:
 
         SBStructuredData(const lldb::EventSP &event_sp);
 
         ~SBStructuredData();
 
         bool
         IsValid() const;
 
+        explicit operator bool() const;
+
         void
         Clear();
 
         lldb::SBStructuredData &operator=(const lldb::SBStructuredData &rhs);
 
         lldb::StructuredDataType GetType() const;
 
         size_t GetSize() const;

lldb/trunk/scripts/interface/SBSymbol.i

public:
 
     ~SBSymbol ();
 
     SBSymbol (const lldb::SBSymbol &rhs);
 
     bool
     IsValid () const;
 
+    explicit operator bool() const;
+
 
     const char *
     GetName() const;
 
     const char *
     GetDisplayName() const;
     
     const char *

lldb/trunk/scripts/interface/SBSymbolContext.i

public:
 
     SBSymbolContext (const lldb::SBSymbolContext& rhs);
 
     ~SBSymbolContext ();
 
     bool
     IsValid () const;
 
+    explicit operator bool() const;
+
     lldb::SBModule        GetModule ();
     lldb::SBCompileUnit   GetCompileUnit ();
     lldb::SBFunction      GetFunction ();
     lldb::SBBlock         GetBlock ();
     lldb::SBLineEntry     GetLineEntry ();
     lldb::SBSymbol        GetSymbol ();
 
     void SetModule      (lldb::SBModule module);

lldb/trunk/scripts/interface/SBSymbolContextList.i

public:
 
     SBSymbolContextList (const lldb::SBSymbolContextList& rhs);
 
     ~SBSymbolContextList ();
 
     bool
     IsValid () const;
 
+    explicit operator bool() const;
+
     uint32_t
     GetSize() const;
 
     SBSymbolContext
     GetContextAtIndex (uint32_t idx);
 
     void
     Append (lldb::SBSymbolContext &sc);

lldb/trunk/scripts/interface/SBTarget.i

public:
     ~SBTarget();
 
     static const char *
     GetBroadcasterClassName ();
 
     bool
     IsValid() const;
 
+    explicit operator bool() const;
+
     static bool
     EventIsTargetEvent (const lldb::SBEvent &event);
 
     static lldb::SBTarget
     GetTargetFromEvent (const lldb::SBEvent &event);
 
     static uint32_t
     GetNumModulesFromEvent (const lldb::SBEvent &event);

lldb/trunk/scripts/interface/SBThread.i

~SBThread();
     GetStackFrameFromEvent (const SBEvent &event);
     
     static SBThread
     GetThreadFromEvent (const SBEvent &event);
 
     bool
     IsValid() const;
 
+    explicit operator bool() const;
+
     void
     Clear ();
 
     lldb::StopReason
     GetStopReason();
 
     %feature("docstring", "
     /// Get the number of words associated with the stop reason.

lldb/trunk/scripts/interface/SBThreadCollection.i

public:
     SBThreadCollection ();
     
     SBThreadCollection (const SBThreadCollection &rhs);
     
     ~SBThreadCollection ();
     
     bool
     IsValid () const;
-    
+    explicit operator bool() const;
+    
     size_t
     GetSize ();
     
     lldb::SBThread
     GetThreadAtIndex (size_t idx);
     
 };
     
 } // namespace lldb

lldb/trunk/scripts/interface/SBThreadPlan.i

public:
 
     SBThreadPlan (lldb::SBThread &thread, const char *class_name);
 
    ~SBThreadPlan ();
 
     bool
     IsValid() const;
 
+    explicit operator bool() const;
+
     void
     Clear ();
 
     lldb::StopReason
     GetStopReason();
 
     /// Get the number of words associated with the stop reason.
     /// See also GetStopReasonDataAtIndex().
~SBThreadPlan ();
     IsPlanComplete();
 
     bool
     IsPlanStale();
 
     bool
     IsValid();
 
+    explicit operator bool() const;
+
     // This section allows an SBThreadPlan to push another of the common types of plans...
     SBThreadPlan
     QueueThreadPlanForStepOverRange (SBAddress &start_address,
                                      lldb::addr_t range_size);
 
     SBThreadPlan
     QueueThreadPlanForStepInRange (SBAddress &start_address,
                                    lldb::addr_t range_size);

lldb/trunk/scripts/interface/SBTrace.i

public:
   void StopTrace(SBError &error,
                  lldb::tid_t thread_id);
 
   void GetTraceConfig(SBTraceOptions &options,
                       SBError &error);
 
   lldb::user_id_t GetTraceUID();
 
+  explicit operator bool() const;
+
   bool IsValid();
 
 };
 } // namespace lldb
 No newline at end of file

lldb/trunk/scripts/interface/SBTraceOptions.i

public:
   void setTraceBufferSize(uint64_t size);
 
   void setMetaDataBufferSize(uint64_t size);
 
   void setThreadID(lldb::tid_t thread_id);
 
   lldb::tid_t getThreadID();
 
+  explicit operator bool() const;
+
   bool IsValid();
 };
 }

lldb/trunk/scripts/interface/SBType.i

public:
 
     SBTypeMember (const lldb::SBTypeMember& rhs);
 
     ~SBTypeMember();
 
     bool
     IsValid() const;
 
+    explicit operator bool() const;
+
     const char *
     GetName ();
     
     lldb::SBType
     GetType ();
 
     uint64_t
     GetOffsetInBytes();
public:
     SBTypeMemberFunction ();
     
     SBTypeMemberFunction (const lldb::SBTypeMemberFunction& rhs);
     
     ~SBTypeMemberFunction();
     
     bool
     IsValid() const;
-    
+    explicit operator bool() const;
+    
     const char *
     GetName ();
     
     const char *
     GetDemangledName ();
 
     const char *
     GetMangledName ();
public:
 
     SBType (const lldb::SBType &rhs);
 
     ~SBType ();
 
     bool
     IsValid();
 
+    explicit operator bool() const;
+
     uint64_t
     GetByteSize();
 
     bool
     IsPointerType();
 
     bool
     IsReferenceType();

 class SBTypeList
 {
 public:
     SBTypeList();
 
     bool
     IsValid();
 
+    explicit operator bool() const;
+
     void
     Append (lldb::SBType type);
 
     lldb::SBType
     GetTypeAtIndex (uint32_t index);
 
     uint32_t
     GetSize();
 
     ~SBTypeList();
 };
 
 } // namespace lldb

lldb/trunk/scripts/interface/SBTypeCategory.i

public:
         SBTypeCategory();
         
         SBTypeCategory (const lldb::SBTypeCategory &rhs);
         
         ~SBTypeCategory ();
         
         bool
         IsValid() const;
-        
+        explicit operator bool() const;
+        
         bool
         GetEnabled ();
         
         void
         SetEnabled (bool);
         
         const char*
         GetName();

lldb/trunk/scripts/interface/SBTypeEnumMember.i

public:
 
     SBTypeEnumMember (const SBTypeEnumMember& rhs);
 
     ~SBTypeEnumMember();
 
     bool
     IsValid() const;
 
+    explicit operator bool() const;
+
     int64_t
     GetValueAsSigned();
 
     uint64_t
     GetValueAsUnsigned();
 
     const char *
     GetName ();
public:
 
     SBTypeEnumMemberList(const SBTypeEnumMemberList& rhs);
 
     ~SBTypeEnumMemberList();
 
     bool
     IsValid();
 
+    explicit operator bool() const;
+
     void
     Append (SBTypeEnumMember entry);
 
     SBTypeEnumMember
     GetTypeEnumMemberAtIndex (uint32_t index);
 
     uint32_t
     GetSize();
 
 
 private:
     std::unique_ptr<lldb_private::TypeEnumMemberListImpl> m_opaque_ap;
 };
 
 } // namespace lldb

lldb/trunk/scripts/interface/SBTypeFilter.i

class SBTypeFilter
         SBTypeFilter (uint32_t options);
         
         SBTypeFilter (const lldb::SBTypeFilter &rhs);
         
         ~SBTypeFilter ();
         
         bool
         IsValid() const;
-        
+        explicit operator bool() const;
+        
         bool
         IsEqualTo (lldb::SBTypeFilter &rhs);
         
         uint32_t
         GetNumberOfExpressionPaths ();
         
         const char*
         GetExpressionPathAtIndex (uint32_t i);

lldb/trunk/scripts/interface/SBTypeFormat.i

public:
         SBTypeFormat (const char* type, uint32_t options = 0);
         
         SBTypeFormat (const lldb::SBTypeFormat &rhs);
         
         ~SBTypeFormat ();
         
         bool
         IsValid() const;
-        
+        explicit operator bool() const;
+        
         bool
         IsEqualTo (lldb::SBTypeFormat &rhs);
         
         lldb::Format
         GetFormat ();
         
         const char*
         GetTypeName ();

lldb/trunk/scripts/interface/SBTypeNameSpecifier.i

public:
         SBTypeNameSpecifier (SBType type);
         
         SBTypeNameSpecifier (const lldb::SBTypeNameSpecifier &rhs);
         
         ~SBTypeNameSpecifier ();
         
         bool
         IsValid() const;
-        
+        explicit operator bool() const;
+        
         bool
         IsEqualTo (lldb::SBTypeNameSpecifier &rhs);
         
         const char*
         GetName();
         
         lldb::SBType
         GetType ();

lldb/trunk/scripts/interface/SBTypeSummary.i

public:
         SBTypeSummaryOptions();
         
         SBTypeSummaryOptions (const lldb::SBTypeSummaryOptions &rhs);
         
         ~SBTypeSummaryOptions ();
         
         bool
         IsValid ();
-        
+        explicit operator bool() const;
+        
         lldb::LanguageType
         GetLanguage ();
         
         lldb::TypeSummaryCapping
         GetCapping ();
         
         void
         SetLanguage (lldb::LanguageType);
public:
         CreateWithScriptCode (const char* data, uint32_t options = 0);
         
         SBTypeSummary (const lldb::SBTypeSummary &rhs);
         
         ~SBTypeSummary ();
         
         bool
         IsValid() const;
-        
+        explicit operator bool() const;
+        
         bool
         IsEqualTo (lldb::SBTypeSummary &rhs);
         
         bool
         IsFunctionCode();
         
         bool
         IsFunctionName();

lldb/trunk/scripts/interface/SBTypeSynthetic.i

public:
         CreateWithScriptCode (const char* data, uint32_t options = 0);
         
         SBTypeSynthetic (const lldb::SBTypeSynthetic &rhs);
         
         ~SBTypeSynthetic ();
         
         bool
         IsValid() const;
-        
+        explicit operator bool() const;
+        
         bool
         IsEqualTo (lldb::SBTypeSynthetic &rhs);
         
         bool
         IsClassCode();
         
         const char*
         GetData ();

lldb/trunk/scripts/interface/SBUnixSignals.i

public:
     ~SBUnixSignals();
 
     void
     Clear ();
 
     bool
     IsValid () const;
 
+    explicit operator bool() const;
+
     const char *
     GetSignalAsCString (int32_t signo) const;
 
     int32_t
     GetSignalNumberFromName (const char *name) const;
 
     bool
     GetShouldSuppress (int32_t signo) const;

lldb/trunk/scripts/interface/SBValue.i

public:
     SBValue ();
 
     SBValue (const SBValue &rhs);
 
     ~SBValue ();
 
     bool
     IsValid();
-    
+    explicit operator bool() const;
+    
     void
     Clear();
     
     SBError
     GetError();
 
     lldb::user_id_t
     GetID ();

lldb/trunk/scripts/interface/SBValueList.i

public:
     SBValueList ();
 
     SBValueList (const lldb::SBValueList &rhs);
 
     ~SBValueList();
 
     bool
     IsValid() const;
-    
+    explicit operator bool() const;
+    
     void 
     Clear();
 
     void
     Append (const lldb::SBValue &val_obj);
 
     void
     Append (const lldb::SBValueList& value_list);

lldb/trunk/scripts/interface/SBVariablesOptions.i

public:
     SBVariablesOptions ();
     
     SBVariablesOptions (const SBVariablesOptions& options);
     
     ~SBVariablesOptions ();
     
     bool
     IsValid () const;
-    
+    explicit operator bool() const;
+    
     bool
     GetIncludeArguments ()  const;
     
     void
     SetIncludeArguments (bool);
 
     bool
     GetIncludeRecognizedArguments (const lldb::SBTarget &)  const;

lldb/trunk/scripts/interface/SBWatchpoint.i

public:
 
     SBWatchpoint (const lldb::SBWatchpoint &rhs);
 
     ~SBWatchpoint ();
 
     bool
     IsValid();
 
+    explicit operator bool() const;
+
     SBError
     GetError();
 
     watch_id_t
     GetID ();
 
     %feature("docstring", "
     //------------------------------------------------------------------

lldb/trunk/scripts/lldb.swig

def lldb_iter(obj, getsize, getelem):
     size = getattr(obj, getsize)
     elem = getattr(obj, getelem)
     for i in range(size()):
         yield elem(i)
 
 # ==============================================================================
 # The modify-python-lldb.py script is responsible for post-processing this SWIG-
 # generated lldb.py module.  It is responsible for adding support for: iteration
-# protocol: __iter__, rich comparison methods: __eq__ and __ne__, truth value
-# testing (and built-in operation bool()): __nonzero__, and built-in function
-# len(): __len__.
+# protocol: __iter__, rich comparison methods: __eq__ and __ne__, and built-in
+# function len(): __len__.
 # ==============================================================================
 %}
 
 %include "./Python/python-typemaps.swig"
 
 /* C++ headers to be included. */
 %{
 #include <algorithm>

lldb/trunk/source/API/SBAddress.cpp

 bool lldb::operator==(const SBAddress &lhs, const SBAddress &rhs) {
   if (lhs.IsValid() && rhs.IsValid())
     return lhs.ref() == rhs.ref();
   return false;
 }
 
 bool SBAddress::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBAddress, IsValid);
+  return this->operator bool();
+}
+SBAddress::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBAddress, operator bool);
 
   return m_opaque_up != NULL && m_opaque_up->IsValid();
 }
 
 void SBAddress::Clear() {
   LLDB_RECORD_METHOD_NO_ARGS(void, SBAddress, Clear);
 
   m_opaque_up.reset(new Address());

lldb/trunk/source/API/SBBlock.cpp

const SBBlock &SBBlock::operator=(const SBBlock &rhs) {
   m_opaque_ptr = rhs.m_opaque_ptr;
   return *this;
 }
 
 SBBlock::~SBBlock() { m_opaque_ptr = NULL; }
 
 bool SBBlock::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBlock, IsValid);
+  return this->operator bool();
+}
+SBBlock::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBlock, operator bool);
 
   return m_opaque_ptr != NULL;
 }
 
 bool SBBlock::IsInlined() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBlock, IsInlined);
 
   if (m_opaque_ptr)

lldb/trunk/source/API/SBBreakpoint.cpp

break_id_t SBBreakpoint::GetID() const {
   if (bkpt_sp)
     break_id = bkpt_sp->GetID();
 
   return break_id;
 }
 
 bool SBBreakpoint::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpoint, IsValid);
+  return this->operator bool();
+}
+SBBreakpoint::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpoint, operator bool);
 
   BreakpointSP bkpt_sp = GetSP();
   if (!bkpt_sp)
     return false;
   else if (bkpt_sp->GetTarget().GetBreakpointByID(bkpt_sp->GetID()))
     return true;
   else
     return false;

lldb/trunk/source/API/SBBreakpointLocation.cpp

 SBBreakpointLocation::~SBBreakpointLocation() {}
 
 BreakpointLocationSP SBBreakpointLocation::GetSP() const {
   return m_opaque_wp.lock();
 }
 
 bool SBBreakpointLocation::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointLocation, IsValid);
+  return this->operator bool();
+}
+SBBreakpointLocation::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointLocation, operator bool);
 
   return bool(GetSP());
 }
 
 SBAddress SBBreakpointLocation::GetAddress() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBBreakpointLocation, GetAddress);
 
   BreakpointLocationSP loc_sp = GetSP();

lldb/trunk/source/API/SBBreakpointName.cpp

bool SBBreakpointName::operator!=(const lldb::SBBreakpointName &rhs) {
   LLDB_RECORD_METHOD(
       bool, SBBreakpointName, operator!=,(const lldb::SBBreakpointName &), rhs);
 
   return *m_impl_up != *rhs.m_impl_up;
 }
 
 bool SBBreakpointName::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointName, IsValid);
+  return this->operator bool();
+}
+SBBreakpointName::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBreakpointName, operator bool);
 
   if (!m_impl_up)
     return false;
   return m_impl_up->IsValid();
 }
 
 const char *SBBreakpointName::GetName() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBreakpointName, GetName);

lldb/trunk/source/API/SBBroadcaster.cpp

if (owns)
     m_opaque_sp.reset(broadcaster);
   else
     m_opaque_sp.reset();
   m_opaque_ptr = broadcaster;
 }
 
 bool SBBroadcaster::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBroadcaster, IsValid);
+  return this->operator bool();
+}
+SBBroadcaster::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBroadcaster, operator bool);
 
   return m_opaque_ptr != NULL;
 }
 
 void SBBroadcaster::Clear() {
   LLDB_RECORD_METHOD_NO_ARGS(void, SBBroadcaster, Clear);
 
   m_opaque_sp.reset();

lldb/trunk/source/API/SBCommandInterpreter.cpp

LLDB_RECORD_METHOD(
       rhs);
 
   m_opaque_ptr = rhs.m_opaque_ptr;
   return *this;
 }
 
 bool SBCommandInterpreter::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreter, IsValid);
+  return this->operator bool();
+}
+SBCommandInterpreter::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreter, operator bool);
 
   return m_opaque_ptr != nullptr;
 }
 
 bool SBCommandInterpreter::CommandExists(const char *cmd) {
   LLDB_RECORD_METHOD(bool, SBCommandInterpreter, CommandExists, (const char *),
                      cmd);
 

 }
 
 SBCommand::SBCommand() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCommand); }
 
 SBCommand::SBCommand(lldb::CommandObjectSP cmd_sp) : m_opaque_sp(cmd_sp) {}
 
 bool SBCommand::IsValid() {
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommand, IsValid);
+  return this->operator bool();
+}
+SBCommand::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommand, operator bool);
 
   return m_opaque_sp.get() != nullptr;
 }
 
 const char *SBCommand::GetName() {
   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBCommand, GetName);
 
   return (IsValid() ? ConstString(m_opaque_sp->GetCommandName()).AsCString() : nullptr);

lldb/trunk/source/API/SBCommandReturnObject.cpp

operator=(const SBCommandReturnObject &rhs) {
 
   if (this != &rhs)
     m_opaque_up = clone(rhs.m_opaque_up);
   return *this;
 }
 
 bool SBCommandReturnObject::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandReturnObject, IsValid);
+  return this->operator bool();
+}
+SBCommandReturnObject::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandReturnObject, operator bool);
 
   return m_opaque_up != nullptr;
 }
 
 const char *SBCommandReturnObject::GetOutput() {
   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBCommandReturnObject, GetOutput);
 
   if (m_opaque_up) {

lldb/trunk/source/API/SBCommunication.cpp

SBCommunication::~SBCommunication() {
   if (m_opaque && m_opaque_owned)
     delete m_opaque;
   m_opaque = NULL;
   m_opaque_owned = false;
 }
 
 bool SBCommunication::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommunication, IsValid);
+  return this->operator bool();
+}
+SBCommunication::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommunication, operator bool);
 
   return m_opaque != NULL;
 }
 
 bool SBCommunication::GetCloseOnEOF() {
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBCommunication, GetCloseOnEOF);
 
   if (m_opaque)

lldb/trunk/source/API/SBCompileUnit.cpp

lldb::LanguageType SBCompileUnit::GetLanguage() {
 
   if (m_opaque_ptr)
     return m_opaque_ptr->GetLanguage();
   return lldb::eLanguageTypeUnknown;
 }
 
 bool SBCompileUnit::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCompileUnit, IsValid);
+  return this->operator bool();
+}
+SBCompileUnit::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCompileUnit, operator bool);
 
   return m_opaque_ptr != NULL;
 }
 
 bool SBCompileUnit::operator==(const SBCompileUnit &rhs) const {
   LLDB_RECORD_METHOD_CONST(
       bool, SBCompileUnit, operator==,(const lldb::SBCompileUnit &), rhs);
 

lldb/trunk/source/API/SBData.cpp

 }
 
 lldb::DataExtractorSP &SBData::operator*() { return m_opaque_sp; }
 
 const lldb::DataExtractorSP &SBData::operator*() const { return m_opaque_sp; }
 
 bool SBData::IsValid() {
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBData, IsValid);
+  return this->operator bool();
+}
+SBData::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBData, operator bool);
 
   return m_opaque_sp.get() != NULL;
 }
 
 uint8_t SBData::GetAddressByteSize() {
   LLDB_RECORD_METHOD_NO_ARGS(uint8_t, SBData, GetAddressByteSize);
 
   uint8_t value = 0;

lldb/trunk/source/API/SBDebugger.cpp

void SBDebugger::MemoryPressureDetected() {
 
   const bool mandatory = false;
 
   ModuleList::RemoveOrphanSharedModules(mandatory);
 }
 
 bool SBDebugger::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDebugger, IsValid);
+  return this->operator bool();
+}
+SBDebugger::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDebugger, operator bool);
 
   return m_opaque_sp.get() != nullptr;
 }
 
 void SBDebugger::SetAsync(bool b) {
   LLDB_RECORD_METHOD(void, SBDebugger, SetAsync, (bool), b);
 
   if (m_opaque_sp)

lldb/trunk/source/API/SBDeclaration.cpp

void SBDeclaration::SetDeclaration(
     const lldb_private::Declaration &lldb_object_ref) {
   ref() = lldb_object_ref;
 }
 
 SBDeclaration::~SBDeclaration() {}
 
 bool SBDeclaration::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDeclaration, IsValid);
+  return this->operator bool();
+}
+SBDeclaration::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDeclaration, operator bool);
 
   return m_opaque_up.get() && m_opaque_up->IsValid();
 }
 
 SBFileSpec SBDeclaration::GetFileSpec() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBDeclaration,
                                    GetFileSpec);
 

lldb/trunk/source/API/SBError.cpp

int SBError::SetErrorStringWithFormat(const char *format, ...) {
   va_start(args, format);
   int num_chars = m_opaque_up->SetErrorStringWithVarArg(format, args);
   va_end(args);
   return num_chars;
 }
 
 bool SBError::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBError, IsValid);
+  return this->operator bool();
+}
+SBError::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBError, operator bool);
 
   return m_opaque_up != NULL;
 }
 
 void SBError::CreateIfNeeded() {
   if (m_opaque_up == NULL)
     m_opaque_up.reset(new Status());
 }

lldb/trunk/source/API/SBEvent.cpp

 
 void SBEvent::reset(Event *event_ptr) {
   m_opaque_ptr = event_ptr;
   m_event_sp.reset();
 }
 
 bool SBEvent::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBEvent, IsValid);
+  return this->operator bool();
+}
+SBEvent::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBEvent, operator bool);
 
   // Do NOT use m_opaque_ptr directly!!! Must use the SBEvent::get() accessor.
   // See comments in SBEvent::get()....
   return SBEvent::get() != NULL;
 }
 
 const char *SBEvent::GetCStringFromEvent(const SBEvent &event) {
   LLDB_RECORD_STATIC_METHOD(const char *, SBEvent, GetCStringFromEvent,

lldb/trunk/source/API/SBFileSpec.cpp

const SBFileSpec &SBFileSpec::operator=(const SBFileSpec &rhs) {
 
   if (this != &rhs)
     m_opaque_up = clone(rhs.m_opaque_up);
   return *this;
 }
 
 bool SBFileSpec::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFileSpec, IsValid);
+  return this->operator bool();
+}
+SBFileSpec::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFileSpec, operator bool);
 
   return m_opaque_up->operator bool();
 }
 
 bool SBFileSpec::Exists() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFileSpec, Exists);
 
   return FileSystem::Instance().Exists(*m_opaque_up);

lldb/trunk/source/API/SBFrame.cpp

 }
 
 void SBFrame::SetFrameSP(const StackFrameSP &lldb_object_sp) {
   return m_opaque_sp->SetFrameSP(lldb_object_sp);
 }
 
 bool SBFrame::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFrame, IsValid);
+  return this->operator bool();
+}
+SBFrame::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFrame, operator bool);
 
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   Target *target = exe_ctx.GetTargetPtr();
   Process *process = exe_ctx.GetProcessPtr();
   if (target && process) {
     Process::StopLocker stop_locker;

lldb/trunk/source/API/SBFunction.cpp

const SBFunction &SBFunction::operator=(const SBFunction &rhs) {
   m_opaque_ptr = rhs.m_opaque_ptr;
   return *this;
 }
 
 SBFunction::~SBFunction() { m_opaque_ptr = NULL; }
 
 bool SBFunction::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFunction, IsValid);
+  return this->operator bool();
+}
+SBFunction::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFunction, operator bool);
 
   return m_opaque_ptr != NULL;
 }
 
 const char *SBFunction::GetName() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFunction, GetName);
 
   const char *cstr = NULL;

lldb/trunk/source/API/SBInstruction.cpp

if (this != &rhs)
     m_opaque_sp = rhs.m_opaque_sp;
   return *this;
 }
 
 SBInstruction::~SBInstruction() {}
 
 bool SBInstruction::IsValid() {
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBInstruction, IsValid);
+  return this->operator bool();
+}
+SBInstruction::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBInstruction, operator bool);
 
   return m_opaque_sp && m_opaque_sp->IsValid();
 }
 
 SBAddress SBInstruction::GetAddress() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBAddress, SBInstruction, GetAddress);
 
   SBAddress sb_addr;

lldb/trunk/source/API/SBInstructionList.cpp

if (this != &rhs)
     m_opaque_sp = rhs.m_opaque_sp;
   return *this;
 }
 
 SBInstructionList::~SBInstructionList() {}
 
 bool SBInstructionList::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBInstructionList, IsValid);
+  return this->operator bool();
+}
+SBInstructionList::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBInstructionList, operator bool);
 
   return m_opaque_sp.get() != NULL;
 }
 
 size_t SBInstructionList::GetSize() {
   LLDB_RECORD_METHOD_NO_ARGS(size_t, SBInstructionList, GetSize);
 
   if (m_opaque_sp)

lldb/trunk/source/API/SBLineEntry.cpp

if (m_opaque_up) {
     sb_address.SetAddress(&m_opaque_up->range.GetBaseAddress());
     sb_address.OffsetAddress(m_opaque_up->range.GetByteSize());
   }
   return LLDB_RECORD_RESULT(sb_address);
 }
 
 bool SBLineEntry::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBLineEntry, IsValid);
+  return this->operator bool();
+}
+SBLineEntry::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBLineEntry, operator bool);
 
   return m_opaque_up.get() && m_opaque_up->IsValid();
 }
 
 SBFileSpec SBLineEntry::GetFileSpec() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBLineEntry, GetFileSpec);
 
   SBFileSpec sb_file_spec;

lldb/trunk/source/API/SBListener.cpp

 
 SBListener::SBListener(const lldb::ListenerSP &listener_sp)
     : m_opaque_sp(listener_sp), m_unused_ptr(nullptr) {}
 
 SBListener::~SBListener() {}
 
 bool SBListener::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBListener, IsValid);
+  return this->operator bool();
+}
+SBListener::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBListener, operator bool);
 
   return m_opaque_sp != nullptr;
 }
 
 void SBListener::AddEvent(const SBEvent &event) {
   LLDB_RECORD_METHOD(void, SBListener, AddEvent, (const lldb::SBEvent &),
                      event);
 

lldb/trunk/source/API/SBModule.cpp

if (this != &rhs)
     m_opaque_sp = rhs.m_opaque_sp;
   return *this;
 }
 
 SBModule::~SBModule() {}
 
 bool SBModule::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBModule, IsValid);
+  return this->operator bool();
+}
+SBModule::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBModule, operator bool);
 
   return m_opaque_sp.get() != NULL;
 }
 
 void SBModule::Clear() {
   LLDB_RECORD_METHOD_NO_ARGS(void, SBModule, Clear);
 
   m_opaque_sp.reset();

lldb/trunk/source/API/SBModuleSpec.cpp

if (this != &rhs)
     m_opaque_up = clone(rhs.m_opaque_up);
   return *this;
 }
 
 SBModuleSpec::~SBModuleSpec() {}
 
 bool SBModuleSpec::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBModuleSpec, IsValid);
+  return this->operator bool();
+}
+SBModuleSpec::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBModuleSpec, operator bool);
 
   return m_opaque_up->operator bool();
 }
 
 void SBModuleSpec::Clear() {
   LLDB_RECORD_METHOD_NO_ARGS(void, SBModuleSpec, Clear);
 
   m_opaque_up->Clear();

lldb/trunk/source/API/SBPlatform.cpp

SBPlatform::SBPlatform(const char *platform_name) : m_opaque_sp() {
   if (platform_name && platform_name[0])
     m_opaque_sp = Platform::Create(ConstString(platform_name), error);
 }
 
 SBPlatform::~SBPlatform() {}
 
 bool SBPlatform::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBPlatform, IsValid);
+  return this->operator bool();
+}
+SBPlatform::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBPlatform, operator bool);
 
   return m_opaque_sp.get() != NULL;
 }
 
 void SBPlatform::Clear() {
   LLDB_RECORD_METHOD_NO_ARGS(void, SBPlatform, Clear);
 
   m_opaque_sp.reset();

lldb/trunk/source/API/SBProcess.cpp

 void SBProcess::Clear() {
   LLDB_RECORD_METHOD_NO_ARGS(void, SBProcess, Clear);
 
   m_opaque_wp.reset();
 }
 
 bool SBProcess::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBProcess, IsValid);
+  return this->operator bool();
+}
+SBProcess::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBProcess, operator bool);
 
   ProcessSP process_sp(m_opaque_wp.lock());
   return ((bool)process_sp && process_sp->IsValid());
 }
 
 bool SBProcess::RemoteLaunch(char const **argv, char const **envp,
                              const char *stdin_path, const char *stdout_path,
                              const char *stderr_path,

lldb/trunk/source/API/SBProcessInfo.cpp

 }
 
 void SBProcessInfo::SetProcessInfo(const ProcessInstanceInfo &proc_info_ref) {
   ref() = proc_info_ref;
 }
 
 bool SBProcessInfo::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBProcessInfo, IsValid);
+  return this->operator bool();
+}
+SBProcessInfo::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBProcessInfo, operator bool);
 
   return m_opaque_up != nullptr;
 }
 
 const char *SBProcessInfo::GetName() {
   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBProcessInfo, GetName);
 
   const char *name = nullptr;

lldb/trunk/source/API/SBQueue.cpp

const lldb::SBQueue &SBQueue::operator=(const lldb::SBQueue &rhs) {
   m_opaque_sp = rhs.m_opaque_sp;
   return *this;
 }
 
 SBQueue::~SBQueue() {}
 
 bool SBQueue::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBQueue, IsValid);
+  return this->operator bool();
+}
+SBQueue::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBQueue, operator bool);
 
   return m_opaque_sp->IsValid();
 }
 
 void SBQueue::Clear() {
   LLDB_RECORD_METHOD_NO_ARGS(void, SBQueue, Clear);
 
   m_opaque_sp->Clear();

lldb/trunk/source/API/SBQueueItem.cpp

 
 //----------------------------------------------------------------------
 // Destructor
 //----------------------------------------------------------------------
 SBQueueItem::~SBQueueItem() { m_queue_item_sp.reset(); }
 
 bool SBQueueItem::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBQueueItem, IsValid);
+  return this->operator bool();
+}
+SBQueueItem::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBQueueItem, operator bool);
 
   return m_queue_item_sp.get() != NULL;
 }
 
 void SBQueueItem::Clear() {
   LLDB_RECORD_METHOD_NO_ARGS(void, SBQueueItem, Clear);
 
   m_queue_item_sp.reset();

lldb/trunk/source/API/SBReproducer.cpp

SBRegistry::SBRegistry() {
   {
     LLDB_REGISTER_CONSTRUCTOR(SBAddress, ());
     LLDB_REGISTER_CONSTRUCTOR(SBAddress, (const lldb::SBAddress &));
     LLDB_REGISTER_CONSTRUCTOR(SBAddress, (lldb::SBSection, lldb::addr_t));
     LLDB_REGISTER_CONSTRUCTOR(SBAddress, (lldb::addr_t, lldb::SBTarget &));
     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));
     LLDB_REGISTER_METHOD_CONST(lldb::addr_t, SBAddress, GetFileAddress, ());
     LLDB_REGISTER_METHOD_CONST(lldb::addr_t, SBAddress, GetLoadAddress,
                                (const lldb::SBTarget &));
     LLDB_REGISTER_METHOD(void, SBAddress, SetLoadAddress,
                          (lldb::addr_t, lldb::SBTarget &));
Register<bool(char *, size_t)>(static_cast<bool (*)(char *, size_t)>(
     LLDB_REGISTER_METHOD(void, SBAttachInfo, SetListener, (lldb::SBListener &));
   }
   {
     LLDB_REGISTER_CONSTRUCTOR(SBBlock, ());
     LLDB_REGISTER_CONSTRUCTOR(SBBlock, (const lldb::SBBlock &));
     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,
                                GetInlinedCallSiteFile, ());
     LLDB_REGISTER_METHOD_CONST(uint32_t, SBBlock, GetInlinedCallSiteLine, ());
     LLDB_REGISTER_METHOD_CONST(uint32_t, SBBlock, GetInlinedCallSiteColumn, ());
     LLDB_REGISTER_METHOD(lldb::SBBlock, SBBlock, GetParent, ());
     LLDB_REGISTER_METHOD(lldb::SBBlock, SBBlock, GetContainingInlinedBlock, ());
Register<bool(char *, size_t)>(static_cast<bool (*)(char *, size_t)>(
     LLDB_REGISTER_METHOD(const lldb::SBBreakpoint &,
                          SBBreakpoint, operator=,(const lldb::SBBreakpoint &));
     LLDB_REGISTER_METHOD(bool,
                          SBBreakpoint, operator==,(const lldb::SBBreakpoint &));
     LLDB_REGISTER_METHOD(bool,
                          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));
     LLDB_REGISTER_METHOD(lldb::break_id_t, SBBreakpoint,
                          FindLocationIDByAddress, (lldb::addr_t));
     LLDB_REGISTER_METHOD(lldb::SBBreakpointLocation, SBBreakpoint,
                          FindLocationByID, (lldb::break_id_t));
     LLDB_REGISTER_METHOD(lldb::SBBreakpointLocation, SBBreakpoint,
Register<bool(char *, size_t)>(static_cast<bool (*)(char *, size_t)>(
     LLDB_REGISTER_CONSTRUCTOR(SBBreakpointLocation,
                               (const lldb::BreakpointLocationSP &));
     LLDB_REGISTER_CONSTRUCTOR(SBBreakpointLocation,
                               (const lldb::SBBreakpointLocation &));
     LLDB_REGISTER_METHOD(
         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,
                          ());
     LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetEnabled, (bool));
     LLDB_REGISTER_METHOD(bool, SBBreakpointLocation, IsEnabled, ());
     LLDB_REGISTER_METHOD(uint32_t, SBBreakpointLocation, GetHitCount, ());
     LLDB_REGISTER_METHOD(uint32_t, SBBreakpointLocation, GetIgnoreCount, ());
     LLDB_REGISTER_METHOD(void, SBBreakpointLocation, SetIgnoreCount,
Register<bool(char *, size_t)>(static_cast<bool (*)(char *, size_t)>(
     LLDB_REGISTER_METHOD(
         const lldb::SBBreakpointName &,
         SBBreakpointName, operator=,(const lldb::SBBreakpointName &));
     LLDB_REGISTER_METHOD(
         bool, SBBreakpointName, operator==,(const lldb::SBBreakpointName &));
     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, ());
     LLDB_REGISTER_METHOD(void, SBBreakpointName, SetOneShot, (bool));
     LLDB_REGISTER_METHOD_CONST(bool, SBBreakpointName, IsOneShot, ());
     LLDB_REGISTER_METHOD(void, SBBreakpointName, SetIgnoreCount, (uint32_t));
     LLDB_REGISTER_METHOD_CONST(uint32_t, SBBreakpointName, GetIgnoreCount, ());
     LLDB_REGISTER_METHOD(void, SBBreakpointName, SetCondition, (const char *));
Register<bool(char *, size_t)>(static_cast<bool (*)(char *, size_t)>(
     LLDB_REGISTER_METHOD(uint32_t, SBBroadcaster, AddListener,
                          (const lldb::SBListener &, uint32_t));
     LLDB_REGISTER_METHOD_CONST(const char *, SBBroadcaster, GetName, ());
     LLDB_REGISTER_METHOD(bool, SBBroadcaster, EventTypeHasListeners,
                          (uint32_t));
     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 &));
     LLDB_REGISTER_METHOD_CONST(
         bool, SBBroadcaster, operator!=,(const lldb::SBBroadcaster &));
     LLDB_REGISTER_METHOD_CONST(
         bool, SBBroadcaster, operator<,(const lldb::SBBroadcaster &));
   }
Register<bool(char *, size_t)>(static_cast<bool (*)(char *, size_t)>(
     LLDB_REGISTER_CONSTRUCTOR(SBCommandInterpreter,
                               (lldb_private::CommandInterpreter *));
     LLDB_REGISTER_CONSTRUCTOR(SBCommandInterpreter,
                               (const lldb::SBCommandInterpreter &));
     LLDB_REGISTER_METHOD(
         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,
                          (const char *));
     LLDB_REGISTER_METHOD(bool, SBCommandInterpreter, IsActive, ());
     LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreter, WasInterrupted, ());
     LLDB_REGISTER_METHOD(const char *, SBCommandInterpreter,
                          GetIOHandlerControlSequence, (char));
Register<bool(char *, size_t)>(static_cast<bool (*)(char *, size_t)>(
     LLDB_REGISTER_METHOD(
         lldb::SBCommand, SBCommandInterpreter, AddCommand,
         (const char *, lldb::SBCommandPluginInterface *, const char *));
     LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommandInterpreter, AddCommand,
                          (const char *, lldb::SBCommandPluginInterface *,
                           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, ());
     LLDB_REGISTER_METHOD(void, SBCommand, SetHelp, (const char *));
     LLDB_REGISTER_METHOD(void, SBCommand, SetHelpLong, (const char *));
     LLDB_REGISTER_METHOD(lldb::SBCommand, SBCommand, AddMultiwordCommand,
                          (const char *, const char *));
     LLDB_REGISTER_METHOD(
Register<bool(char *, size_t)>(static_cast<bool (*)(char *, size_t)>(
     LLDB_REGISTER_CONSTRUCTOR(SBCommandReturnObject,
                               (lldb_private::CommandReturnObject *));
     LLDB_REGISTER_METHOD(lldb_private::CommandReturnObject *,
                          SBCommandReturnObject, Release, ());
     LLDB_REGISTER_METHOD(
         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, ());
     LLDB_REGISTER_METHOD(size_t, SBCommandReturnObject, GetErrorSize, ());
     LLDB_REGISTER_METHOD(size_t, SBCommandReturnObject, PutOutput, (FILE *));
     LLDB_REGISTER_METHOD(size_t, SBCommandReturnObject, PutError, (FILE *));
     LLDB_REGISTER_METHOD(void, SBCommandReturnObject, Clear, ());
     LLDB_REGISTER_METHOD(lldb::ReturnStatus, SBCommandReturnObject, GetStatus,
Register<bool(char *, size_t)>(static_cast<bool (*)(char *, size_t)>(
     LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetError,
                          (lldb::SBError &, const char *));
     LLDB_REGISTER_METHOD(void, SBCommandReturnObject, SetError, (const char *));
   }
   {
     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,
                          (const char *));
     LLDB_REGISTER_METHOD(lldb::ConnectionStatus, SBCommunication,
                          AdoptFileDesriptor, (int, bool));
     LLDB_REGISTER_METHOD(lldb::ConnectionStatus, SBCommunication, Disconnect,
                          ());
Register<bool(char *, size_t)>(static_cast<bool (*)(char *, size_t)>(
     LLDB_REGISTER_METHOD_CONST(uint32_t, SBCompileUnit, GetNumSupportFiles, ());
     LLDB_REGISTER_METHOD(lldb::SBTypeList, SBCompileUnit, GetTypes, (uint32_t));
     LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBCompileUnit,
                                GetSupportFileAtIndex, (uint32_t));
     LLDB_REGISTER_METHOD(uint32_t, SBCompileUnit, FindSupportFileIndex,
                          (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(
         bool, SBCompileUnit, operator!=,(const lldb::SBCompileUnit &));
     LLDB_REGISTER_METHOD(bool, SBCompileUnit, GetDescription,
                          (lldb::SBStream &));
   }
   {
     LLDB_REGISTER_CONSTRUCTOR(SBData, ());
     LLDB_REGISTER_CONSTRUCTOR(SBData, (const lldb::SBData &));
     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, ());
     LLDB_REGISTER_METHOD(size_t, SBData, GetByteSize, ());
     LLDB_REGISTER_METHOD(lldb::ByteOrder, SBData, GetByteOrder, ());
     LLDB_REGISTER_METHOD(void, SBData, SetByteOrder, (lldb::ByteOrder));
     LLDB_REGISTER_METHOD(float, SBData, GetFloat,
                          (lldb::SBError &, lldb::offset_t));
Register<bool(char *, size_t)>(static_cast<bool (*)(char *, size_t)>(
     LLDB_REGISTER_STATIC_METHOD(void, SBDebugger, Terminate, ());
     LLDB_REGISTER_METHOD(void, SBDebugger, Clear, ());
     LLDB_REGISTER_STATIC_METHOD(lldb::SBDebugger, SBDebugger, Create, ());
     LLDB_REGISTER_STATIC_METHOD(lldb::SBDebugger, SBDebugger, Create, (bool));
     LLDB_REGISTER_STATIC_METHOD(void, SBDebugger, Destroy,
                                 (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));
     LLDB_REGISTER_METHOD(void, SBDebugger, SkipAppInitFiles, (bool));
     LLDB_REGISTER_METHOD(void, SBDebugger, SetInputFileHandle, (FILE *, bool));
     LLDB_REGISTER_METHOD(FILE *, SBDebugger, GetInputFileHandle, ());
     LLDB_REGISTER_METHOD(FILE *, SBDebugger, GetOutputFileHandle, ());
     LLDB_REGISTER_METHOD(FILE *, SBDebugger, GetErrorFileHandle, ());
#endif
   }
   {
     LLDB_REGISTER_CONSTRUCTOR(SBDeclaration, ());
     LLDB_REGISTER_CONSTRUCTOR(SBDeclaration, (const lldb::SBDeclaration &));
     LLDB_REGISTER_METHOD(
         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, ());
     LLDB_REGISTER_METHOD_CONST(uint32_t, SBDeclaration, GetColumn, ());
     LLDB_REGISTER_METHOD(void, SBDeclaration, SetFileSpec, (lldb::SBFileSpec));
     LLDB_REGISTER_METHOD(void, SBDeclaration, SetLine, (uint32_t));
     LLDB_REGISTER_METHOD(void, SBDeclaration, SetColumn, (uint32_t));
     LLDB_REGISTER_METHOD_CONST(
#endif
     LLDB_REGISTER_METHOD_CONST(bool, SBError, Success, ());
     LLDB_REGISTER_METHOD_CONST(uint32_t, SBError, GetError, ());
     LLDB_REGISTER_METHOD_CONST(lldb::ErrorType, SBError, GetType, ());
     LLDB_REGISTER_METHOD(void, SBError, SetError, (uint32_t, lldb::ErrorType));
     LLDB_REGISTER_METHOD(void, SBError, SetErrorToErrno, ());
     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 &));
   }
   {
     LLDB_REGISTER_CONSTRUCTOR(SBEvent, ());
     LLDB_REGISTER_CONSTRUCTOR(SBEvent, (uint32_t, const char *, uint32_t));
     LLDB_REGISTER_CONSTRUCTOR(SBEvent, (lldb::EventSP &));
     LLDB_REGISTER_CONSTRUCTOR(SBEvent, (lldb_private::Event *));
     LLDB_REGISTER_CONSTRUCTOR(SBEvent, (const lldb::SBEvent &));
     LLDB_REGISTER_METHOD(const lldb::SBEvent &,
                          SBEvent, operator=,(const lldb::SBEvent &));
     LLDB_REGISTER_METHOD(const char *, SBEvent, GetDataFlavor, ());
     LLDB_REGISTER_METHOD_CONST(uint32_t, SBEvent, GetType, ());
     LLDB_REGISTER_METHOD_CONST(lldb::SBBroadcaster, SBEvent, GetBroadcaster,
                                ());
     LLDB_REGISTER_METHOD_CONST(const char *, SBEvent, GetBroadcasterClass, ());
     LLDB_REGISTER_METHOD(bool, SBEvent, BroadcasterMatchesPtr,
                          (const lldb::SBBroadcaster *));
     LLDB_REGISTER_METHOD(bool, SBEvent, BroadcasterMatchesRef,
                          (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 &));
     LLDB_REGISTER_METHOD_CONST(bool, SBEvent, GetDescription,
                                (lldb::SBStream &));
   }
   {
     LLDB_REGISTER_CONSTRUCTOR(SBExecutionContext, ());
#endif
   {
     LLDB_REGISTER_CONSTRUCTOR(SBFileSpec, ());
     LLDB_REGISTER_CONSTRUCTOR(SBFileSpec, (const lldb::SBFileSpec &));
     LLDB_REGISTER_CONSTRUCTOR(SBFileSpec, (const char *));
     LLDB_REGISTER_CONSTRUCTOR(SBFileSpec, (const char *, bool));
     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,
                                 (const char *, char *, size_t));
     LLDB_REGISTER_METHOD_CONST(const char *, SBFileSpec, GetFilename, ());
     LLDB_REGISTER_METHOD_CONST(const char *, SBFileSpec, GetDirectory, ());
     LLDB_REGISTER_METHOD(void, SBFileSpec, SetFilename, (const char *));
     LLDB_REGISTER_METHOD(void, SBFileSpec, SetDirectory, (const char *));
#endif
   }
   {
     LLDB_REGISTER_CONSTRUCTOR(SBFrame, ());
     LLDB_REGISTER_CONSTRUCTOR(SBFrame, (const lldb::StackFrameSP &));
     LLDB_REGISTER_CONSTRUCTOR(SBFrame, (const lldb::SBFrame &));
     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, ());
     LLDB_REGISTER_METHOD_CONST(lldb::SBCompileUnit, SBFrame, GetCompileUnit,
                                ());
     LLDB_REGISTER_METHOD_CONST(lldb::SBFunction, SBFrame, GetFunction, ());
     LLDB_REGISTER_METHOD_CONST(lldb::SBSymbol, SBFrame, GetSymbol, ());
     LLDB_REGISTER_METHOD_CONST(lldb::SBBlock, SBFrame, GetBlock, ());
#endif
     LLDB_REGISTER_METHOD(const char *, SBFrame, GetDisplayFunctionName, ());
   }
   {
     LLDB_REGISTER_CONSTRUCTOR(SBFunction, ());
     LLDB_REGISTER_CONSTRUCTOR(SBFunction, (const lldb::SBFunction &));
     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, ());
     LLDB_REGISTER_METHOD_CONST(
         bool, SBFunction, operator==,(const lldb::SBFunction &));
     LLDB_REGISTER_METHOD_CONST(
         bool, SBFunction, operator!=,(const lldb::SBFunction &));
     LLDB_REGISTER_METHOD(bool, SBFunction, GetDescription, (lldb::SBStream &));
#endif
   }
   {
     LLDB_REGISTER_CONSTRUCTOR(SBInstruction, ());
     LLDB_REGISTER_CONSTRUCTOR(SBInstruction, (const lldb::SBInstruction &));
     LLDB_REGISTER_METHOD(
         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));
     LLDB_REGISTER_METHOD(const char *, SBInstruction, GetOperands,
                          (lldb::SBTarget));
     LLDB_REGISTER_METHOD(const char *, SBInstruction, GetComment,
                          (lldb::SBTarget));
     LLDB_REGISTER_METHOD(size_t, SBInstruction, GetByteSize, ());
#endif
   {
     LLDB_REGISTER_CONSTRUCTOR(SBInstructionList, ());
     LLDB_REGISTER_CONSTRUCTOR(SBInstructionList,
                               (const lldb::SBInstructionList &));
     LLDB_REGISTER_METHOD(
         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));
     LLDB_REGISTER_METHOD(
         size_t, SBInstructionList, GetInstructionsCount,
         (const lldb::SBAddress &, const lldb::SBAddress &, bool));
     LLDB_REGISTER_METHOD(void, SBInstructionList, Clear, ());
     LLDB_REGISTER_METHOD(void, SBInstructionList, AppendInstruction,
#endif
     LLDB_REGISTER_CONSTRUCTOR(SBLineEntry, ());
     LLDB_REGISTER_CONSTRUCTOR(SBLineEntry, (const lldb::SBLineEntry &));
     LLDB_REGISTER_METHOD(const lldb::SBLineEntry &,
                          SBLineEntry, operator=,(const lldb::SBLineEntry &));
     LLDB_REGISTER_METHOD_CONST(lldb::SBAddress, SBLineEntry, GetStartAddress,
                                ());
     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, ());
     LLDB_REGISTER_METHOD(void, SBLineEntry, SetFileSpec, (lldb::SBFileSpec));
     LLDB_REGISTER_METHOD(void, SBLineEntry, SetLine, (uint32_t));
     LLDB_REGISTER_METHOD(void, SBLineEntry, SetColumn, (uint32_t));
     LLDB_REGISTER_METHOD_CONST(
         bool, SBLineEntry, operator==,(const lldb::SBLineEntry &));
     LLDB_REGISTER_METHOD_CONST(
         bool, SBLineEntry, operator!=,(const lldb::SBLineEntry &));
     LLDB_REGISTER_METHOD(bool, SBLineEntry, GetDescription, (lldb::SBStream &));
   }
   {
     LLDB_REGISTER_CONSTRUCTOR(SBListener, ());
     LLDB_REGISTER_CONSTRUCTOR(SBListener, (const char *));
     LLDB_REGISTER_CONSTRUCTOR(SBListener, (const lldb::SBListener &));
     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,
                          (lldb::SBDebugger &, const char *, uint32_t));
     LLDB_REGISTER_METHOD(bool, SBListener, StopListeningForEventClass,
                          (lldb::SBDebugger &, const char *, uint32_t));
     LLDB_REGISTER_METHOD(uint32_t, SBListener, StartListeningForEvents,
                          (const lldb::SBBroadcaster &, uint32_t));
#endif
   {
     LLDB_REGISTER_CONSTRUCTOR(SBModule, ());
     LLDB_REGISTER_CONSTRUCTOR(SBModule, (const lldb::SBModuleSpec &));
     LLDB_REGISTER_CONSTRUCTOR(SBModule, (const lldb::SBModule &));
     LLDB_REGISTER_CONSTRUCTOR(SBModule, (lldb::SBProcess &, lldb::addr_t));
     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,
                                ());
     LLDB_REGISTER_METHOD(bool, SBModule, SetPlatformFileSpec,
                          (const lldb::SBFileSpec &));
     LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBModule, GetRemoteInstallFileSpec,
                          ());
LLDB_REGISTER_METHOD_CONST(lldb::SBAddress, SBModule,
                                GetObjectFileEntryPointAddress, ());
   }
   {
     LLDB_REGISTER_CONSTRUCTOR(SBModuleSpec, ());
     LLDB_REGISTER_CONSTRUCTOR(SBModuleSpec, (const lldb::SBModuleSpec &));
     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,
                          (const lldb::SBFileSpec &));
     LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBModuleSpec, GetPlatformFileSpec,
                          ());
     LLDB_REGISTER_METHOD(void, SBModuleSpec, SetPlatformFileSpec,
                          (const lldb::SBFileSpec &));
#endif
     LLDB_REGISTER_METHOD(void, SBPlatformShellCommand, SetTimeoutSeconds,
                          (uint32_t));
     LLDB_REGISTER_METHOD(int, SBPlatformShellCommand, GetSignal, ());
     LLDB_REGISTER_METHOD(int, SBPlatformShellCommand, GetStatus, ());
     LLDB_REGISTER_METHOD(const char *, SBPlatformShellCommand, GetOutput, ());
     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, ());
     LLDB_REGISTER_METHOD(bool, SBPlatform, SetWorkingDirectory, (const char *));
     LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, ConnectRemote,
                          (lldb::SBPlatformConnectOptions &));
     LLDB_REGISTER_METHOD(void, SBPlatform, DisconnectRemote, ());
     LLDB_REGISTER_METHOD(bool, SBPlatform, IsConnected, ());
#endif
     LLDB_REGISTER_METHOD(const lldb::SBProcess &,
                          SBProcess, operator=,(const lldb::SBProcess &));
     LLDB_REGISTER_STATIC_METHOD(const char *, SBProcess,
                                 GetBroadcasterClassName, ());
     LLDB_REGISTER_METHOD(const char *, SBProcess, GetPluginName, ());
     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,
                           bool, lldb::SBError &));
     LLDB_REGISTER_METHOD(bool, SBProcess, RemoteAttachToProcessWithID,
                          (lldb::pid_t, lldb::SBError &));
     LLDB_REGISTER_METHOD(uint32_t, SBProcess, GetNumThreads, ());
     LLDB_REGISTER_METHOD_CONST(lldb::SBThread, SBProcess, GetSelectedThread,
#endif
   }
   {
     LLDB_REGISTER_CONSTRUCTOR(SBProcessInfo, ());
     LLDB_REGISTER_CONSTRUCTOR(SBProcessInfo, (const lldb::SBProcessInfo &));
     LLDB_REGISTER_METHOD(
         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,
                          ());
     LLDB_REGISTER_METHOD(lldb::pid_t, SBProcessInfo, GetProcessID, ());
     LLDB_REGISTER_METHOD(uint32_t, SBProcessInfo, GetUserID, ());
     LLDB_REGISTER_METHOD(uint32_t, SBProcessInfo, GetGroupID, ());
     LLDB_REGISTER_METHOD(bool, SBProcessInfo, UserIDIsValid, ());
     LLDB_REGISTER_METHOD(bool, SBProcessInfo, GroupIDIsValid, ());
     LLDB_REGISTER_METHOD(uint32_t, SBProcessInfo, GetEffectiveUserID, ());
     LLDB_REGISTER_METHOD(uint32_t, SBProcessInfo, GetEffectiveGroupID, ());
     LLDB_REGISTER_METHOD(bool, SBProcessInfo, EffectiveUserIDIsValid, ());
     LLDB_REGISTER_METHOD(bool, SBProcessInfo, EffectiveGroupIDIsValid, ());
     LLDB_REGISTER_METHOD(lldb::pid_t, SBProcessInfo, GetParentProcessID, ());
   }
   {
     LLDB_REGISTER_CONSTRUCTOR(SBQueue, ());
     LLDB_REGISTER_CONSTRUCTOR(SBQueue, (const lldb::QueueSP &));
     LLDB_REGISTER_CONSTRUCTOR(SBQueue, (const lldb::SBQueue &));
     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, ());
     LLDB_REGISTER_METHOD_CONST(const char *, SBQueue, GetName, ());
     LLDB_REGISTER_METHOD(uint32_t, SBQueue, GetNumThreads, ());
     LLDB_REGISTER_METHOD(lldb::SBThread, SBQueue, GetThreadAtIndex, (uint32_t));
     LLDB_REGISTER_METHOD(uint32_t, SBQueue, GetNumPendingItems, ());
     LLDB_REGISTER_METHOD(lldb::SBQueueItem, SBQueue, GetPendingItemAtIndex,
                          (uint32_t));
     LLDB_REGISTER_METHOD(uint32_t, SBQueue, GetNumRunningItems, ());
     LLDB_REGISTER_METHOD(lldb::SBProcess, SBQueue, GetProcess, ());
     LLDB_REGISTER_METHOD(lldb::QueueKind, SBQueue, GetKind, ());
   }
   {
     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 &));
     LLDB_REGISTER_METHOD_CONST(lldb::QueueItemKind, SBQueueItem, GetKind, ());
     LLDB_REGISTER_METHOD(void, SBQueueItem, SetKind, (lldb::QueueItemKind));
     LLDB_REGISTER_METHOD_CONST(lldb::SBAddress, SBQueueItem, GetAddress, ());
     LLDB_REGISTER_METHOD(void, SBQueueItem, SetAddress, (lldb::SBAddress));
     LLDB_REGISTER_METHOD(lldb::SBThread, SBQueueItem,
                          GetExtendedBacktraceThread, (const char *));
   }
   {
     LLDB_REGISTER_CONSTRUCTOR(SBSection, ());
     LLDB_REGISTER_CONSTRUCTOR(SBSection, (const lldb::SBSection &));
     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,
                          (const char *));
     LLDB_REGISTER_METHOD(size_t, SBSection, GetNumSubSections, ());
     LLDB_REGISTER_METHOD(lldb::SBSection, SBSection, GetSubSectionAtIndex,
                          (size_t));
     LLDB_REGISTER_METHOD(lldb::addr_t, SBSection, GetFileAddress, ());
#endif
     LLDB_REGISTER_METHOD(size_t, SBSourceManager,
                          DisplaySourceLinesWithLineNumbersAndColumn,
                          (const lldb::SBFileSpec &, uint32_t, uint32_t,
                           uint32_t, uint32_t, const char *, lldb::SBStream &));
   }
   {
     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));
     LLDB_REGISTER_METHOD(void, SBStream, RedirectToFileHandle, (FILE *, bool));
     LLDB_REGISTER_METHOD(void, SBStream, RedirectToFileDescriptor, (int, bool));
     LLDB_REGISTER_METHOD(void, SBStream, Clear, ());
   }
   {
     LLDB_REGISTER_CONSTRUCTOR(SBStringList, ());
     LLDB_REGISTER_CONSTRUCTOR(SBStringList, (const lldb::SBStringList &));
     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,
                          (const lldb::SBStringList &));
     LLDB_REGISTER_METHOD_CONST(uint32_t, SBStringList, GetSize, ());
     LLDB_REGISTER_METHOD(const char *, SBStringList, GetStringAtIndex,
                          (size_t));
     LLDB_REGISTER_METHOD_CONST(const char *, SBStringList, GetStringAtIndex,
                                (size_t));
     LLDB_REGISTER_METHOD(void, SBStringList, Clear, ());
   }
   {
     LLDB_REGISTER_CONSTRUCTOR(SBStructuredData, ());
     LLDB_REGISTER_CONSTRUCTOR(SBStructuredData,
                               (const lldb::SBStructuredData &));
     LLDB_REGISTER_CONSTRUCTOR(SBStructuredData, (const lldb::EventSP &));
     LLDB_REGISTER_CONSTRUCTOR(SBStructuredData,
                               (lldb_private::StructuredDataImpl *));
     LLDB_REGISTER_METHOD(
         lldb::SBStructuredData &,
         SBStructuredData, operator=,(const lldb::SBStructuredData &));
     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 &));
     LLDB_REGISTER_METHOD_CONST(lldb::SBError, SBStructuredData, GetDescription,
                                (lldb::SBStream &));
     LLDB_REGISTER_METHOD_CONST(lldb::StructuredDataType, SBStructuredData,
                                GetType, ());
     LLDB_REGISTER_METHOD_CONST(size_t, SBStructuredData, GetSize, ());
LLDB_REGISTER_METHOD_CONST(size_t, SBStructuredData, GetStringValue,
                                (char *, size_t));
   }
   {
     LLDB_REGISTER_CONSTRUCTOR(SBSymbol, ());
     LLDB_REGISTER_CONSTRUCTOR(SBSymbol, (const lldb::SBSymbol &));
     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, ());
     LLDB_REGISTER_METHOD_CONST(bool,
                                SBSymbol, operator==,(const lldb::SBSymbol &));
     LLDB_REGISTER_METHOD_CONST(bool,
                                SBSymbol, operator!=,(const lldb::SBSymbol &));
     LLDB_REGISTER_METHOD(bool, SBSymbol, GetDescription, (lldb::SBStream &));

     LLDB_REGISTER_CONSTRUCTOR(SBSymbolContext, ());
     LLDB_REGISTER_CONSTRUCTOR(SBSymbolContext,
                               (const lldb_private::SymbolContext *));
     LLDB_REGISTER_CONSTRUCTOR(SBSymbolContext, (const lldb::SBSymbolContext &));
     LLDB_REGISTER_METHOD(
         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,
                          ());
     LLDB_REGISTER_METHOD(lldb::SBFunction, SBSymbolContext, GetFunction, ());
     LLDB_REGISTER_METHOD(lldb::SBBlock, SBSymbolContext, GetBlock, ());
     LLDB_REGISTER_METHOD(lldb::SBLineEntry, SBSymbolContext, GetLineEntry, ());
     LLDB_REGISTER_METHOD(lldb::SBSymbol, SBSymbolContext, GetSymbol, ());
     LLDB_REGISTER_METHOD(void, SBSymbolContext, SetModule, (lldb::SBModule));

     LLDB_REGISTER_METHOD(lldb::SBSymbolContext, SBSymbolContextList,
                          GetContextAtIndex, (uint32_t));
     LLDB_REGISTER_METHOD(void, SBSymbolContextList, Clear, ());
     LLDB_REGISTER_METHOD(void, SBSymbolContextList, Append,
                          (lldb::SBSymbolContext &));
     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 &));
   }
   {
     LLDB_REGISTER_CONSTRUCTOR(SBTarget, ());
     LLDB_REGISTER_CONSTRUCTOR(SBTarget, (const lldb::SBTarget &));
     LLDB_REGISTER_CONSTRUCTOR(SBTarget, (const lldb::TargetSP &));
     LLDB_REGISTER_METHOD(const lldb::SBTarget &,
                          SBTarget, operator=,(const lldb::SBTarget &));
     LLDB_REGISTER_STATIC_METHOD(bool, SBTarget, EventIsTargetEvent,
                                 (const lldb::SBEvent &));
     LLDB_REGISTER_STATIC_METHOD(lldb::SBTarget, SBTarget, GetTargetFromEvent,
                                 (const lldb::SBEvent &));
     LLDB_REGISTER_STATIC_METHOD(uint32_t, SBTarget, GetNumModulesFromEvent,
                                 (const lldb::SBEvent &));
     LLDB_REGISTER_STATIC_METHOD(lldb::SBModule, SBTarget,
                                 GetModuleAtIndexFromEvent,
                                 (const uint32_t, const lldb::SBEvent &));
     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, ());
     LLDB_REGISTER_METHOD(lldb::SBStructuredData, SBTarget, GetStatistics, ());
     LLDB_REGISTER_METHOD(void, SBTarget, SetCollectingStats, (bool));
     LLDB_REGISTER_METHOD(bool, SBTarget, GetCollectingStats, ());
     LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, LoadCore, (const char *));
     LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, LoadCore,
LLDB_REGISTER_STATIC_METHOD(const char *, SBThread, GetBroadcasterClassName,
                                 ());
     LLDB_REGISTER_CONSTRUCTOR(SBThread, ());
     LLDB_REGISTER_CONSTRUCTOR(SBThread, (const lldb::ThreadSP &));
     LLDB_REGISTER_CONSTRUCTOR(SBThread, (const lldb::SBThread &));
     LLDB_REGISTER_METHOD(const lldb::SBThread &,
                          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, ());
     LLDB_REGISTER_METHOD(uint64_t, SBThread, GetStopReasonDataAtIndex,
                          (uint32_t));
     LLDB_REGISTER_METHOD(bool, SBThread, GetStopReasonExtendedInfoAsJSON,
                          (lldb::SBStream &));
     LLDB_REGISTER_METHOD(lldb::SBThreadCollection, SBThread,

   {
     LLDB_REGISTER_CONSTRUCTOR(SBThreadCollection, ());
     LLDB_REGISTER_CONSTRUCTOR(SBThreadCollection,
                               (const lldb::SBThreadCollection &));
     LLDB_REGISTER_METHOD(
         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));
   }
   {
     LLDB_REGISTER_CONSTRUCTOR(SBThreadPlan, ());
     LLDB_REGISTER_CONSTRUCTOR(SBThreadPlan, (const lldb::ThreadPlanSP &));
     LLDB_REGISTER_CONSTRUCTOR(SBThreadPlan, (const lldb::SBThreadPlan &));
     LLDB_REGISTER_CONSTRUCTOR(SBThreadPlan, (lldb::SBThread &, const char *));
     LLDB_REGISTER_METHOD(const lldb::SBThreadPlan &,
                          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, ());
     LLDB_REGISTER_METHOD(uint64_t, SBThreadPlan, GetStopReasonDataAtIndex,
                          (uint32_t));
     LLDB_REGISTER_METHOD_CONST(lldb::SBThread, SBThreadPlan, GetThread, ());
     LLDB_REGISTER_METHOD_CONST(bool, SBThreadPlan, GetDescription,
                                (lldb::SBStream &));

   {
     LLDB_REGISTER_METHOD(void, SBTrace, StopTrace,
                          (lldb::SBError &, lldb::tid_t));
     LLDB_REGISTER_METHOD(void, SBTrace, GetTraceConfig,
                          (lldb::SBTraceOptions &, lldb::SBError &));
     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, ());
     LLDB_REGISTER_METHOD_CONST(lldb::TraceType, SBTraceOptions, getType, ());
     LLDB_REGISTER_METHOD_CONST(uint64_t, SBTraceOptions, getTraceBufferSize,
                                ());
     LLDB_REGISTER_METHOD(lldb::SBStructuredData, SBTraceOptions, getTraceParams,
                          (lldb::SBError &));
     LLDB_REGISTER_METHOD_CONST(uint64_t, SBTraceOptions, getMetaDataBufferSize,
                                ());
     LLDB_REGISTER_METHOD(void, SBTraceOptions, setTraceParams,
                          (lldb::SBStructuredData &));
     LLDB_REGISTER_METHOD(void, SBTraceOptions, setType, (lldb::TraceType));
     LLDB_REGISTER_METHOD(void, SBTraceOptions, setTraceBufferSize, (uint64_t));
     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, ());
   }
   {
     LLDB_REGISTER_CONSTRUCTOR(SBType, ());
     LLDB_REGISTER_CONSTRUCTOR(SBType, (const lldb::SBType &));
     LLDB_REGISTER_METHOD(bool, SBType, operator==,(lldb::SBType &));
     LLDB_REGISTER_METHOD(bool, SBType, operator!=,(lldb::SBType &));
     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, ());
     LLDB_REGISTER_METHOD(bool, SBType, IsVectorType, ());
     LLDB_REGISTER_METHOD(bool, SBType, IsReferenceType, ());
     LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetPointerType, ());
     LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetPointeeType, ());
     LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetReferenceType, ());

     LLDB_REGISTER_METHOD(uint32_t, SBType, GetNumberOfTemplateArguments, ());
     LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetTemplateArgumentType,
                          (uint32_t));
     LLDB_REGISTER_METHOD(lldb::TemplateArgumentKind, SBType,
                          GetTemplateArgumentKind, (uint32_t));
     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));
     LLDB_REGISTER_METHOD(lldb::SBType, SBTypeList, GetTypeAtIndex, (uint32_t));
     LLDB_REGISTER_METHOD(uint32_t, SBTypeList, GetSize, ());
     LLDB_REGISTER_CONSTRUCTOR(SBTypeMember, ());
     LLDB_REGISTER_CONSTRUCTOR(SBTypeMember, (const lldb::SBTypeMember &));
     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, ());
     LLDB_REGISTER_METHOD(uint64_t, SBTypeMember, GetOffsetInBits, ());
     LLDB_REGISTER_METHOD(bool, SBTypeMember, IsBitfield, ());
     LLDB_REGISTER_METHOD(uint32_t, SBTypeMember, GetBitfieldSizeInBits, ());
     LLDB_REGISTER_METHOD(bool, SBTypeMember, GetDescription,
                          (lldb::SBStream &, lldb::DescriptionLevel));
     LLDB_REGISTER_CONSTRUCTOR(SBTypeMemberFunction, ());
     LLDB_REGISTER_CONSTRUCTOR(SBTypeMemberFunction,
                               (const lldb::SBTypeMemberFunction &));
     LLDB_REGISTER_METHOD(
         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,
                          ());
     LLDB_REGISTER_METHOD(const char *, SBTypeMemberFunction, GetMangledName,
                          ());
     LLDB_REGISTER_METHOD(lldb::SBType, SBTypeMemberFunction, GetType, ());
     LLDB_REGISTER_METHOD(lldb::SBType, SBTypeMemberFunction, GetReturnType, ());
     LLDB_REGISTER_METHOD(uint32_t, SBTypeMemberFunction, GetNumberOfArguments,
                          ());
     LLDB_REGISTER_METHOD(lldb::SBType, SBTypeMemberFunction,
                          GetArgumentTypeAtIndex, (uint32_t));
     LLDB_REGISTER_METHOD(lldb::MemberFunctionKind, SBTypeMemberFunction,
                          GetKind, ());
     LLDB_REGISTER_METHOD(bool, SBTypeMemberFunction, GetDescription,
                          (lldb::SBStream &, lldb::DescriptionLevel));
   }
   {
     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, ());
     LLDB_REGISTER_METHOD(lldb::LanguageType, SBTypeCategory, GetLanguageAtIndex,
                          (uint32_t));
     LLDB_REGISTER_METHOD(uint32_t, SBTypeCategory, GetNumLanguages, ());
     LLDB_REGISTER_METHOD(void, SBTypeCategory, AddLanguage,
                          (lldb::LanguageType));
#endif
   {
     LLDB_REGISTER_CONSTRUCTOR(SBTypeEnumMember, ());
     LLDB_REGISTER_CONSTRUCTOR(SBTypeEnumMember,
                               (const lldb::SBTypeEnumMember &));
     LLDB_REGISTER_METHOD(
         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, ());
     LLDB_REGISTER_METHOD(lldb::SBType, SBTypeEnumMember, GetType, ());
     LLDB_REGISTER_CONSTRUCTOR(SBTypeEnumMemberList, ());
     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 &));
     LLDB_REGISTER_METHOD(void, SBTypeEnumMemberList, Append,
                          (lldb::SBTypeEnumMember));
     LLDB_REGISTER_METHOD(lldb::SBTypeEnumMember, SBTypeEnumMemberList,
                          GetTypeEnumMemberAtIndex, (uint32_t));
     LLDB_REGISTER_METHOD(uint32_t, SBTypeEnumMemberList, GetSize, ());
     LLDB_REGISTER_METHOD(bool, SBTypeEnumMember, GetDescription,
                          (lldb::SBStream &, lldb::DescriptionLevel));
   }
   {
     LLDB_REGISTER_CONSTRUCTOR(SBTypeFilter, ());
     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,
                          (lldb::SBStream &, lldb::DescriptionLevel));
     LLDB_REGISTER_METHOD(void, SBTypeFilter, Clear, ());
     LLDB_REGISTER_METHOD(uint32_t, SBTypeFilter, GetNumberOfExpressionPaths,
                          ());
     LLDB_REGISTER_METHOD(const char *, SBTypeFilter, GetExpressionPathAtIndex,
#endif
     LLDB_REGISTER_METHOD(bool, SBTypeFilter, operator!=,(lldb::SBTypeFilter &));
   }
   {
     LLDB_REGISTER_CONSTRUCTOR(SBTypeFormat, ());
     LLDB_REGISTER_CONSTRUCTOR(SBTypeFormat, (lldb::Format, uint32_t));
     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, ());
     LLDB_REGISTER_METHOD(void, SBTypeFormat, SetFormat, (lldb::Format));
     LLDB_REGISTER_METHOD(void, SBTypeFormat, SetTypeName, (const char *));
     LLDB_REGISTER_METHOD(void, SBTypeFormat, SetOptions, (uint32_t));
     LLDB_REGISTER_METHOD(bool, SBTypeFormat, GetDescription,
                          (lldb::SBStream &, lldb::DescriptionLevel));
     LLDB_REGISTER_METHOD(lldb::SBTypeFormat &,
                          SBTypeFormat, operator=,(const lldb::SBTypeFormat &));
     LLDB_REGISTER_METHOD(bool, SBTypeFormat, operator==,(lldb::SBTypeFormat &));
     LLDB_REGISTER_METHOD(bool, SBTypeFormat, IsEqualTo, (lldb::SBTypeFormat &));
     LLDB_REGISTER_METHOD(bool, SBTypeFormat, operator!=,(lldb::SBTypeFormat &));
   }
   {
     LLDB_REGISTER_CONSTRUCTOR(SBTypeNameSpecifier, ());
     LLDB_REGISTER_CONSTRUCTOR(SBTypeNameSpecifier, (const char *, bool));
     LLDB_REGISTER_CONSTRUCTOR(SBTypeNameSpecifier, (lldb::SBType));
     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, ());
     LLDB_REGISTER_METHOD(bool, SBTypeNameSpecifier, GetDescription,
                          (lldb::SBStream &, lldb::DescriptionLevel));
     LLDB_REGISTER_METHOD(
         lldb::SBTypeNameSpecifier &,
         SBTypeNameSpecifier, operator=,(const lldb::SBTypeNameSpecifier &));
     LLDB_REGISTER_METHOD(
         bool, SBTypeNameSpecifier, operator==,(lldb::SBTypeNameSpecifier &));
     LLDB_REGISTER_METHOD(bool, SBTypeNameSpecifier, IsEqualTo,
                          (lldb::SBTypeNameSpecifier &));
     LLDB_REGISTER_METHOD(
         bool, SBTypeNameSpecifier, operator!=,(lldb::SBTypeNameSpecifier &));
   }
   {
     LLDB_REGISTER_CONSTRUCTOR(SBTypeSummaryOptions, ());
     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,
                          GetCapping, ());
     LLDB_REGISTER_METHOD(void, SBTypeSummaryOptions, SetLanguage,
                          (lldb::LanguageType));
     LLDB_REGISTER_METHOD(void, SBTypeSummaryOptions, SetCapping,
                          (lldb::TypeSummaryCapping));
     LLDB_REGISTER_CONSTRUCTOR(SBTypeSummaryOptions,
                               (const lldb_private::TypeSummaryOptions *));
     LLDB_REGISTER_CONSTRUCTOR(SBTypeSummary, ());
     LLDB_REGISTER_STATIC_METHOD(lldb::SBTypeSummary, SBTypeSummary,
                                 CreateWithSummaryString,
                                 (const char *, uint32_t));
     LLDB_REGISTER_STATIC_METHOD(lldb::SBTypeSummary, SBTypeSummary,
                                 CreateWithFunctionName,
                                 (const char *, uint32_t));
     LLDB_REGISTER_STATIC_METHOD(lldb::SBTypeSummary, SBTypeSummary,
                                 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, ());
     LLDB_REGISTER_METHOD(const char *, SBTypeSummary, GetData, ());
     LLDB_REGISTER_METHOD(uint32_t, SBTypeSummary, GetOptions, ());
     LLDB_REGISTER_METHOD(void, SBTypeSummary, SetOptions, (uint32_t));
     LLDB_REGISTER_METHOD(void, SBTypeSummary, SetSummaryString, (const char *));
     LLDB_REGISTER_METHOD(void, SBTypeSummary, SetFunctionName, (const char *));
#ifndef LLDB_DISABLE_PYTHON
   {
     LLDB_REGISTER_CONSTRUCTOR(SBTypeSynthetic, ());
     LLDB_REGISTER_STATIC_METHOD(lldb::SBTypeSynthetic, SBTypeSynthetic,
                                 CreateWithClassName, (const char *, uint32_t));
     LLDB_REGISTER_STATIC_METHOD(lldb::SBTypeSynthetic, SBTypeSynthetic,
                                 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, ());
     LLDB_REGISTER_METHOD(void, SBTypeSynthetic, SetClassName, (const char *));
     LLDB_REGISTER_METHOD(void, SBTypeSynthetic, SetClassCode, (const char *));
     LLDB_REGISTER_METHOD(uint32_t, SBTypeSynthetic, GetOptions, ());
     LLDB_REGISTER_METHOD(void, SBTypeSynthetic, SetOptions, (uint32_t));
     LLDB_REGISTER_METHOD(bool, SBTypeSynthetic, GetDescription,
#endif
   {
     LLDB_REGISTER_CONSTRUCTOR(SBUnixSignals, ());
     LLDB_REGISTER_CONSTRUCTOR(SBUnixSignals, (const lldb::SBUnixSignals &));
     LLDB_REGISTER_METHOD(
         const lldb::SBUnixSignals &,
         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,
                                (const char *));
     LLDB_REGISTER_METHOD_CONST(bool, SBUnixSignals, GetShouldSuppress,
                                (int32_t));
     LLDB_REGISTER_METHOD(bool, SBUnixSignals, SetShouldSuppress,
                          (int32_t, bool));
     LLDB_REGISTER_METHOD_CONST(bool, SBUnixSignals, GetShouldStop, (int32_t));
     LLDB_REGISTER_METHOD(bool, SBUnixSignals, SetShouldStop, (int32_t, bool));
     LLDB_REGISTER_METHOD_CONST(bool, SBUnixSignals, GetShouldNotify, (int32_t));
     LLDB_REGISTER_METHOD(bool, SBUnixSignals, SetShouldNotify, (int32_t, bool));
     LLDB_REGISTER_METHOD_CONST(int32_t, SBUnixSignals, GetNumSignals, ());
     LLDB_REGISTER_METHOD_CONST(int32_t, SBUnixSignals, GetSignalAtIndex,
                                (int32_t));
   }
   {
     LLDB_REGISTER_CONSTRUCTOR(SBValue, ());
     LLDB_REGISTER_CONSTRUCTOR(SBValue, (const lldb::ValueObjectSP &));
     LLDB_REGISTER_CONSTRUCTOR(SBValue, (const lldb::SBValue &));
     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, ());
     LLDB_REGISTER_METHOD(const char *, SBValue, GetName, ());
     LLDB_REGISTER_METHOD(const char *, SBValue, GetTypeName, ());
     LLDB_REGISTER_METHOD(const char *, SBValue, GetDisplayTypeName, ());
     LLDB_REGISTER_METHOD(size_t, SBValue, GetByteSize, ());
     LLDB_REGISTER_METHOD(bool, SBValue, IsInScope, ());
#endif
     LLDB_REGISTER_METHOD(lldb::SBWatchpoint, SBValue, WatchPointee,
                          (bool, bool, bool, lldb::SBError &));
     LLDB_REGISTER_METHOD(lldb::SBValue, SBValue, Persist, ());
   }
   {
     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 &));
     LLDB_REGISTER_METHOD(void, SBValueList, Append, (const lldb::SBValue &));
     LLDB_REGISTER_METHOD(void, SBValueList, Append,
                          (const lldb::SBValueList &));
     LLDB_REGISTER_METHOD_CONST(lldb::SBValue, SBValueList, GetValueAtIndex,
                                (uint32_t));
     LLDB_REGISTER_METHOD_CONST(uint32_t, SBValueList, GetSize, ());
     LLDB_REGISTER_METHOD(lldb::SBValue, SBValueList, FindValueObjectByUID,
                          (lldb::user_id_t));
     LLDB_REGISTER_METHOD_CONST(lldb::SBValue, SBValueList, GetFirstValueByName,
                                (const char *));
   }
   {
     LLDB_REGISTER_CONSTRUCTOR(SBVariablesOptions, ());
     LLDB_REGISTER_CONSTRUCTOR(SBVariablesOptions,
                               (const lldb::SBVariablesOptions &));
     LLDB_REGISTER_METHOD(
         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));
     LLDB_REGISTER_METHOD_CONST(bool, SBVariablesOptions,
                                GetIncludeRecognizedArguments,
                                (const lldb::SBTarget &));
     LLDB_REGISTER_METHOD(void, SBVariablesOptions,
                          SetIncludeRecognizedArguments, (bool));
#endif
   {
     LLDB_REGISTER_CONSTRUCTOR(SBWatchpoint, ());
     LLDB_REGISTER_CONSTRUCTOR(SBWatchpoint, (const lldb::WatchpointSP &));
     LLDB_REGISTER_CONSTRUCTOR(SBWatchpoint, (const lldb::SBWatchpoint &));
     LLDB_REGISTER_METHOD(const lldb::SBWatchpoint &,
                          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, ());
     LLDB_REGISTER_METHOD(size_t, SBWatchpoint, GetWatchSize, ());
     LLDB_REGISTER_METHOD(void, SBWatchpoint, SetEnabled, (bool));
     LLDB_REGISTER_METHOD(bool, SBWatchpoint, IsEnabled, ());
     LLDB_REGISTER_METHOD(uint32_t, SBWatchpoint, GetHitCount, ());
     LLDB_REGISTER_METHOD(uint32_t, SBWatchpoint, GetIgnoreCount, ());

lldb/trunk/source/API/SBSection.cpp

const SBSection &SBSection::operator=(const SBSection &rhs) {
   m_opaque_wp = rhs.m_opaque_wp;
   return *this;
 }
 
 SBSection::~SBSection() {}
 
 bool SBSection::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSection, IsValid);
+  return this->operator bool();
+}
+SBSection::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSection, operator bool);
 
   SectionSP section_sp(GetSP());
   return section_sp && section_sp->GetModule().get() != NULL;
 }
 
 const char *SBSection::GetName() {
   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBSection, GetName);
 

lldb/trunk/source/API/SBStream.cpp

 
 SBStream::SBStream(SBStream &&rhs)
     : m_opaque_up(std::move(rhs.m_opaque_up)), m_is_file(rhs.m_is_file) {}
 
 SBStream::~SBStream() {}
 
 bool SBStream::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBStream, IsValid);
+  return this->operator bool();
+}
+SBStream::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBStream, operator bool);
 
   return (m_opaque_up != NULL);
 }
 
 // If this stream is not redirected to a file, it will maintain a local cache
 // for the stream data which can be accessed using this accessor.
 const char *SBStream::GetData() {
   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBStream, GetData);

lldb/trunk/source/API/SBStringList.cpp

 }
 
 const lldb_private::StringList &SBStringList::operator*() const {
   return *m_opaque_up;
 }
 
 bool SBStringList::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBStringList, IsValid);
+  return this->operator bool();
+}
+SBStringList::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBStringList, operator bool);
 
   return (m_opaque_up != NULL);
 }
 
 void SBStringList::AppendString(const char *str) {
   LLDB_RECORD_METHOD(void, SBStringList, AppendString, (const char *), str);
 
   if (str != NULL) {

lldb/trunk/source/API/SBStructuredData.cpp

lldb::SBError SBStructuredData::SetFromJSON(lldb::SBStream &stream) {
 
   if (!json_obj || json_obj->GetType() != eStructuredDataTypeDictionary)
     error.SetErrorString("Invalid Syntax");
   return LLDB_RECORD_RESULT(error);
 }
 
 bool SBStructuredData::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBStructuredData, IsValid);
+  return this->operator bool();
+}
+SBStructuredData::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBStructuredData, operator bool);
 
   return m_impl_up->IsValid();
 }
 
 void SBStructuredData::Clear() {
   LLDB_RECORD_METHOD_NO_ARGS(void, SBStructuredData, Clear);
 
   m_impl_up->Clear();

lldb/trunk/source/API/SBSymbol.cpp

 SBSymbol::~SBSymbol() { m_opaque_ptr = NULL; }
 
 void SBSymbol::SetSymbol(lldb_private::Symbol *lldb_object_ptr) {
   m_opaque_ptr = lldb_object_ptr;
 }
 
 bool SBSymbol::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSymbol, IsValid);
+  return this->operator bool();
+}
+SBSymbol::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSymbol, operator bool);
 
   return m_opaque_ptr != NULL;
 }
 
 const char *SBSymbol::GetName() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBSymbol, GetName);
 
   const char *name = NULL;

lldb/trunk/source/API/SBSymbolContext.cpp

void SBSymbolContext::SetSymbolContext(const SymbolContext *sc_ptr) {
   if (sc_ptr)
     m_opaque_up = llvm::make_unique<SymbolContext>(*sc_ptr);
   else
     m_opaque_up->Clear(true);
 }
 
 bool SBSymbolContext::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSymbolContext, IsValid);
+  return this->operator bool();
+}
+SBSymbolContext::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSymbolContext, operator bool);
 
   return m_opaque_up != NULL;
 }
 
 SBModule SBSymbolContext::GetModule() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBModule, SBSymbolContext, GetModule);
 
   SBModule sb_module;

lldb/trunk/source/API/SBSymbolContextList.cpp

LLDB_RECORD_METHOD(void, SBSymbolContextList, Append,
                      (lldb::SBSymbolContextList &), sc_list);
 
   if (sc_list.IsValid() && m_opaque_up.get())
     m_opaque_up->Append(*sc_list);
 }
 
 bool SBSymbolContextList::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSymbolContextList, IsValid);
+  return this->operator bool();
+}
+SBSymbolContextList::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSymbolContextList, operator bool);
 
   return m_opaque_up != NULL;
 }
 
 lldb_private::SymbolContextList *SBSymbolContextList::operator->() const {
   return m_opaque_up.get();
 }
 

lldb/trunk/source/API/SBTarget.cpp

const char *SBTarget::GetBroadcasterClassName() {
   LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBTarget,
                                     GetBroadcasterClassName);
 
   return Target::GetStaticBroadcasterClass().AsCString();
 }
 
 bool SBTarget::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTarget, IsValid);
+  return this->operator bool();
+}
+SBTarget::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTarget, operator bool);
 
   return m_opaque_sp.get() != NULL && m_opaque_sp->IsValid();
 }
 
 SBProcess SBTarget::GetProcess() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcess, SBTarget, GetProcess);
 
   SBProcess sb_process;

lldb/trunk/source/API/SBThread.cpp

if (exe_ctx.HasThreadScope()) {
     }
   }
 
   return LLDB_RECORD_RESULT(sb_queue);
 }
 
 bool SBThread::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBThread, IsValid);
+  return this->operator bool();
+}
+SBThread::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBThread, operator bool);
 
   std::unique_lock<std::recursive_mutex> lock;
   ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
   Target *target = exe_ctx.GetTargetPtr();
   Process *process = exe_ctx.GetProcessPtr();
   if (target && process) {
     Process::StopLocker stop_locker;

lldb/trunk/source/API/SBThreadCollection.cpp

 }
 
 const lldb::ThreadCollectionSP &SBThreadCollection::operator*() const {
   return m_opaque_sp;
 }
 
 bool SBThreadCollection::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBThreadCollection, IsValid);
+  return this->operator bool();
+}
+SBThreadCollection::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBThreadCollection, operator bool);
 
   return m_opaque_sp.get() != NULL;
 }
 
 size_t SBThreadCollection::GetSize() {
   LLDB_RECORD_METHOD_NO_ARGS(size_t, SBThreadCollection, GetSize);
 
   if (m_opaque_sp)

lldb/trunk/source/API/SBThreadPlan.cpp

 lldb_private::ThreadPlan *SBThreadPlan::get() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb_private::ThreadPlan *, SBThreadPlan, get);
 
   return m_opaque_sp.get();
 }
 
 bool SBThreadPlan::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBThreadPlan, IsValid);
+  return this->operator bool();
+}
+SBThreadPlan::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBThreadPlan, operator bool);
 
   return m_opaque_sp.get() != NULL;
 }
 
 void SBThreadPlan::Clear() {
   LLDB_RECORD_METHOD_NO_ARGS(void, SBThreadPlan, Clear);
 
   m_opaque_sp.reset();

lldb/trunk/source/API/SBTrace.cpp

SBTrace::SBTrace() {
   if (m_trace_impl_sp)
     m_trace_impl_sp->uid = LLDB_INVALID_UID;
 }
 
 void SBTrace::SetSP(const ProcessSP &process_sp) { m_opaque_wp = process_sp; }
 
 bool SBTrace::IsValid() {
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBTrace, IsValid);
+  return this->operator bool();
+}
+SBTrace::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTrace, operator bool);
 
   if (!m_trace_impl_sp)
     return false;
   if (!GetSP())
     return false;
   return true;
 }

lldb/trunk/source/API/SBTraceOptions.cpp

LLDB_RECORD_METHOD(void, SBTraceOptions, setMetaDataBufferSize, (uint64_t),
                      size);
 
   if (m_traceoptions_sp)
     m_traceoptions_sp->setMetaDataBufferSize(size);
 }
 
 bool SBTraceOptions::IsValid() {
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBTraceOptions, IsValid);
+  return this->operator bool();
+}
+SBTraceOptions::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTraceOptions, operator bool);
 
   if (m_traceoptions_sp)
     return true;
   return false;
 }
 
 void SBTraceOptions::setThreadID(lldb::tid_t thread_id) {
   LLDB_RECORD_METHOD(void, SBTraceOptions, setThreadID, (lldb::tid_t),

lldb/trunk/source/API/SBType.cpp

const TypeImpl &SBType::ref() const {
   // to calling this function. In case you didn't we will assert and die to let
   // you know.
   assert(m_opaque_sp.get());
   return *m_opaque_sp;
 }
 
 bool SBType::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBType, IsValid);
+  return this->operator bool();
+}
+SBType::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBType, operator bool);
 
   if (m_opaque_sp.get() == NULL)
     return false;
 
   return m_opaque_sp->IsValid();
 }
 
 uint64_t SBType::GetByteSize() {
SBTypeList::SBTypeList(const SBTypeList &rhs)
 
   for (uint32_t i = 0, rhs_size = const_cast<SBTypeList &>(rhs).GetSize();
        i < rhs_size; i++)
     Append(const_cast<SBTypeList &>(rhs).GetTypeAtIndex(i));
 }
 
 bool SBTypeList::IsValid() {
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeList, IsValid);
+  return this->operator bool();
+}
+SBTypeList::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeList, operator bool);
 
   return (m_opaque_up != NULL);
 }
 
 SBTypeList &SBTypeList::operator=(const SBTypeList &rhs) {
   LLDB_RECORD_METHOD(lldb::SBTypeList &,
                      SBTypeList, operator=,(const lldb::SBTypeList &), rhs);
 
if (this != &rhs) {
     if (rhs.IsValid())
       m_opaque_up.reset(new TypeMemberImpl(rhs.ref()));
   }
   return *this;
 }
 
 bool SBTypeMember::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeMember, IsValid);
+  return this->operator bool();
+}
+SBTypeMember::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeMember, operator bool);
 
   return m_opaque_up.get();
 }
 
 const char *SBTypeMember::GetName() {
   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeMember, GetName);
 
   if (m_opaque_up)
operator=(const lldb::SBTypeMemberFunction &rhs) {
 
   if (this != &rhs)
     m_opaque_sp = rhs.m_opaque_sp;
   return *this;
 }
 
 bool SBTypeMemberFunction::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeMemberFunction, IsValid);
+  return this->operator bool();
+}
+SBTypeMemberFunction::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeMemberFunction, operator bool);
 
   return m_opaque_sp.get();
 }
 
 const char *SBTypeMemberFunction::GetName() {
   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeMemberFunction, GetName);
 
   if (m_opaque_sp)

lldb/trunk/source/API/SBTypeCategory.cpp

SBTypeCategory::SBTypeCategory(const lldb::SBTypeCategory &rhs)
     : m_opaque_sp(rhs.m_opaque_sp) {
   LLDB_RECORD_CONSTRUCTOR(SBTypeCategory, (const lldb::SBTypeCategory &), rhs);
 }
 
 SBTypeCategory::~SBTypeCategory() {}
 
 bool SBTypeCategory::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeCategory, IsValid);
+  return this->operator bool();
+}
+SBTypeCategory::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeCategory, operator bool);
 
   return (m_opaque_sp.get() != NULL);
 }
 
 bool SBTypeCategory::GetEnabled() {
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeCategory, GetEnabled);
 
   if (!IsValid())

lldb/trunk/source/API/SBTypeEnumMember.cpp

SBTypeEnumMember &SBTypeEnumMember::operator=(const SBTypeEnumMember &rhs) {
 
   if (this != &rhs)
     m_opaque_sp = clone(rhs.m_opaque_sp);
   return *this;
 }
 
 bool SBTypeEnumMember::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeEnumMember, IsValid);
+  return this->operator bool();
+}
+SBTypeEnumMember::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeEnumMember, operator bool);
 
   return m_opaque_sp.get();
 }
 
 const char *SBTypeEnumMember::GetName() {
   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeEnumMember, GetName);
 
   if (m_opaque_sp.get())
SBTypeEnumMemberList::SBTypeEnumMemberList(const SBTypeEnumMemberList &rhs)
   for (uint32_t i = 0,
                 rhs_size = const_cast<SBTypeEnumMemberList &>(rhs).GetSize();
        i < rhs_size; i++)
     Append(const_cast<SBTypeEnumMemberList &>(rhs).GetTypeEnumMemberAtIndex(i));
 }
 
 bool SBTypeEnumMemberList::IsValid() {
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeEnumMemberList, IsValid);
+  return this->operator bool();
+}
+SBTypeEnumMemberList::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeEnumMemberList, operator bool);
 
   return (m_opaque_up != NULL);
 }
 
 SBTypeEnumMemberList &SBTypeEnumMemberList::
 operator=(const SBTypeEnumMemberList &rhs) {
   LLDB_RECORD_METHOD(
       lldb::SBTypeEnumMemberList &,

lldb/trunk/source/API/SBTypeFilter.cpp

SBTypeFilter::SBTypeFilter(const lldb::SBTypeFilter &rhs)
     : m_opaque_sp(rhs.m_opaque_sp) {
   LLDB_RECORD_CONSTRUCTOR(SBTypeFilter, (const lldb::SBTypeFilter &), rhs);
 }
 
 SBTypeFilter::~SBTypeFilter() {}
 
 bool SBTypeFilter::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeFilter, IsValid);
+  return this->operator bool();
+}
+SBTypeFilter::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeFilter, operator bool);
 
   return m_opaque_sp.get() != NULL;
 }
 
 uint32_t SBTypeFilter::GetOptions() {
   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeFilter, GetOptions);
 
   if (IsValid())

lldb/trunk/source/API/SBTypeFormat.cpp

SBTypeFormat::SBTypeFormat(const lldb::SBTypeFormat &rhs)
     : m_opaque_sp(rhs.m_opaque_sp) {
   LLDB_RECORD_CONSTRUCTOR(SBTypeFormat, (const lldb::SBTypeFormat &), rhs);
 }
 
 SBTypeFormat::~SBTypeFormat() {}
 
 bool SBTypeFormat::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeFormat, IsValid);
+  return this->operator bool();
+}
+SBTypeFormat::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeFormat, operator bool);
 
   return m_opaque_sp.get() != NULL;
 }
 
 lldb::Format SBTypeFormat::GetFormat() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::Format, SBTypeFormat, GetFormat);
 
   if (IsValid() && m_opaque_sp->GetType() == TypeFormatImpl::Type::eTypeFormat)

lldb/trunk/source/API/SBTypeNameSpecifier.cpp

SBTypeNameSpecifier::SBTypeNameSpecifier(const lldb::SBTypeNameSpecifier &rhs)
   LLDB_RECORD_CONSTRUCTOR(SBTypeNameSpecifier,
                           (const lldb::SBTypeNameSpecifier &), rhs);
 }
 
 SBTypeNameSpecifier::~SBTypeNameSpecifier() {}
 
 bool SBTypeNameSpecifier::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeNameSpecifier, IsValid);
+  return this->operator bool();
+}
+SBTypeNameSpecifier::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeNameSpecifier, operator bool);
 
   return m_opaque_sp.get() != NULL;
 }
 
 const char *SBTypeNameSpecifier::GetName() {
   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeNameSpecifier, GetName);
 
   if (!IsValid())

lldb/trunk/source/API/SBTypeSummary.cpp

SBTypeSummaryOptions::SBTypeSummaryOptions(
 
   m_opaque_up = clone(rhs.m_opaque_up);
 }
 
 SBTypeSummaryOptions::~SBTypeSummaryOptions() {}
 
 bool SBTypeSummaryOptions::IsValid() {
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeSummaryOptions, IsValid);
+  return this->operator bool();
+}
+SBTypeSummaryOptions::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeSummaryOptions, operator bool);
 
   return m_opaque_up.get();
 }
 
 lldb::LanguageType SBTypeSummaryOptions::GetLanguage() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::LanguageType, SBTypeSummaryOptions,
                              GetLanguage);
 
SBTypeSummary::SBTypeSummary(const lldb::SBTypeSummary &rhs)
     : m_opaque_sp(rhs.m_opaque_sp) {
   LLDB_RECORD_CONSTRUCTOR(SBTypeSummary, (const lldb::SBTypeSummary &), rhs);
 }
 
 SBTypeSummary::~SBTypeSummary() {}
 
 bool SBTypeSummary::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeSummary, IsValid);
+  return this->operator bool();
+}
+SBTypeSummary::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeSummary, operator bool);
 
   return m_opaque_sp.get() != NULL;
 }
 
 bool SBTypeSummary::IsFunctionCode() {
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeSummary, IsFunctionCode);
 
   if (!IsValid())

lldb/trunk/source/API/SBTypeSynthetic.cpp

SBTypeSynthetic::SBTypeSynthetic(const lldb::SBTypeSynthetic &rhs)
   LLDB_RECORD_CONSTRUCTOR(SBTypeSynthetic, (const lldb::SBTypeSynthetic &),
                           rhs);
 }
 
 SBTypeSynthetic::~SBTypeSynthetic() {}
 
 bool SBTypeSynthetic::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeSynthetic, IsValid);
+  return this->operator bool();
+}
+SBTypeSynthetic::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeSynthetic, operator bool);
 
   return m_opaque_sp.get() != NULL;
 }
 
 bool SBTypeSynthetic::IsClassCode() {
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeSynthetic, IsClassCode);
 
   if (!IsValid())

lldb/trunk/source/API/SBUnixSignals.cpp

 void SBUnixSignals::Clear() {
   LLDB_RECORD_METHOD_NO_ARGS(void, SBUnixSignals, Clear);
 
   m_opaque_wp.reset();
 }
 
 bool SBUnixSignals::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBUnixSignals, IsValid);
+  return this->operator bool();
+}
+SBUnixSignals::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBUnixSignals, operator bool);
 
   return static_cast<bool>(GetSP());
 }
 
 const char *SBUnixSignals::GetSignalAsCString(int32_t signo) const {
   LLDB_RECORD_METHOD_CONST(const char *, SBUnixSignals, GetSignalAsCString,
                            (int32_t), signo);
 

lldb/trunk/source/API/SBValue.cpp

SBValue &SBValue::operator=(const SBValue &rhs) {
   }
   return *this;
 }
 
 SBValue::~SBValue() {}
 
 bool SBValue::IsValid() {
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsValid);
+  return this->operator bool();
+}
+SBValue::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBValue, operator bool);
 
   // If this function ever changes to anything that does more than just check
   // if the opaque shared pointer is non NULL, then we need to update all "if
   // (m_opaque_sp)" code in this file.
   return m_opaque_sp.get() != NULL && m_opaque_sp->IsValid() &&
          m_opaque_sp->GetRootSP().get() != NULL;
 }
 

lldb/trunk/source/API/SBValueList.cpp

SBValueList::SBValueList(const ValueListImpl *lldb_object_ptr) : m_opaque_up() {
   if (lldb_object_ptr)
     m_opaque_up.reset(new ValueListImpl(*lldb_object_ptr));
 }
 
 SBValueList::~SBValueList() {}
 
 bool SBValueList::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBValueList, IsValid);
+  return this->operator bool();
+}
+SBValueList::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBValueList, operator bool);
 
   return (m_opaque_up != NULL);
 }
 
 void SBValueList::Clear() {
   LLDB_RECORD_METHOD_NO_ARGS(void, SBValueList, Clear);
 
   m_opaque_up.reset();

lldb/trunk/source/API/SBVariablesOptions.cpp

operator=(const SBVariablesOptions &options) {
   m_opaque_up.reset(new VariablesOptionsImpl(options.ref()));
   return *this;
 }
 
 SBVariablesOptions::~SBVariablesOptions() = default;
 
 bool SBVariablesOptions::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, IsValid);
+  return this->operator bool();
+}
+SBVariablesOptions::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions, operator bool);
 
   return m_opaque_up != nullptr;
 }
 
 bool SBVariablesOptions::GetIncludeArguments() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBVariablesOptions,
                                    GetIncludeArguments);
 

lldb/trunk/source/API/SBWatchpoint.cpp

watch_id_t SBWatchpoint::GetID() {
   if (watchpoint_sp)
     watch_id = watchpoint_sp->GetID();
 
   return watch_id;
 }
 
 bool SBWatchpoint::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBWatchpoint, IsValid);
+  return this->operator bool();
+}
+SBWatchpoint::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBWatchpoint, operator bool);
 
   return bool(m_opaque_wp.lock());
 }
 
 SBError SBWatchpoint::GetError() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBWatchpoint, GetError);
 
   SBError sb_error;