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).

include/lldb/API/SBAddress.h

public:
   SBAddress(lldb::addr_t load_addr, lldb::SBTarget &target);
 
   ~SBAddress();
 
   const lldb::SBAddress &operator=(const lldb::SBAddress &rhs);
 
   bool IsValid() const;
 
+  explicit operator bool() const;
+
   void Clear();
 
   addr_t GetFileAddress() const;
 
   addr_t GetLoadAddress(const lldb::SBTarget &target) const;
 
   void SetAddress(lldb::SBSection section, lldb::addr_t offset);
 

include/lldb/API/SBBlock.h

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

include/lldb/API/SBBreakpoint.h

public:
   bool operator==(const lldb::SBBreakpoint &rhs);
 
   bool operator!=(const lldb::SBBreakpoint &rhs);
 
   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::SBBreakpointLocation FindLocationByID(lldb::break_id_t bp_loc_id);
 

include/lldb/API/SBBreakpointLocation.h

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

include/lldb/API/SBBreakpointName.h

//                                        lldb::SBBreakpointLocation &location);
 
   // 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);
 
   bool IsValid() const;
-  
+  explicit operator bool() const;
+
   const char *GetName() const;
 
   void SetEnabled(bool enable);
 
   bool IsEnabled();
 
   void SetOneShot(bool one_shot);
 

include/lldb/API/SBBroadcaster.h

public:
   SBBroadcaster(const SBBroadcaster &rhs);
 
   const SBBroadcaster &operator=(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);
 
   void AddInitialEventsToListener(const lldb::SBListener &listener,
                                   uint32_t requested_events);

include/lldb/API/SBCommandInterpreter.h

public:
 
   static const char *
   GetArgumentDescriptionAsCString(const lldb::CommandArgumentType arg_type);
 
   static bool EventIsCommandInterpreterEvent(const lldb::SBEvent &event);
 
   bool IsValid() const;
 
+  explicit operator bool() const;
+
   bool CommandExists(const char *cmd);
 
   bool AliasExists(const char *cmd);
 
   lldb::SBBroadcaster GetBroadcaster();
 
   static const char *GetBroadcasterClass();
 

 };
 
 class SBCommand {
 public:
   SBCommand();
 
   bool IsValid();
 
+  explicit operator bool();
+
   const char *GetName();
 
   const char *GetHelp();
 
   const char *GetHelpLong();
 
   void SetHelp(const char *);
 

include/lldb/API/SBCommandReturnObject.h

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

include/lldb/API/SBCommunication.h

typedef void (*ReadThreadBytesReceived)(void *baton, const void *src,
                                           size_t src_len);
 
   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::ConnectionStatus Connect(const char *url);
 

include/lldb/API/SBCompileUnit.h

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

include/lldb/API/SBData.h

public:
   uint8_t GetAddressByteSize();
 
   void SetAddressByteSize(uint8_t addr_byte_size);
 
   void Clear();
 
   bool IsValid();
 
+  explicit operator bool();
+
   size_t GetByteSize();
 
   lldb::ByteOrder GetByteOrder();
 
   void SetByteOrder(lldb::ByteOrder endian);
 
   float GetFloat(lldb::SBError &error, lldb::offset_t offset);
 

include/lldb/API/SBDebugger.h

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

include/lldb/API/SBDeclaration.h

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

include/lldb/API/SBError.h

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

include/lldb/API/SBEvent.h

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

include/lldb/API/SBFileSpec.h

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

include/lldb/API/SBFrame.h

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

include/lldb/API/SBFunction.h

public:
   SBFunction(const lldb::SBFunction &rhs);
 
   const lldb::SBFunction &operator=(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::SBInstructionList GetInstructions(lldb::SBTarget target);
 

include/lldb/API/SBInstruction.h

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

include/lldb/API/SBInstructionList.h

public:
   SBInstructionList(const SBInstructionList &rhs);
 
   const SBInstructionList &operator=(const SBInstructionList &rhs);
 
   ~SBInstructionList();
 
   bool IsValid() const;
 
+  explicit operator bool() const;
+
   size_t GetSize();
 
   lldb::SBInstruction GetInstructionAtIndex(uint32_t idx);
 
   // ----------------------------------------------------------------------
   // Returns the number of instructions between the start and end address. If
   // canSetBreakpoint is true then the count will be the number of
   // instructions on which a breakpoint can be set.

include/lldb/API/SBLineEntry.h

public:
   const lldb::SBLineEntry &operator=(const lldb::SBLineEntry &rhs);
 
   lldb::SBAddress 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;
 
   void SetFileSpec(lldb::SBFileSpec filespec);
 

include/lldb/API/SBListener.h

public:
   const lldb::SBListener &operator=(const lldb::SBListener &rhs);
 
   void 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);
 
   bool StopListeningForEventClass(SBDebugger &debugger,
                                   const char *broadcaster_class,
                                   uint32_t event_mask);
 

include/lldb/API/SBModule.h

public:
   const SBModule &operator=(const SBModule &rhs);
 
   SBModule(lldb::SBProcess &process, lldb::addr_t header_addr);
 
   ~SBModule();
 
   bool IsValid() const;
 
+  explicit operator bool() const;
+
   void Clear();
 
   //------------------------------------------------------------------
   /// Get const accessor for the module file specification.
   ///
   /// This function returns the file for the module on the host system
   /// that is running LLDB. This can differ from the path on the
   /// platform since we might be doing remote debugging.

include/lldb/API/SBModuleSpec.h

public:
   SBModuleSpec(const SBModuleSpec &rhs);
 
   ~SBModuleSpec();
 
   const SBModuleSpec &operator=(const SBModuleSpec &rhs);
 
   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
   /// platform since we might be doing remote debugging.

include/lldb/API/SBPlatform.h

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

include/lldb/API/SBProcess.h

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

include/lldb/API/SBProcessInfo.h

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

include/lldb/API/SBQueue.h

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

include/lldb/API/SBQueueItem.h

public:
   SBQueueItem();
 
   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::SBAddress GetAddress() const;
 

include/lldb/API/SBSection.h

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

include/lldb/API/SBStream.h

public:
   SBStream();
 
   SBStream(SBStream &&rhs);
 
   ~SBStream();
 
   bool IsValid() const;
 
+  explicit operator bool() 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.
   size_t GetSize();
 

include/lldb/API/SBStringList.h

public:
   SBStringList(const lldb::SBStringList &rhs);
 
   const SBStringList &operator=(const 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);
 
   uint32_t GetSize() const;
 

include/lldb/API/SBStructuredData.h

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

include/lldb/API/SBSymbol.h

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

include/lldb/API/SBSymbolContext.h

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

include/lldb/API/SBSymbolContextList.h

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

include/lldb/API/SBTarget.h

public:
   // Destructor
   //------------------------------------------------------------------
   ~SBTarget();
 
   const lldb::SBTarget &operator=(const lldb::SBTarget &rhs);
 
   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);
 
   static lldb::SBModule GetModuleAtIndexFromEvent(const uint32_t idx,
                                                   const lldb::SBEvent &event);

