Make methods of exported API classes that access internal types private.

[zturner]

Summary

As part of the contract of a dll-exported C++ interface, classes that are not exported should not be accessible via a public interface of an exported class, and doing so generates warnings on MSVC. These warnings can be safely suprressed as long as all non-exported classes are part of the exported class's private interface, so this change moves all such methods to the private interface, friending where necessary, and finally suppresses the warnings on MSVC.

[tfiala]

I ran into a few issues with this change on both gcc and clang.

The first issue is the handling of the friend class namespace. Prepending a :: to the friend declaration for non-namespaced implementation classes took care of one of them.

The bigger issue is that the Swig-generated classes are failing in a number of static methods that need access to the now-private methods. After discussing with Zachary, I'm testing just the CMakeLists.txt portion for now and aborting the other portion until he can work on a swig-enabled build.

[tfiala]

The CMakeLists.txt cmake change warning suppression was submitted with this commit:

svn commit
Sending CMakeLists.txt
Transmitting file data .
Committed revision 209756.

[tfiala]

Current state: Zachary is going to look into addressing swig incompatibilities with the non-cmake portion of this change. We're keeping this ticket open until that portion is handled.

[tfiala]

Hey Zachary - I'd like to close this one out (or at least get it out of my inbox as a task). Can we break the second part of it into a separate task and call this one done on the first part?

[zturner]

Yes, I had totally forgotten about this one. And now I'm in the weeds on
more pressing issues. So let's call this one done and I'll treat the
remainder as a minor cleanup task, and get back to it when I have some
spare cycles.

[tfiala]

Good deal :-)

CMakeLists.txt

 endif ()
 
 # Disable MSVC warnings
 if( MSVC )
   add_lldb_definitions(
     -wd4018 # Suppress 'warning C4018: '>=' : signed/unsigned mismatch'
     -wd4068 # Suppress 'warning C4068: unknown pragma'
     -wd4150 # Suppress 'warning C4150: deletion of pointer to incomplete type'
+    -wd4251 # Suppress 'warning C4251: T must have dll-interface to be used by clients of class U.'
     -wd4521 # Suppress 'warning C4521: 'type' : multiple copy constructors specified'
     -wd4530 # Suppress 'warning C4530: C++ exception handler used, but unwind semantics are not enabled.'
   )
 endif() 
 
 # If building on a 32-bit system, make sure off_t can store offsets > 2GB
 if( CMAKE_SIZEOF_VOID_P EQUAL 4 )
   add_lldb_definitions(

include/lldb/API/SBDebugger.h

 #ifndef LLDB_SBDebugger_h_
 #define LLDB_SBDebugger_h_
 
 #include <stdio.h>
 
 #include "lldb/API/SBDefines.h"
 #include "lldb/API/SBPlatform.h"
 
+class CommandPluginInterfaceImplementation;
+
 namespace lldb {
 
     
 class SBInputReader
 {
 public:
     SBInputReader();
     ~SBInputReader();
public:
 
     static void
     Destroy (lldb::SBDebugger &debugger);
 
     static void
     MemoryPressureDetected ();
 
     SBDebugger();
-
     SBDebugger(const lldb::SBDebugger &rhs);
 
-    SBDebugger(const lldb::DebuggerSP &debugger_sp);
-    
     lldb::SBDebugger &
     operator = (const lldb::SBDebugger &rhs);
     
     ~SBDebugger();
 
     bool
     IsValid() const;
 

 private:
 
     friend class SBCommandInterpreter;
     friend class SBInputReader;
     friend class SBListener;
     friend class SBProcess;
     friend class SBSourceManager;
     friend class SBTarget;
-    
+    friend class CommandPluginInterfaceImplementation;
+
+    SBDebugger(const lldb::DebuggerSP &debugger_sp);    
+
+    static lldb::DynamicLibrarySP
+    LoadPlugin (const lldb::DebuggerSP &debugger_sp, const lldb_private::FileSpec& spec, lldb_private::Error& error);
     lldb::SBTarget
     FindTargetWithLLDBProcess (const lldb::ProcessSP &processSP);
 
     void
     reset (const lldb::DebuggerSP &debugger_sp);
 
     lldb_private::Debugger *
     get () const;

include/lldb/API/SBFrame.h

~SBFrame();
     /// operation succeeds.  Otherwise, an invalid SBValue is returned.
     /// You can use LLDB_WATCH_TYPE_READ | LLDB_WATCH_TYPE_WRITE for 'rw' watch.
     lldb::SBValue
     WatchLocation (const char *name, ValueType value_type, uint32_t watch_type, size_t size);
 
     bool
     GetDescription (lldb::SBStream &description);
 
-    SBFrame (const lldb::StackFrameSP &lldb_object_sp);
-
 protected:
 
     friend class SBBlock;
     friend class SBInstruction;
     friend class SBThread;
     friend class SBValue;
 #ifndef LLDB_DISABLE_PYTHON
     friend class lldb_private::ScriptInterpreterPython;
 #endif
 
+    SBFrame (const lldb::StackFrameSP &lldb_object_sp);
+
     lldb::StackFrameSP
     GetFrameSP() const;
 
     void
     SetFrameSP (const lldb::StackFrameSP &lldb_object_sp);
 
     lldb::ExecutionContextRefSP m_opaque_sp;
 };
 
 } // namespace lldb
 
 #endif  // LLDB_SBFrame_h_

include/lldb/API/SBProcess.h

public:
 
     SBProcess ();
 
     SBProcess (const lldb::SBProcess& rhs);
 
     const lldb::SBProcess&
     operator = (const lldb::SBProcess& rhs);
 
-    SBProcess (const lldb::ProcessSP &process_sp);
-    
     ~SBProcess();
 
     static const char *
     GetBroadcasterClassName ();
     
     const char *
     GetPluginName ();
     
protected:
     friend class SBDebugger;
     friend class SBFunction;
     friend class SBModule;
     friend class SBTarget;
     friend class SBThread;
     friend class SBValue;
     friend class lldb_private::QueueImpl;
 
+    SBProcess (const lldb::ProcessSP &process_sp);    
+
     lldb::ProcessSP
     GetSP() const;
     
     void
     SetSP (const lldb::ProcessSP &process_sp);
 
     lldb::ProcessWP m_opaque_wp;
 };
 
 }  // namespace lldb
 
 #endif  // LLDB_SBProcess_h_

