Remove unneeded #ifdef SWIGs

[labath]

Summary

Some of these were present in files which should never be read by swig
(and we also had one in the interface file, which is only read by swig).
They are probably leftovers from the time when we were running swig over
lldb headers directly.

The reason I'm putting this up for review is that the patch also
contains mild functional changes. While writing this patch, I noticed
that some of the #ifdefs were guarding public functions that were
operating on lldb_private data types. While it wasn't strictly
necessary, I made these private, as nobody should really be accessing
them. This can potentially break existing code if it happened to use
these methods, though it will only break at build time -- if someone
builds against an old header, he should still be able to link to a new
lldb library, since the functions are still there.

We could keep these public for backward compatbility, but I would argue
that if anyone was actually using these functions for anything, his code
is already broken.

[JDevlieghere]

LGTM

include/lldb/API/SBDefines.h

 
 
 #include "lldb/lldb-defines.h"
 #include "lldb/lldb-enumerations.h"
 #include "lldb/lldb-forward.h"
 #include "lldb/lldb-types.h"
 #include "lldb/lldb-versioning.h"
 
-#ifdef SWIG
-#define LLDB_API
-#endif
-
 // Forward Declarations
 namespace lldb {
 
 class LLDB_API SBAddress;
 class LLDB_API SBBlock;
 class LLDB_API SBBreakpoint;
 class LLDB_API SBBreakpointLocation;
 class LLDB_API SBBreakpointName;

include/lldb/API/SBThread.h

public:
   uint32_t GetExtendedBacktraceOriginatingIndexID();
 
   SBValue GetCurrentException();
 
   SBThread GetCurrentExceptionBacktrace();
 
   bool SafeToCallFunctions();
 
-#ifndef SWIG
-  lldb_private::Thread *operator->();
-
-  lldb_private::Thread *get();
-
-#endif
-
-protected:
+private:
   friend class SBBreakpoint;
   friend class SBBreakpointLocation;
   friend class SBBreakpointCallbackBaton;
   friend class SBExecutionContext;
   friend class SBFrame;
   friend class SBProcess;
   friend class SBDebugger;
   friend class SBValue;
   friend class lldb_private::QueueImpl;
   friend class SBQueueItem;
+  friend class SBThreadPlan;
 
   void SetThread(const lldb::ThreadSP &lldb_object_sp);
 
-#ifndef SWIG
   SBError ResumeNewPlan(lldb_private::ExecutionContext &exe_ctx,
                         lldb_private::ThreadPlan *new_plan);
-#endif
 
-private:
   lldb::ExecutionContextRefSP m_opaque_sp;
+
+  lldb_private::Thread *operator->();
+
+  lldb_private::Thread *get();
 };
 
 } // namespace lldb
 
 #endif // LLDB_SBThread_h_

include/lldb/API/SBThreadPlan.h

public:
   SBThreadPlan QueueThreadPlanForRunToAddress(SBAddress address);
   SBThreadPlan QueueThreadPlanForRunToAddress(SBAddress address,
                                               SBError &error);
 
   SBThreadPlan QueueThreadPlanForStepScripted(const char *script_class_name);
   SBThreadPlan QueueThreadPlanForStepScripted(const char *script_class_name,
                                               SBError &error);
 
-#ifndef SWIG
-  lldb_private::ThreadPlan *get();
-#endif
-
-protected:
+private:
   friend class SBBreakpoint;
   friend class SBBreakpointLocation;
   friend class SBFrame;
   friend class SBProcess;
   friend class SBDebugger;
   friend class SBValue;
   friend class lldb_private::QueueImpl;
   friend class SBQueueItem;
 
-#ifndef SWIG
+  lldb_private::ThreadPlan *get();
   void SetThreadPlan(const lldb::ThreadPlanSP &lldb_object_sp);
-#endif
 
-private:
   lldb::ThreadPlanSP m_opaque_sp;
 };
 
 } // namespace lldb
 
 #endif // LLDB_SBThreadPlan_h_

include/lldb/Core/Address.h

 /// object.
 ///
 /// \param[in] rhs
 ///     A const Address object reference to copy.
 ///
 /// \return
 ///     A const Address object reference to \a this.
 //------------------------------------------------------------------
-#ifndef SWIG
   const Address &operator=(const Address &rhs);