include/lldb/API/SBThread.h

public:
   SBThread(const lldb::ThreadSP &lldb_object_sp);
 
   ~SBThread();
 
   lldb::SBQueue GetQueue() const;
 
   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().
   size_t GetStopReasonDataCount();
 

include/lldb/API/SBThreadCollection.h

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

include/lldb/API/SBThreadPlan.h

public:
   SBThreadPlan(const lldb::ThreadPlanSP &lldb_object_sp);
 
   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().
   size_t GetStopReasonDataCount();
 

include/lldb/API/SBTrace.h

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

include/lldb/API/SBTraceOptions.h

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

include/lldb/API/SBType.h

public:
   SBTypeMember(const lldb::SBTypeMember &rhs);
 
   ~SBTypeMember();
 
   lldb::SBTypeMember &operator=(const lldb::SBTypeMember &rhs);
 
   bool IsValid() const;
 
+  explicit operator bool() const;
+
   const char *GetName();
 
   lldb::SBType GetType();
 
   uint64_t GetOffsetInBytes();
 
   uint64_t GetOffsetInBits();
 
public:
   SBTypeMemberFunction(const lldb::SBTypeMemberFunction &rhs);
 
   ~SBTypeMemberFunction();
 
   lldb::SBTypeMemberFunction &operator=(const lldb::SBTypeMemberFunction &rhs);
 
   bool IsValid() const;
 
+  explicit operator bool() const;
+
   const char *GetName();
 
   const char *GetDemangledName();
 
   const char *GetMangledName();
 
   lldb::SBType GetType();
 
public:
   SBType();
 
   SBType(const lldb::SBType &rhs);
 
   ~SBType();
 
   bool IsValid() const;
 
+  explicit operator bool() const;
+
   uint64_t GetByteSize();
 
   bool IsPointerType();
 
   bool IsReferenceType();
 
   bool IsFunctionType();
 
public:
   SBTypeList(const lldb::SBTypeList &rhs);
 
   ~SBTypeList();
 
   lldb::SBTypeList &operator=(const lldb::SBTypeList &rhs);
 
   bool IsValid();
 
+  explicit operator bool();
+
   void Append(lldb::SBType type);
 
   lldb::SBType GetTypeAtIndex(uint32_t index);
 
   uint32_t GetSize();
 
 private:
   std::unique_ptr<lldb_private::TypeListImpl> m_opaque_up;
   friend class SBModule;
   friend class SBCompileUnit;
 };
 
 } // namespace lldb
 
 #endif // LLDB_SBType_h_

include/lldb/API/SBTypeCategory.h

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

include/lldb/API/SBTypeEnumMember.h

public:
   SBTypeEnumMember(const SBTypeEnumMember &rhs);
 
   ~SBTypeEnumMember();
 
   SBTypeEnumMember &operator=(const SBTypeEnumMember &rhs);
 
   bool IsValid() const;
 
+  explicit operator bool() const;
+
   int64_t GetValueAsSigned();
 
   uint64_t GetValueAsUnsigned();
 
   const char *GetName();
 
   lldb::SBType GetType();
 
public:
   SBTypeEnumMemberList(const SBTypeEnumMemberList &rhs);
 
   ~SBTypeEnumMemberList();
 
   SBTypeEnumMemberList &operator=(const SBTypeEnumMemberList &rhs);
 
   bool IsValid();
 
+  explicit operator bool();
+
   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_

include/lldb/API/SBTypeFilter.h

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

include/lldb/API/SBTypeFormat.h

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

include/lldb/API/SBTypeNameSpecifier.h

public:
   SBTypeNameSpecifier(SBType type);
 
   SBTypeNameSpecifier(const lldb::SBTypeNameSpecifier &rhs);
 
   ~SBTypeNameSpecifier();
 
   bool IsValid() const;
 
+  explicit operator bool() const;
+
   const char *GetName();
 
   SBType GetType();
 
   bool IsRegex();
 
   bool GetDescription(lldb::SBStream &description,
                       lldb::DescriptionLevel description_level);

include/lldb/API/SBTypeSummary.h

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

include/lldb/API/SBTypeSynthetic.h

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

include/lldb/API/SBUnixSignals.h

public:
   ~SBUnixSignals();
 
   const SBUnixSignals &operator=(const lldb::SBUnixSignals &rhs);
 
   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;
 
   bool SetShouldSuppress(int32_t signo, bool value);
 

include/lldb/API/SBValue.h

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

include/lldb/API/SBValueList.h

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);
 
   uint32_t GetSize() const;
 

include/lldb/API/SBVariablesOptions.h

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

include/lldb/API/SBWatchpoint.h

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