include/lldb/API/SBQueueItem.h

 
 namespace lldb {
 
 class SBQueueItem
 {
 public:
     SBQueueItem ();
 
-    SBQueueItem (const lldb::QueueItemSP& queue_item_sp);
-    
    ~SBQueueItem();
 
     bool
     IsValid() const;
 
     void
     Clear ();
 
     lldb::QueueItemKind
     GetKind () const;
 
     void
     SetKind (lldb::QueueItemKind kind);
 
     lldb::SBAddress
     GetAddress () const;
 
     void
     SetAddress (lldb::SBAddress addr);
 
-    void
-    SetQueueItem (const lldb::QueueItemSP& queue_item_sp);
-
     SBThread
     GetExtendedBacktraceThread (const char *type);
 
 private:
+    friend class lldb_private::QueueImpl;
+
+    SBQueueItem(const QueueItemSP& queue_item_sp);
+    
+    void
+    SetQueueItem (const lldb::QueueItemSP& queue_item_sp);
+
     lldb::QueueItemSP           m_queue_item_sp;
 };
 
 } // namespace lldb
 
 #endif  // LLDB_SBQueueItem_h_

include/lldb/API/SBTarget.h

public:
 
     //------------------------------------------------------------------
     // Constructors
     //------------------------------------------------------------------
     SBTarget ();
 
     SBTarget (const lldb::SBTarget& rhs);
 
-    SBTarget (const lldb::TargetSP& target_sp);
-    
     const lldb::SBTarget&
     operator = (const lldb::SBTarget& rhs);
 
     //------------------------------------------------------------------
     // Destructor
     //------------------------------------------------------------------
     ~SBTarget();
 
protected:
     friend class SBSourceManager;
     friend class SBSymbol;
     friend class SBValue;
 
     //------------------------------------------------------------------
     // Constructors are private, use static Target::Create function to
     // create an instance of this class.
     //------------------------------------------------------------------
+    SBTarget (const lldb::TargetSP& target_sp);
 
     lldb::TargetSP
     GetSP () const;
 
     void
     SetSP (const lldb::TargetSP& target_sp);
 
 

include/lldb/API/SBThread.h

public:
 
     static const char *
     GetBroadcasterClassName ();
     
     SBThread ();
 
     SBThread (const lldb::SBThread &thread);
     
-    SBThread (const lldb::ThreadSP& lldb_object_sp);
-
    ~SBThread();
 
     lldb::SBQueue
     GetQueue () const;
 
     bool
     IsValid() const;
 
protected:
     friend class SBBreakpointLocation;
     friend class SBFrame;
     friend class SBProcess;
     friend class SBDebugger;
     friend class SBValue;
     friend class lldb_private::QueueImpl;
     friend class SBQueueItem;
 
+    SBThread (const lldb::ThreadSP& lldb_object_sp);
+
     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;
 };
 
 } // namespace lldb
 
 #endif  // LLDB_SBThread_h_

include/lldb/API/SBValue.h

#endif
 
     bool
     GetExpressionPath (lldb::SBStream &description);
     
     bool
     GetExpressionPath (lldb::SBStream &description, 
                        bool qualify_cxx_base_classes);
 