-#endif
 
   //------------------------------------------------------------------
   /// Clear the object's state.
   ///
   /// Sets the section to an invalid value (NULL) and an invalid offset
   /// (LLDB_INVALID_ADDRESS).
   //------------------------------------------------------------------
   void Clear() {

include/lldb/Core/SourceManager.h

 namespace lldb_private {
 class Target;
 }
 
 namespace lldb_private {
 
 class SourceManager {
 public:
-#ifndef SWIG
   class File {
     friend bool operator==(const SourceManager::File &lhs,
                            const SourceManager::File &rhs);
 
   public:
     File(const FileSpec &file_spec, Target *target);
     File(const FileSpec &file_spec, lldb::DebuggerSP debugger_sp);
     ~File() = default;
protected:
     lldb::DataBufferSP m_data_sp;
     typedef std::vector<uint32_t> LineOffsets;
     LineOffsets m_offsets;
     lldb::DebuggerWP m_debugger_wp;
 
   private:
     void CommonInitializer(const FileSpec &file_spec, Target *target);
   };
-#endif // SWIG
 
   typedef std::shared_ptr<File> FileSP;
 
-#ifndef SWIG
   // The SourceFileCache class separates the source manager from the cache of
   // source files, so the cache can be stored in the Debugger, but the source
   // managers can be per target.
   class SourceFileCache {
   public:
     SourceFileCache() = default;
     ~SourceFileCache() = default;
 
     void AddSourceFile(const FileSP &file_sp);
     FileSP FindSourceFile(const FileSpec &file_spec) const;
 
   protected:
     typedef std::map<FileSpec, FileSP> FileCache;
     FileCache m_file_cache;
   };
-#endif // SWIG
 
   //------------------------------------------------------------------
   // Constructors and Destructors
   //------------------------------------------------------------------
   // A source manager can be made with a non-null target, in which case it can
   // use the path remappings to find
   // source files that are not in their build locations.  With no target it
   // won't be able to do this.

include/lldb/Target/Process.h

 
 //------------------------------------------------------------------
 /// A notification structure that can be used by clients to listen
 /// for changes in a process's lifetime.
 ///
 /// \see RegisterNotificationCallbacks (const Notifications&) @see
 /// UnregisterNotificationCallbacks (const Notifications&)
 //------------------------------------------------------------------
-#ifndef SWIG
   typedef struct {
     void *baton;
     void (*initialize)(void *baton, Process *process);
     void (*process_state_changed)(void *baton, Process *process,
                                   lldb::StateType state);
   } Notifications;
 
   class ProcessEventData : public EventData {
private:
     std::vector<std::string> m_restarted_reasons;
     bool m_restarted; // For "eStateStopped" events, this is true if the target
                       // was automatically restarted.
     int m_update_state;
     bool m_interrupted;
 
     DISALLOW_COPY_AND_ASSIGN(ProcessEventData);
   };
-#endif // SWIG
 
   //------------------------------------------------------------------
   /// Construct with a shared pointer to a target, and the Process listener.
   /// Uses the Host UnixSignalsSP by default.
   //------------------------------------------------------------------
   Process(lldb::TargetSP target_sp, lldb::ListenerSP listener_sp);
 
   //------------------------------------------------------------------

 /// Process::Notifications structure and calling this function.
 ///
 /// \param[in] callbacks
 ///     A structure that contains the notification baton and
 ///     callback functions.
 ///
 /// \see Process::Notifications
 //------------------------------------------------------------------
-#ifndef SWIG
   void RegisterNotificationCallbacks(const Process::Notifications &callbacks);
-#endif
 
 //------------------------------------------------------------------
 /// Unregister for process and thread notifications.
 ///
 /// Clients can unregister notification callbacks by passing a copy of the
 /// original baton and callbacks in \a callbacks.
 ///
 /// \param[in] callbacks
 ///     A structure that contains the notification baton and
 ///     callback functions.
 ///
 /// \return
 ///     Returns \b true if the notification callbacks were
 ///     successfully removed from the process, \b false otherwise.
 ///
 /// \see Process::Notifications
 //------------------------------------------------------------------
-#ifndef SWIG
   bool UnregisterNotificationCallbacks(const Process::Notifications &callbacks);
-#endif
 
   //==================================================================
   // Built in Process Control functions
   //==================================================================
   //------------------------------------------------------------------
   /// Resumes all of a process's threads as configured using the Thread run
   /// control functions.
   ///

scripts/interface/SBFrame.i

~SBFrame();
     GetThread () const;
 
     const char *
     Disassemble () const;
 
     void
     Clear();
 
-#ifndef SWIG
     bool
     operator == (const lldb::SBFrame &rhs) const;
 
     bool
     operator != (const lldb::SBFrame &rhs) const;
 
-#endif
-
     %feature("docstring", "
     /// The version that doesn't supply a 'use_dynamic' value will use the
     /// target's default.
     ") GetVariables;
     lldb::SBValueList
     GetVariables (bool arguments,
                   bool locals,
                   bool statics,

source/API/SBThread.cpp

bool SBThread::SafeToCallFunctions() {
 
   ThreadSP thread_sp(m_opaque_sp->GetThreadSP());
   if (thread_sp)
     return thread_sp->SafeToCallFunctions();
   return true;
 }
 
 lldb_private::Thread *SBThread::operator->() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb_private::Thread *, SBThread, operator->);
-
-  ThreadSP thread_sp(m_opaque_sp->GetThreadSP());
-  if (thread_sp)
-    return LLDB_RECORD_RESULT(thread_sp.get());
-  return nullptr;
+  return get();
 }
 
 lldb_private::Thread *SBThread::get() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb_private::Thread *, SBThread, get);
-
-  ThreadSP thread_sp(m_opaque_sp->GetThreadSP());
-  if (thread_sp)
-    return LLDB_RECORD_RESULT(thread_sp.get());
-  return nullptr;
+  return m_opaque_sp->GetThreadSP().get();
 }
 
 namespace lldb_private {
 namespace repro {
 
 template <>
 void RegisterMethods<SBThread>(Registry &R) {
   LLDB_REGISTER_STATIC_METHOD(const char *, SBThread, GetBroadcasterClassName,
void RegisterMethods<SBThread>(Registry &R) {
   LLDB_REGISTER_METHOD(lldb::SBThread, SBThread, GetExtendedBacktraceThread,
                        (const char *));
   LLDB_REGISTER_METHOD(uint32_t, SBThread,
                        GetExtendedBacktraceOriginatingIndexID, ());
   LLDB_REGISTER_METHOD(lldb::SBValue, SBThread, GetCurrentException, ());
   LLDB_REGISTER_METHOD(lldb::SBThread, SBThread, GetCurrentExceptionBacktrace,
                        ());
   LLDB_REGISTER_METHOD(bool, SBThread, SafeToCallFunctions, ());
-  LLDB_REGISTER_METHOD(lldb_private::Thread *, SBThread, operator->,());
-  LLDB_REGISTER_METHOD(lldb_private::Thread *, SBThread, get, ());
 }
 
 }
 }

source/API/SBThreadPlan.cpp

if (this != &rhs)
     m_opaque_sp = rhs.m_opaque_sp;
   return LLDB_RECORD_RESULT(*this);
 }
 //----------------------------------------------------------------------
 // Destructor
 //----------------------------------------------------------------------
 SBThreadPlan::~SBThreadPlan() {}
 
-lldb_private::ThreadPlan *SBThreadPlan::get() {
-  LLDB_RECORD_METHOD_NO_ARGS(lldb_private::ThreadPlan *, SBThreadPlan, get);
-
-  return LLDB_RECORD_RESULT(m_opaque_sp.get());
-}
+lldb_private::ThreadPlan *SBThreadPlan::get() { return m_opaque_sp.get(); }
 
 bool SBThreadPlan::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBThreadPlan, IsValid);
   return this->operator bool();
 }
 SBThreadPlan::operator bool() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBThreadPlan, operator bool);
 

 template <>
 void RegisterMethods<SBThreadPlan>(Registry &R) {
   LLDB_REGISTER_CONSTRUCTOR(SBThreadPlan, ());
   LLDB_REGISTER_CONSTRUCTOR(SBThreadPlan, (const lldb::ThreadPlanSP &));
   LLDB_REGISTER_CONSTRUCTOR(SBThreadPlan, (const lldb::SBThreadPlan &));
   LLDB_REGISTER_CONSTRUCTOR(SBThreadPlan, (lldb::SBThread &, const char *));
   LLDB_REGISTER_METHOD(const lldb::SBThreadPlan &,
                        SBThreadPlan, operator=,(const lldb::SBThreadPlan &));
-  LLDB_REGISTER_METHOD(lldb_private::ThreadPlan *, SBThreadPlan, get, ());
   LLDB_REGISTER_METHOD_CONST(bool, SBThreadPlan, IsValid, ());
   LLDB_REGISTER_METHOD_CONST(bool, SBThreadPlan, operator bool, ());
   LLDB_REGISTER_METHOD(void, SBThreadPlan, Clear, ());
   LLDB_REGISTER_METHOD(lldb::StopReason, SBThreadPlan, GetStopReason, ());
   LLDB_REGISTER_METHOD(size_t, SBThreadPlan, GetStopReasonDataCount, ());
   LLDB_REGISTER_METHOD(uint64_t, SBThreadPlan, GetStopReasonDataAtIndex,
                        (uint32_t));
   LLDB_REGISTER_METHOD_CONST(lldb::SBThread, SBThreadPlan, GetThread, ());