scripts/Python/modify-python-lldb.py

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()''')

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;

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", "

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);

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);

scripts/interface/SBBreakpointName.i

public:
 
   // 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);
 
   bool IsValid() const;
-  
+  explicit operator bool() const;
+  
   const char *GetName() const;
 
   void SetEnabled(bool enable);
 
   bool IsEnabled();
 
   void SetOneShot(bool one_shot);
 

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);

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);

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 ();

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);
 

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;

scripts/interface/SBData.i

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

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 ();

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;

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

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;

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;

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

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;

scripts/interface/SBInstruction.i

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

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);

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;

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,

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

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

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 *);

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

scripts/interface/SBProcessInfo.i

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

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

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);

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);

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 ();

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);

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;

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 *

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);

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);

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);

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.

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

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();
+
     // 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);

scripts/interface/SBTrace.i

public:
 
   void GetTraceConfig(SBTraceOptions &options,
                       SBError &error);
 
   lldb::user_id_t GetTraceUID();
 
   bool IsValid();
 
+  explicit operator bool();
+
 };
-} // namespace lldb
+} // namespace lldb
 

scripts/interface/SBTraceOptions.i

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

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();
+
     uint64_t
     GetByteSize();
 
     bool
     IsPointerType();
 
     bool
     IsReferenceType();

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

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();

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();
+
     void
     Append (SBTypeEnumMember entry);
 
     SBTypeEnumMember
     GetTypeEnumMemberAtIndex (uint32_t index);
 
     uint32_t
     GetSize();
 
 
 private:
     std::unique_ptr<lldb_private::TypeEnumMemberListImpl> m_opaque_ap;
 };
 
 } // namespace lldb

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);

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 ();

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 ();

scripts/interface/SBTypeSummary.i

public:
         SBTypeSummaryOptions();
         
         SBTypeSummaryOptions (const lldb::SBTypeSummaryOptions &rhs);
         
         ~SBTypeSummaryOptions ();
         
         bool
         IsValid ();
-        
+        explicit operator bool();
+        
         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();

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 ();

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;

scripts/interface/SBValue.i

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

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);

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;

scripts/interface/SBWatchpoint.i

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

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>

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;
 }
 
+SBAddress::operator bool() const { return IsValid(); }
+
 bool SBAddress::IsValid() const {
   return m_opaque_up != NULL && m_opaque_up->IsValid();
 }
 
 void SBAddress::Clear() { m_opaque_up.reset(new Address()); }
 
 void SBAddress::SetAddress(lldb::SBSection section, lldb::addr_t offset) {
   Address &addr = ref();

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; }
 
+SBBlock::operator bool() const { return IsValid(); }
+
 bool SBBlock::IsValid() const { return m_opaque_ptr != NULL; }
 
 bool SBBlock::IsInlined() const {
   if (m_opaque_ptr)
     return m_opaque_ptr->GetInlinedFunctionInfo() != NULL;
   return false;
 }
 

source/API/SBBreakpoint.cpp

break_id_t SBBreakpoint::GetID() const {
   BreakpointSP bkpt_sp = GetSP();
   if (bkpt_sp)
     break_id = bkpt_sp->GetID();
 
   LLDB_LOG(log, "breakpoint = {0}, id = {1}", bkpt_sp.get(), break_id);
   return break_id;
 }
 
+SBBreakpoint::operator bool() const { return IsValid(); }
+
 bool SBBreakpoint::IsValid() const {
   BreakpointSP bkpt_sp = GetSP();
   if (!bkpt_sp)
     return false;
   else if (bkpt_sp->GetTarget().GetBreakpointByID(bkpt_sp->GetID()))
     return true;
   else
     return false;

source/API/SBBreakpointLocation.cpp

 }
 
 SBBreakpointLocation::~SBBreakpointLocation() {}
 
 BreakpointLocationSP SBBreakpointLocation::GetSP() const {
   return m_opaque_wp.lock();
 }
 
+SBBreakpointLocation::operator bool() const { return IsValid(); }
+
 bool SBBreakpointLocation::IsValid() const { return bool(GetSP()); }
 
 SBAddress SBBreakpointLocation::GetAddress() {
   BreakpointLocationSP loc_sp = GetSP();
   if (loc_sp)
     return SBAddress(&loc_sp->GetAddress());
   else
     return SBAddress();

source/API/SBBreakpointName.cpp

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

source/API/SBBroadcaster.cpp

 void SBBroadcaster::reset(Broadcaster *broadcaster, bool owns) {
   if (owns)
     m_opaque_sp.reset(broadcaster);
   else
     m_opaque_sp.reset();
   m_opaque_ptr = broadcaster;
 }
 
+SBBroadcaster::operator bool() const { return IsValid(); }
+
 bool SBBroadcaster::IsValid() const { return m_opaque_ptr != NULL; }
 
 void SBBroadcaster::Clear() {
   m_opaque_sp.reset();
   m_opaque_ptr = NULL;
 }
 
 bool SBBroadcaster::operator==(const SBBroadcaster &rhs) const {

source/API/SBCommandInterpreter.cpp

 SBCommandInterpreter::~SBCommandInterpreter() = default;
 
 const SBCommandInterpreter &SBCommandInterpreter::
 operator=(const SBCommandInterpreter &rhs) {
   m_opaque_ptr = rhs.m_opaque_ptr;
   return *this;
 }
 
+SBCommandInterpreter::operator bool() const { return IsValid(); }
+
 bool SBCommandInterpreter::IsValid() const { return m_opaque_ptr != nullptr; }
 
 bool SBCommandInterpreter::CommandExists(const char *cmd) {
   return (((cmd != nullptr) && IsValid()) ? m_opaque_ptr->CommandExists(cmd)
                                           : false);
 }
 
 bool SBCommandInterpreter::AliasExists(const char *cmd) {
if (new_command_sp &&
     return lldb::SBCommand(new_command_sp);
   return lldb::SBCommand();
 }
 
 SBCommand::SBCommand() = default;
 
 SBCommand::SBCommand(lldb::CommandObjectSP cmd_sp) : m_opaque_sp(cmd_sp) {}
 
+SBCommand::operator bool() { return IsValid(); }
+
 bool SBCommand::IsValid() { return m_opaque_sp.get() != nullptr; }
 
 const char *SBCommand::GetName() {
   return (IsValid() ? ConstString(m_opaque_sp->GetCommandName()).AsCString() : nullptr);
 }
 
 const char *SBCommand::GetHelp() {
   return (IsValid() ? ConstString(m_opaque_sp->GetHelp()).AsCString()

source/API/SBCommandReturnObject.cpp

if (this != &rhs) {
     if (rhs.m_opaque_up)
       m_opaque_up.reset(new CommandReturnObject(*rhs.m_opaque_up));
     else
       m_opaque_up.reset();
   }
   return *this;
 }
 
+SBCommandReturnObject::operator bool() const { return IsValid(); }
+
 bool SBCommandReturnObject::IsValid() const { return m_opaque_up != nullptr; }
 
 const char *SBCommandReturnObject::GetOutput() {
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   if (m_opaque_up) {
     llvm::StringRef output = m_opaque_up->GetOutputData();
     ConstString result(output.empty() ? llvm::StringRef("") : output);

source/API/SBCommunication.cpp

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

source/API/SBCompileUnit.cpp

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

source/API/SBData.cpp

 lldb_private::DataExtractor *SBData::operator->() const {
   return m_opaque_sp.operator->();
 }
 
 lldb::DataExtractorSP &SBData::operator*() { return m_opaque_sp; }
 
 const lldb::DataExtractorSP &SBData::operator*() const { return m_opaque_sp; }
 
+SBData::operator bool() { return IsValid(); }
+
 bool SBData::IsValid() { return m_opaque_sp.get() != NULL; }
 
 uint8_t SBData::GetAddressByteSize() {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   uint8_t value = 0;
   if (m_opaque_sp.get())
     value = m_opaque_sp->GetAddressByteSize();
   if (log)

source/API/SBDebugger.cpp

void SBDebugger::MemoryPressureDetected() {
   if (log) {
     log->Printf("SBDebugger::MemoryPressureDetected (), mandatory = %d",
                 mandatory);
   }
 
   ModuleList::RemoveOrphanSharedModules(mandatory);
 }
 
+SBDebugger::operator bool() const { return IsValid(); }
+
 bool SBDebugger::IsValid() const { return m_opaque_sp.get() != nullptr; }
 
 void SBDebugger::SetAsync(bool b) {
   if (m_opaque_sp)
     m_opaque_sp->SetAsyncExecution(b);
 }
 
 bool SBDebugger::GetAsync() {

source/API/SBDeclaration.cpp

 
 void SBDeclaration::SetDeclaration(
     const lldb_private::Declaration &lldb_object_ref) {
   ref() = lldb_object_ref;
 }
 
 SBDeclaration::~SBDeclaration() {}
 
+SBDeclaration::operator bool() const { return IsValid(); }
+
 bool SBDeclaration::IsValid() const {
   return m_opaque_up.get() && m_opaque_up->IsValid();
 }
 
 SBFileSpec SBDeclaration::GetFileSpec() const {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBFileSpec sb_file_spec;

source/API/SBError.cpp

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

source/API/SBEvent.cpp

void SBEvent::reset(EventSP &event_sp) {
   m_opaque_ptr = m_event_sp.get();
 }
 
 void SBEvent::reset(Event *event_ptr) {
   m_opaque_ptr = event_ptr;
   m_event_sp.reset();
 }
 
+SBEvent::operator bool() const { return IsValid(); }
+
 bool SBEvent::IsValid() const {
   // 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) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));

source/API/SBFileSpec.cpp

 SBFileSpec::~SBFileSpec() {}
 
 const SBFileSpec &SBFileSpec::operator=(const SBFileSpec &rhs) {
   if (this != &rhs)
     *m_opaque_up = *rhs.m_opaque_up;
   return *this;
 }
 
+SBFileSpec::operator bool() const { return IsValid(); }
+
 bool SBFileSpec::IsValid() const { return m_opaque_up->operator bool(); }
 
 bool SBFileSpec::Exists() const {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   bool result = FileSystem::Instance().Exists(*m_opaque_up);
 
   if (log)

source/API/SBFrame.cpp

 StackFrameSP SBFrame::GetFrameSP() const {
   return (m_opaque_sp ? m_opaque_sp->GetFrameSP() : StackFrameSP());
 }
 
 void SBFrame::SetFrameSP(const StackFrameSP &lldb_object_sp) {
   return m_opaque_sp->SetFrameSP(lldb_object_sp);
 }
 
+SBFrame::operator bool() const { return IsValid(); }
+
 bool SBFrame::IsValid() const {
   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;

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; }
 
+SBFunction::operator bool() const { return IsValid(); }
+
 bool SBFunction::IsValid() const { return m_opaque_ptr != NULL; }
 
 const char *SBFunction::GetName() const {
   const char *cstr = NULL;
   if (m_opaque_ptr)
     cstr = m_opaque_ptr->GetName().AsCString();
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));

source/API/SBInstruction.cpp

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

source/API/SBInstructionList.cpp

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

source/API/SBLineEntry.cpp

if (addr)
                  Address::DumpStyleInvalid, 4);
     log->Printf("SBLineEntry(%p)::GetEndAddress () => SBAddress (%p): %s",
                 static_cast<void *>(m_opaque_up.get()),
                 static_cast<void *>(sb_address.get()), sstr.GetData());
   }
   return sb_address;
 }
 
+SBLineEntry::operator bool() const { return IsValid(); }
+
 bool SBLineEntry::IsValid() const {
   return m_opaque_up.get() && m_opaque_up->IsValid();
 }
 
 SBFileSpec SBLineEntry::GetFileSpec() const {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBFileSpec sb_file_spec;

source/API/SBListener.cpp

const lldb::SBListener &SBListener::operator=(const lldb::SBListener &rhs) {
   return *this;
 }
 
 SBListener::SBListener(const lldb::ListenerSP &listener_sp)
     : m_opaque_sp(listener_sp), m_unused_ptr(nullptr) {}
 
 SBListener::~SBListener() {}
 
+SBListener::operator bool() const { return IsValid(); }
+
 bool SBListener::IsValid() const { return m_opaque_sp != nullptr; }
 
 void SBListener::AddEvent(const SBEvent &event) {
   EventSP &event_sp = event.GetSP();
   if (event_sp)
     m_opaque_sp->AddEvent(event_sp);
 }
 

source/API/SBModule.cpp

 const SBModule &SBModule::operator=(const SBModule &rhs) {
   if (this != &rhs)
     m_opaque_sp = rhs.m_opaque_sp;
   return *this;
 }
 
 SBModule::~SBModule() {}
 
+SBModule::operator bool() const { return IsValid(); }
+
 bool SBModule::IsValid() const { return m_opaque_sp.get() != NULL; }
 
 void SBModule::Clear() { m_opaque_sp.reset(); }
 
 SBFileSpec SBModule::GetFileSpec() const {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBFileSpec file_spec;

source/API/SBModuleSpec.cpp

 const SBModuleSpec &SBModuleSpec::operator=(const SBModuleSpec &rhs) {
   if (this != &rhs)
     *m_opaque_up = *(rhs.m_opaque_up);
   return *this;
 }
 
 SBModuleSpec::~SBModuleSpec() {}
 
+SBModuleSpec::operator bool() const { return IsValid(); }
+
 bool SBModuleSpec::IsValid() const { return m_opaque_up->operator bool(); }
 
 void SBModuleSpec::Clear() { m_opaque_up->Clear(); }
 
 SBFileSpec SBModuleSpec::GetFileSpec() {
   SBFileSpec sb_spec(m_opaque_up->GetFileSpec());
   return sb_spec;
 }

source/API/SBPlatform.cpp

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

source/API/SBProcess.cpp

 }
 
 lldb::ProcessSP SBProcess::GetSP() const { return m_opaque_wp.lock(); }
 
 void SBProcess::SetSP(const ProcessSP &process_sp) { m_opaque_wp = process_sp; }
 
 void SBProcess::Clear() { m_opaque_wp.reset(); }
 
+SBProcess::operator bool() const { return IsValid(); }
+
 bool SBProcess::IsValid() const {
   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,

source/API/SBProcessInfo.cpp

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

source/API/SBQueue.cpp

 
 const lldb::SBQueue &SBQueue::operator=(const lldb::SBQueue &rhs) {
   m_opaque_sp = rhs.m_opaque_sp;
   return *this;
 }
 
 SBQueue::~SBQueue() {}
 
+SBQueue::operator bool() const { return IsValid(); }
+
 bool SBQueue::IsValid() const {
   bool is_valid = m_opaque_sp->IsValid();
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log)
     log->Printf("SBQueue(0x%" PRIx64 ")::IsValid() == %s",
                 m_opaque_sp->GetQueueID(), is_valid ? "true" : "false");
   return is_valid;
 }

source/API/SBQueueItem.cpp

 SBQueueItem::SBQueueItem(const QueueItemSP &queue_item_sp)
     : m_queue_item_sp(queue_item_sp) {}
 
 //----------------------------------------------------------------------
 // Destructor
 //----------------------------------------------------------------------
 SBQueueItem::~SBQueueItem() { m_queue_item_sp.reset(); }
 
+SBQueueItem::operator bool() const { return IsValid(); }
+
 bool SBQueueItem::IsValid() const {
   bool is_valid = m_queue_item_sp.get() != NULL;
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log)
     log->Printf("SBQueueItem(%p)::IsValid() == %s",
                 static_cast<void *>(m_queue_item_sp.get()),
                 is_valid ? "true" : "false");
   return is_valid;

source/API/SBSection.cpp

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

source/API/SBStream.cpp

 
 SBStream::SBStream() : m_opaque_up(new StreamString()), m_is_file(false) {}
 
 SBStream::SBStream(SBStream &&rhs)
     : m_opaque_up(std::move(rhs.m_opaque_up)), m_is_file(rhs.m_is_file) {}
 
 SBStream::~SBStream() {}
 
+SBStream::operator bool() const { return IsValid(); }
+
 bool SBStream::IsValid() const { 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() {
   if (m_is_file || m_opaque_up == NULL)
     return NULL;
 

source/API/SBStringList.cpp

 const lldb_private::StringList *SBStringList::operator->() const {
   return m_opaque_up.get();
 }
 
 const lldb_private::StringList &SBStringList::operator*() const {
   return *m_opaque_up;
 }
 
+SBStringList::operator bool() const { return IsValid(); }
+
 bool SBStringList::IsValid() const { return (m_opaque_up != NULL); }
 
 void SBStringList::AppendString(const char *str) {
   if (str != NULL) {
     if (IsValid())
       m_opaque_up->AppendString(str);
     else
       m_opaque_up.reset(new lldb_private::StringList(str));

source/API/SBStructuredData.cpp

lldb::SBError SBStructuredData::SetFromJSON(lldb::SBStream &stream) {
   StructuredData::ObjectSP json_obj = StructuredData::ParseJSON(json_str);
   m_impl_up->SetObjectSP(json_obj);
 
   if (!json_obj || json_obj->GetType() != eStructuredDataTypeDictionary)
     error.SetErrorString("Invalid Syntax");
   return error;
 }
 
+SBStructuredData::operator bool() const { return IsValid(); }
+
 bool SBStructuredData::IsValid() const { return m_impl_up->IsValid(); }
 
 void SBStructuredData::Clear() { m_impl_up->Clear(); }
 
 SBError SBStructuredData::GetAsJSON(lldb::SBStream &stream) const {
   SBError error;
   error.SetError(m_impl_up->GetAsJSON(stream.ref()));
   return error;

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;
 }
 
+SBSymbol::operator bool() const { return IsValid(); }
+
 bool SBSymbol::IsValid() const { return m_opaque_ptr != NULL; }
 
 const char *SBSymbol::GetName() const {
   const char *name = NULL;
   if (m_opaque_ptr)
     name = m_opaque_ptr->GetName().AsCString();
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));

source/API/SBSymbolContext.cpp

if (sc_ptr) {
     else
       m_opaque_up.reset(new SymbolContext(*sc_ptr));
   } else {
     if (m_opaque_up)
       m_opaque_up->Clear(true);
   }
 }
 
+SBSymbolContext::operator bool() const { return IsValid(); }
+
 bool SBSymbolContext::IsValid() const { return m_opaque_up != NULL; }
 
 SBModule SBSymbolContext::GetModule() {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
   SBModule sb_module;
   ModuleSP module_sp;
   if (m_opaque_up) {

source/API/SBSymbolContextList.cpp

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

source/API/SBTarget.cpp

const ModuleList module_list =
       Target::TargetEventData::GetModuleListFromEvent(event.get());
   return SBModule(module_list.GetModuleAtIndex(idx));
 }
 
 const char *SBTarget::GetBroadcasterClassName() {
   return Target::GetStaticBroadcasterClass().AsCString();
 }
 
+SBTarget::operator bool() const { return IsValid(); }
+
 bool SBTarget::IsValid() const {
   return m_opaque_sp.get() != NULL && m_opaque_sp->IsValid();
 }
 
 SBProcess SBTarget::GetProcess() {
   SBProcess sb_process;
   ProcessSP process_sp;
   TargetSP target_sp(GetSP());

source/API/SBThread.cpp

lldb::SBQueue SBThread::GetQueue() const {
   if (log)
     log->Printf("SBThread(%p)::GetQueue () => SBQueue(%p)",
                 static_cast<void *>(exe_ctx.GetThreadPtr()),
                 static_cast<void *>(queue_sp.get()));
 
   return sb_queue;
 }
 
+SBThread::operator bool() const { return IsValid(); }
+
 bool SBThread::IsValid() const {
   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;

source/API/SBThreadCollection.cpp

 lldb::ThreadCollectionSP &SBThreadCollection::operator*() {
   return m_opaque_sp;
 }
 
 const lldb::ThreadCollectionSP &SBThreadCollection::operator*() const {
   return m_opaque_sp;
 }
 
+SBThreadCollection::operator bool() const { return IsValid(); }
+
 bool SBThreadCollection::IsValid() const { return m_opaque_sp.get() != NULL; }
 
 size_t SBThreadCollection::GetSize() {
   if (m_opaque_sp)
     return m_opaque_sp->GetSize();
   return 0;
 }
 
 SBThread SBThreadCollection::GetThreadAtIndex(size_t idx) {
   SBThread thread;
   if (m_opaque_sp && idx < m_opaque_sp->GetSize())
     thread = m_opaque_sp->GetThreadAtIndex(idx);
   return thread;
 }

source/API/SBThreadPlan.cpp

 }
 //----------------------------------------------------------------------
 // Destructor
 //----------------------------------------------------------------------
 SBThreadPlan::~SBThreadPlan() {}
 
 lldb_private::ThreadPlan *SBThreadPlan::get() { return m_opaque_sp.get(); }
 
+SBThreadPlan::operator bool() const { return IsValid(); }
+
 bool SBThreadPlan::IsValid() const { return m_opaque_sp.get() != NULL; }
 
 void SBThreadPlan::Clear() { m_opaque_sp.reset(); }
 
 lldb::StopReason SBThreadPlan::GetStopReason() { return eStopReasonNone; }
 
 size_t SBThreadPlan::GetStopReasonDataCount() { return 0; }
 

source/API/SBTrace.cpp

 SBTrace::SBTrace() {
   m_trace_impl_sp = std::make_shared<TraceImpl>();
   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; }
 
+SBTrace::operator bool() { return IsValid(); }
+
 bool SBTrace::IsValid() {
   if (!m_trace_impl_sp)
     return false;
   if (!GetSP())
     return false;
   return true;
 }

source/API/SBTraceOptions.cpp

if (m_traceoptions_sp)
     m_traceoptions_sp->setTraceBufferSize(size);
 }
 
 void SBTraceOptions::setMetaDataBufferSize(uint64_t size) {
   if (m_traceoptions_sp)
     m_traceoptions_sp->setMetaDataBufferSize(size);
 }
 
+SBTraceOptions::operator bool() { return IsValid(); }
+
 bool SBTraceOptions::IsValid() {
   if (m_traceoptions_sp)
     return true;
   return false;
 }
 
 void SBTraceOptions::setThreadID(lldb::tid_t thread_id) {
   if (m_traceoptions_sp)
     m_traceoptions_sp->setThreadID(thread_id);
 }
 
 lldb::tid_t SBTraceOptions::getThreadID() {
   if (m_traceoptions_sp)
     return m_traceoptions_sp->getThreadID();
   return LLDB_INVALID_THREAD_ID;
 }

source/API/SBType.cpp

 const TypeImpl &SBType::ref() const {
   // "const SBAddress &addr" should already have checked "addr.IsValid()" prior
   // 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;
 }
 
+SBType::operator bool() const { return IsValid(); }
+
 bool SBType::IsValid() const {
   if (m_opaque_sp.get() == NULL)
     return false;
 
   return m_opaque_sp->IsValid();
 }
 
 uint64_t SBType::GetByteSize() {

 
 SBTypeList::SBTypeList(const SBTypeList &rhs)
     : m_opaque_up(new TypeListImpl()) {
   for (uint32_t i = 0, rhs_size = const_cast<SBTypeList &>(rhs).GetSize();
        i < rhs_size; i++)
     Append(const_cast<SBTypeList &>(rhs).GetTypeAtIndex(i));
 }
 
+SBTypeList::operator bool() { return IsValid(); }
+
 bool SBTypeList::IsValid() { return (m_opaque_up != NULL); }
 
 SBTypeList &SBTypeList::operator=(const SBTypeList &rhs) {
   if (this != &rhs) {
     m_opaque_up.reset(new TypeListImpl());
     for (uint32_t i = 0, rhs_size = const_cast<SBTypeList &>(rhs).GetSize();
          i < rhs_size; i++)
       Append(const_cast<SBTypeList &>(rhs).GetTypeAtIndex(i));

 lldb::SBTypeMember &SBTypeMember::operator=(const lldb::SBTypeMember &rhs) {
   if (this != &rhs) {
     if (rhs.IsValid())
       m_opaque_up.reset(new TypeMemberImpl(rhs.ref()));
   }
   return *this;
 }
 
+SBTypeMember::operator bool() const { return IsValid(); }
+
 bool SBTypeMember::IsValid() const { return m_opaque_up.get(); }
 
 const char *SBTypeMember::GetName() {
   if (m_opaque_up)
     return m_opaque_up->GetName().GetCString();
   return NULL;
 }
 

 
 lldb::SBTypeMemberFunction &SBTypeMemberFunction::
 operator=(const lldb::SBTypeMemberFunction &rhs) {
   if (this != &rhs)
     m_opaque_sp = rhs.m_opaque_sp;
   return *this;
 }
 
+SBTypeMemberFunction::operator bool() const { return IsValid(); }
+
 bool SBTypeMemberFunction::IsValid() const { return m_opaque_sp.get(); }
 
 const char *SBTypeMemberFunction::GetName() {
   if (m_opaque_sp)
     return m_opaque_sp->GetName().GetCString();
   return NULL;
 }
 

source/API/SBTypeCategory.cpp

SBTypeCategory::SBTypeCategory(const char *name) : m_opaque_sp() {
   DataVisualization::Categories::GetCategory(ConstString(name), m_opaque_sp);
 }
 
 SBTypeCategory::SBTypeCategory(const lldb::SBTypeCategory &rhs)
     : m_opaque_sp(rhs.m_opaque_sp) {}
 
 SBTypeCategory::~SBTypeCategory() {}
 
+SBTypeCategory::operator bool() const { return IsValid(); }
+
 bool SBTypeCategory::IsValid() const { return (m_opaque_sp.get() != NULL); }
 
 bool SBTypeCategory::GetEnabled() {
   if (!IsValid())
     return false;
   return m_opaque_sp->IsEnabled();
 }
 

source/API/SBTypeEnumMember.cpp

 SBTypeEnumMember &SBTypeEnumMember::operator=(const SBTypeEnumMember &rhs) {
   if (this != &rhs) {
     if (rhs.IsValid())
       m_opaque_sp = std::make_shared<TypeEnumMemberImpl>(rhs.ref());
   }
   return *this;
 }
 
+SBTypeEnumMember::operator bool() const { return IsValid(); }
+
 bool SBTypeEnumMember::IsValid() const { return m_opaque_sp.get(); }
 
 const char *SBTypeEnumMember::GetName() {
   if (m_opaque_sp.get())
     return m_opaque_sp->GetName().GetCString();
   return NULL;
 }
 

 SBTypeEnumMemberList::SBTypeEnumMemberList(const SBTypeEnumMemberList &rhs)
     : m_opaque_up(new TypeEnumMemberListImpl()) {
   for (uint32_t i = 0,
                 rhs_size = const_cast<SBTypeEnumMemberList &>(rhs).GetSize();
        i < rhs_size; i++)
     Append(const_cast<SBTypeEnumMemberList &>(rhs).GetTypeEnumMemberAtIndex(i));
 }
 
+SBTypeEnumMemberList::operator bool() { return IsValid(); }
+
 bool SBTypeEnumMemberList::IsValid() { return (m_opaque_up != NULL); }
 
 SBTypeEnumMemberList &SBTypeEnumMemberList::
 operator=(const SBTypeEnumMemberList &rhs) {
   if (this != &rhs) {
     m_opaque_up.reset(new TypeEnumMemberListImpl());
     for (uint32_t i = 0,
                   rhs_size = const_cast<SBTypeEnumMemberList &>(rhs).GetSize();

source/API/SBTypeFilter.cpp

 SBTypeFilter::SBTypeFilter(uint32_t options)
     : m_opaque_sp(TypeFilterImplSP(new TypeFilterImpl(options))) {}
 
 SBTypeFilter::SBTypeFilter(const lldb::SBTypeFilter &rhs)
     : m_opaque_sp(rhs.m_opaque_sp) {}
 
 SBTypeFilter::~SBTypeFilter() {}
 
+SBTypeFilter::operator bool() const { return IsValid(); }
+
 bool SBTypeFilter::IsValid() const { return m_opaque_sp.get() != NULL; }
 
 uint32_t SBTypeFilter::GetOptions() {
   if (IsValid())
     return m_opaque_sp->GetOptions();
   return 0;
 }
 

source/API/SBTypeFormat.cpp

SBTypeFormat::SBTypeFormat(const char *type, uint32_t options)
     : m_opaque_sp(TypeFormatImplSP(new TypeFormatImpl_EnumType(
           ConstString(type ? type : ""), options))) {}
 
 SBTypeFormat::SBTypeFormat(const lldb::SBTypeFormat &rhs)
     : m_opaque_sp(rhs.m_opaque_sp) {}
 
 SBTypeFormat::~SBTypeFormat() {}
 
+SBTypeFormat::operator bool() const { return IsValid(); }
+
 bool SBTypeFormat::IsValid() const { return m_opaque_sp.get() != NULL; }
 
 lldb::Format SBTypeFormat::GetFormat() {
   if (IsValid() && m_opaque_sp->GetType() == TypeFormatImpl::Type::eTypeFormat)
     return ((TypeFormatImpl_Format *)m_opaque_sp.get())->GetFormat();
   return lldb::eFormatInvalid;
 }
 

source/API/SBTypeNameSpecifier.cpp

m_opaque_sp = TypeNameSpecifierImplSP(
         new TypeNameSpecifierImpl(type.m_opaque_sp->GetCompilerType(true)));
 }
 
 SBTypeNameSpecifier::SBTypeNameSpecifier(const lldb::SBTypeNameSpecifier &rhs)
     : m_opaque_sp(rhs.m_opaque_sp) {}
 
 SBTypeNameSpecifier::~SBTypeNameSpecifier() {}
 
+SBTypeNameSpecifier::operator bool() const { return IsValid(); }
+
 bool SBTypeNameSpecifier::IsValid() const { return m_opaque_sp.get() != NULL; }
 
 const char *SBTypeNameSpecifier::GetName() {
   if (!IsValid())
     return NULL;
 
   return m_opaque_sp->GetName();
 }

source/API/SBTypeSummary.cpp

SBTypeSummaryOptions::SBTypeSummaryOptions(
   if (rhs.m_opaque_up)
     m_opaque_up.reset(new TypeSummaryOptions(*rhs.m_opaque_up));
   else
     m_opaque_up.reset(new TypeSummaryOptions());
 }
 
 SBTypeSummaryOptions::~SBTypeSummaryOptions() {}
 
+SBTypeSummaryOptions::operator bool() { return IsValid(); }
+
 bool SBTypeSummaryOptions::IsValid() { return m_opaque_up.get(); }
 
 lldb::LanguageType SBTypeSummaryOptions::GetLanguage() {
   if (IsValid())
     return m_opaque_up->GetLanguage();
   return lldb::eLanguageTypeUnknown;
 }
 
SBTypeSummary SBTypeSummary::CreateWithCallback(FormatCallback cb,
   return retval;
 }
 
 SBTypeSummary::SBTypeSummary(const lldb::SBTypeSummary &rhs)
     : m_opaque_sp(rhs.m_opaque_sp) {}
 
 SBTypeSummary::~SBTypeSummary() {}
 
+SBTypeSummary::operator bool() const { return IsValid(); }
+
 bool SBTypeSummary::IsValid() const { return m_opaque_sp.get() != NULL; }
 
 bool SBTypeSummary::IsFunctionCode() {
   if (!IsValid())
     return false;
   if (ScriptSummaryFormat *script_summary_ptr =
           llvm::dyn_cast<ScriptSummaryFormat>(m_opaque_sp.get())) {
     const char *ftext = script_summary_ptr->GetPythonScript();

source/API/SBTypeSynthetic.cpp

return SBTypeSynthetic(ScriptedSyntheticChildrenSP(
       new ScriptedSyntheticChildren(options, "", data)));
 }
 
 SBTypeSynthetic::SBTypeSynthetic(const lldb::SBTypeSynthetic &rhs)
     : m_opaque_sp(rhs.m_opaque_sp) {}
 
 SBTypeSynthetic::~SBTypeSynthetic() {}
 
+SBTypeSynthetic::operator bool() const { return IsValid(); }
+
 bool SBTypeSynthetic::IsValid() const { return m_opaque_sp.get() != NULL; }
 
 bool SBTypeSynthetic::IsClassCode() {
   if (!IsValid())
     return false;
   const char *code = m_opaque_sp->GetPythonCode();
   return (code && *code);
 }

source/API/SBUnixSignals.cpp

 UnixSignalsSP SBUnixSignals::GetSP() const { return m_opaque_wp.lock(); }
 
 void SBUnixSignals::SetSP(const UnixSignalsSP &signals_sp) {
   m_opaque_wp = signals_sp;
 }
 
 void SBUnixSignals::Clear() { m_opaque_wp.reset(); }
 
+SBUnixSignals::operator bool() const { return IsValid(); }
+
 bool SBUnixSignals::IsValid() const { return static_cast<bool>(GetSP()); }
 
 const char *SBUnixSignals::GetSignalAsCString(int32_t signo) const {
   if (auto signals_sp = GetSP())
     return signals_sp->GetSignalAsCString(signo);
 
   return nullptr;
 }

source/API/SBValue.cpp

SBValue &SBValue::operator=(const SBValue &rhs) {
   if (this != &rhs) {
     SetSP(rhs.m_opaque_sp);
   }
   return *this;
 }
 
 SBValue::~SBValue() {}
 
+SBValue::operator bool() { return IsValid(); }
+
 bool SBValue::IsValid() {
   // 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;
 }
 

source/API/SBValueList.cpp

if (log) {
     log->Printf("SBValueList::SBValueList (lldb_object_ptr=%p) => this.ap = %p",
                 static_cast<const void *>(lldb_object_ptr),
                 static_cast<void *>(m_opaque_up.get()));
   }
 }
 
 SBValueList::~SBValueList() {}
 
+SBValueList::operator bool() const { return IsValid(); }
+
 bool SBValueList::IsValid() const { return (m_opaque_up != NULL); }
 
 void SBValueList::Clear() { m_opaque_up.reset(); }
 
 const SBValueList &SBValueList::operator=(const SBValueList &rhs) {
   if (this != &rhs) {
     if (rhs.IsValid())
       m_opaque_up.reset(new ValueListImpl(*rhs));

source/API/SBVariablesOptions.cpp

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

source/API/SBWatchpoint.cpp

if (log) {
     else
       log->Printf("SBWatchpoint(%p)::GetID () => %u",
                   static_cast<void *>(watchpoint_sp.get()), watch_id);
   }
 
   return watch_id;
 }
 
+SBWatchpoint::operator bool() const { return IsValid(); }
+
 bool SBWatchpoint::IsValid() const { return bool(m_opaque_wp.lock()); }
 
 SBError SBWatchpoint::GetError() {
   SBError sb_error;
   lldb::WatchpointSP watchpoint_sp(GetSP());
   if (watchpoint_sp) {
     sb_error.SetError(watchpoint_sp->GetError());
   }