-    SBValue (const lldb::ValueObjectSP &value_sp);
-
     //------------------------------------------------------------------
     /// Watch this value if it resides in memory.
     ///
     /// Sets a watchpoint on the value.
     ///
     /// @param[in] resolve_location
     ///     Resolve the location of this value once and watch its address.
     ///     This value must currently be set to \b true as watching all
#endif
     ///     An SBWatchpoint object. This object might not be valid upon
     ///     return due to a value not being contained in memory, too 
     ///     large, or watchpoint resources are not available or all in
     ///     use.
     //------------------------------------------------------------------
     lldb::SBWatchpoint
     WatchPointee (bool resolve_location, bool read, bool write, SBError &error);
 
+protected:
+    friend class SBBlock;
+    friend class SBFrame;
+    friend class SBModule;
+    friend class SBTarget;
+    friend class SBThread;
+    friend class SBValueList;
+
+    SBValue (const lldb::ValueObjectSP &value_sp);
+
     //------------------------------------------------------------------
-    /// Same as the protected version of GetSP that takes a locker, except that we make the
+    /// Same as the version of GetSP that takes a locker, except that we make the
     /// locker locally in the function.  Since the Target API mutex is recursive, and the
     /// StopLocker is a read lock, you can call this function even if you are already
     /// holding the two above-mentioned locks.
     ///
     /// @return
     ///     A ValueObjectSP of the best kind (static, dynamic or synthetic) we
     ///     can cons up, in accordance with the SBValue's settings.
     //------------------------------------------------------------------
     lldb::ValueObjectSP
     GetSP () const;
 
-protected:
-    friend class SBBlock;
-    friend class SBFrame;
-    friend class SBTarget;
-    friend class SBThread;
-    friend class SBValueList;
-
     //------------------------------------------------------------------
     /// Get the appropriate ValueObjectSP from this SBValue, consulting the
     /// use_dynamic and use_synthetic options passed in to SetSP when the
     /// SBValue's contents were set.  Since this often requires examining memory,
     /// and maybe even running code, it needs to acquire the Target API and Process StopLock.
     /// Those are held in an opaque class ValueLocker which is currently local to SBValue.cpp.
     /// So you don't have to get these yourself just default construct a ValueLocker, and pass it into this.
     /// If we need to make a ValueLocker and use it in some other .cpp file, we'll have to move it to

include/lldb/API/SBWatchpoint.h

 class SBWatchpoint
 {
 public:
 
     SBWatchpoint ();
 
     SBWatchpoint (const lldb::SBWatchpoint &rhs);
 
-    SBWatchpoint (const lldb::WatchpointSP &wp_sp);
-
     ~SBWatchpoint ();
 
     const lldb::SBWatchpoint &
     operator = (const lldb::SBWatchpoint &rhs);
 
     bool
     IsValid() const;
 
public:
     SetCondition (const char *condition);
     
     bool
     GetDescription (lldb::SBStream &description, DescriptionLevel level);
 
     void
     Clear ();
 
-    lldb::WatchpointSP
-    GetSP () const;
-
-    void
-    SetSP (const lldb::WatchpointSP &sp);
-
     static bool
     EventIsWatchpointEvent (const lldb::SBEvent &event);
     
     static lldb::WatchpointEventType
     GetWatchpointEventTypeFromEvent (const lldb::SBEvent& event);
 
     static lldb::SBWatchpoint
     GetWatchpointFromEvent (const lldb::SBEvent& event);
 
 private:
     friend class SBTarget;
     friend class SBValue;
 
+    SBWatchpoint (const lldb::WatchpointSP &wp_sp);
+
+    lldb::WatchpointSP
+    GetSP () const;
+
+    void
+    SetSP (const lldb::WatchpointSP &sp);
     
     lldb::WatchpointSP m_opaque_sp;
 
 };
 
 } // namespace lldb
 
 #endif  // LLDB_SBWatchpoint_h_

source/API/SBDebugger.cpp

 {
 }
 bool
 SBInputReader::IsActive() const
 {
     return false;
 }
 
-static lldb::DynamicLibrarySP
-LoadPlugin (const lldb::DebuggerSP &debugger_sp, const FileSpec& spec, Error& error)
+lldb::DynamicLibrarySP
+SBDebugger::LoadPlugin (const lldb::DebuggerSP &debugger_sp, const FileSpec& spec, Error& error)
 {
     lldb::DynamicLibrarySP dynlib_sp(new lldb_private::DynamicLibrary(spec));
     if (dynlib_sp && dynlib_sp->IsValid())
     {
         typedef bool (*LLDBCommandPluginInit) (lldb::SBDebugger& debugger);
         
         lldb::SBDebugger debugger_sb(debugger_sp);
         // This calls the bool lldb::PluginInitialize(lldb::SBDebugger debugger) function.