vendor/lldb/lldb-r201577

8 files changed, 251 insertions, 119 deletions

diff --git a/include/lldb/DataFormatters/CXXFormatterFunctions.h b/include/lldb/DataFormatters/CXXFormatterFunctions.h
index 415ef9be59ef4..c53ef9589eea7 100644
--- a/include/lldb/DataFormatters/CXXFormatterFunctions.h
+++ b/include/lldb/DataFormatters/CXXFormatterFunctions.h
@@ -79,6 +79,9 @@ namespace lldb_private {
 
         bool
         LibcxxWStringSummaryProvider (ValueObject& valobj, Stream& stream); // libc++ std::wstring
+
+        bool
+        LibcxxSmartPointerSummaryProvider (ValueObject& valobj, Stream& stream); // libc++ std::shared_ptr<> and std::weak_ptr<>
         
         bool
         ObjCClassSummaryProvider (ValueObject& valobj, Stream& stream);
@@ -594,10 +597,11 @@ namespace lldb_private {
             virtual
             ~LibcxxVectorBoolSyntheticFrontEnd ();
         private:
+            ClangASTType m_bool_type;
             ExecutionContextRef m_exe_ctx_ref;
             uint64_t m_count;
             lldb::addr_t m_base_data_address;
-            EvaluateExpressionOptions m_options;
+            std::map<size_t,lldb::ValueObjectSP> m_children;
         };
         
         SyntheticChildrenFrontEnd* LibcxxVectorBoolSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP);
diff --git a/include/lldb/DataFormatters/FormatManager.h b/include/lldb/DataFormatters/FormatManager.h
index 750e53008318f..24ec877ee5156 100644
--- a/include/lldb/DataFormatters/FormatManager.h
+++ b/include/lldb/DataFormatters/FormatManager.h
@@ -20,7 +20,7 @@
 
 #include "lldb/DataFormatters/FormatCache.h"
 #include "lldb/DataFormatters/FormatClasses.h"
-#include "lldb/DataFormatters/FormatNavigator.h"
+#include "lldb/DataFormatters/FormattersContainer.h"
 #include "lldb/DataFormatters/TypeCategory.h"
 #include "lldb/DataFormatters/TypeCategoryMap.h"
 
@@ -44,7 +44,7 @@ public:
     FormatManager ();
     
     NamedSummariesMap&
-    GetNamedSummaryNavigator ()
+    GetNamedSummaryContainer ()
     {
         return m_named_summaries_map;
     }
diff --git a/include/lldb/DataFormatters/FormatNavigator.h b/include/lldb/DataFormatters/FormattersContainer.h
index 1b82776fb28cb..de838d1ab9c1e 100644
--- a/include/lldb/DataFormatters/FormatNavigator.h
+++ b/include/lldb/DataFormatters/FormattersContainer.h
@@ -1,4 +1,4 @@
-//===-- FormatNavigator.h ----------------------------------------*- C++ -*-===//
+//===-- FormattersContainer.h ----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef lldb_FormatNavigator_h_
-#define lldb_FormatNavigator_h_
+#ifndef lldb_FormattersContainer_h_
+#define lldb_FormattersContainer_h_
 
 // C Includes
 // C++ Includes
@@ -104,7 +104,7 @@ GetValidTypeName_Impl (const ConstString& type)
 }
     
 template<typename KeyType, typename ValueType>
-class FormatNavigator;
+class FormattersContainer;
 
 template<typename KeyType, typename ValueType>
 class FormatMap
@@ -243,13 +243,13 @@ protected:
         return m_map_mutex;
     }
     
-    friend class FormatNavigator<KeyType, ValueType>;
+    friend class FormattersContainer<KeyType, ValueType>;
     friend class FormatManager;
     
 };
     
 template<typename KeyType, typename ValueType>
-class FormatNavigator
+class FormattersContainer
 {
 protected:
     typedef FormatMap<KeyType,ValueType> BackEndType;
@@ -260,11 +260,11 @@ public:
     typedef typename MapType::key_type MapKeyType;
     typedef typename MapType::mapped_type MapValueType;
     typedef typename BackEndType::CallbackType CallbackType;
-    typedef typename std::shared_ptr<FormatNavigator<KeyType, ValueType> > SharedPointer;
+    typedef typename std::shared_ptr<FormattersContainer<KeyType, ValueType> > SharedPointer;
     
     friend class TypeCategoryImpl;
 
-    FormatNavigator(std::string name,
+    FormattersContainer(std::string name,
                     IFormatChangeListener* lst) :
     m_format_map(lst),
     m_name(name),
@@ -350,7 +350,7 @@ protected:
     
     std::string m_name;
     
-    DISALLOW_COPY_AND_ASSIGN(FormatNavigator);
+    DISALLOW_COPY_AND_ASSIGN(FormattersContainer);
     
     ConstString m_id_cs;
                            
@@ -470,6 +470,7 @@ protected:
     {
         for (const FormattersMatchCandidate& candidate : candidates)
         {
+            // FIXME: could we do the IsMatch() check first?
             if (Get(candidate.GetTypeName(),entry))
             {
                 if (candidate.IsMatch(entry) == false)
@@ -491,4 +492,4 @@ protected:
 
 } // namespace lldb_private
 
-#endif	// lldb_FormatNavigator_h_
+#endif	// lldb_FormattersContainer_h_
diff --git a/include/lldb/DataFormatters/TypeCategory.h b/include/lldb/DataFormatters/TypeCategory.h
index 082395a046167..491fef29b5c55 100644
--- a/include/lldb/DataFormatters/TypeCategory.h
+++ b/include/lldb/DataFormatters/TypeCategory.h
@@ -19,108 +19,131 @@
 #include "lldb/lldb-enumerations.h"
 
 #include "lldb/DataFormatters/FormatClasses.h"
-#include "lldb/DataFormatters/FormatNavigator.h"
+#include "lldb/DataFormatters/FormattersContainer.h"
 
-namespace lldb_private {    
-    class TypeCategoryImpl
+namespace lldb_private {
+    
+    template <typename FormatterImpl>
+    class FormatterContainerPair
     {
-    private:
-        typedef FormatNavigator<ConstString, TypeFormatImpl> ValueNavigator;
-        typedef FormatNavigator<lldb::RegularExpressionSP, TypeFormatImpl> RegexValueNavigator;
+    public:
+        typedef FormattersContainer<ConstString, FormatterImpl> ExactMatchContainer;
+        typedef FormattersContainer<lldb::RegularExpressionSP, FormatterImpl> RegexMatchContainer;
         
-        typedef FormatNavigator<ConstString, TypeSummaryImpl> SummaryNavigator;
-        typedef FormatNavigator<lldb::RegularExpressionSP, TypeSummaryImpl> RegexSummaryNavigator;
+        typedef typename ExactMatchContainer::MapType ExactMatchMap;
+        typedef typename RegexMatchContainer::MapType RegexMatchMap;
+
+        typedef typename ExactMatchContainer::MapValueType MapValueType;
         
-        typedef FormatNavigator<ConstString, TypeFilterImpl> FilterNavigator;
-        typedef FormatNavigator<lldb::RegularExpressionSP, TypeFilterImpl> RegexFilterNavigator;
+        typedef typename ExactMatchContainer::SharedPointer ExactMatchContainerSP;
+        typedef typename RegexMatchContainer::SharedPointer RegexMatchContainerSP;
         
-#ifndef LLDB_DISABLE_PYTHON
-        typedef FormatNavigator<ConstString, ScriptedSyntheticChildren> SynthNavigator;
-        typedef FormatNavigator<lldb::RegularExpressionSP, ScriptedSyntheticChildren> RegexSynthNavigator;
-#endif // #ifndef LLDB_DISABLE_PYTHON
-
-        typedef ValueNavigator::MapType ValueMap;
-        typedef RegexValueNavigator::MapType RegexValueMap;
-
-        typedef SummaryNavigator::MapType SummaryMap;
-        typedef RegexSummaryNavigator::MapType RegexSummaryMap;
+        FormatterContainerPair (const char* exact_name,
+                                const char* regex_name,
+                                IFormatChangeListener* clist) :
+            m_exact_sp(new ExactMatchContainer(std::string(exact_name),clist)),
+            m_regex_sp(new RegexMatchContainer(std::string(regex_name),clist))
+        {
+        }
+        
+        ~FormatterContainerPair () = default;
+        
+        ExactMatchContainerSP
+        GetExactMatch () const
+        {
+            return m_exact_sp;
+        }
         
-        typedef FilterNavigator::MapType FilterMap;
-        typedef RegexFilterNavigator::MapType RegexFilterMap;
+        RegexMatchContainerSP
+        GetRegexMatch () const
+        {
+            return m_regex_sp;
+        }
+        
+    private:
+        ExactMatchContainerSP m_exact_sp;
+        RegexMatchContainerSP m_regex_sp;
+    };
 
+    class TypeCategoryImpl
+    {
+    private:
+        typedef FormatterContainerPair<TypeFormatImpl> FormatContainer;
+        typedef FormatterContainerPair<TypeSummaryImpl> SummaryContainer;
+        typedef FormatterContainerPair<TypeFilterImpl> FilterContainer;
+        
 #ifndef LLDB_DISABLE_PYTHON
-        typedef SynthNavigator::MapType SynthMap;
-        typedef RegexSynthNavigator::MapType RegexSynthMap;
+        typedef FormatterContainerPair<ScriptedSyntheticChildren> SynthContainer;
 #endif // #ifndef LLDB_DISABLE_PYTHON
-        
+
     public:
         
         typedef uint16_t FormatCategoryItems;
         static const uint16_t ALL_ITEM_TYPES = UINT16_MAX;
 
-        typedef ValueNavigator::SharedPointer ValueNavigatorSP;
-        typedef RegexValueNavigator::SharedPointer RegexValueNavigatorSP;
+        typedef FormatContainer::ExactMatchContainerSP FormatContainerSP;
+        typedef FormatContainer::RegexMatchContainerSP RegexFormatContainerSP;
         
-        typedef SummaryNavigator::SharedPointer SummaryNavigatorSP;
-        typedef RegexSummaryNavigator::SharedPointer RegexSummaryNavigatorSP;
+        typedef SummaryContainer::ExactMatchContainerSP SummaryContainerSP;
+        typedef SummaryContainer::RegexMatchContainerSP RegexSummaryContainerSP;
 
-        typedef FilterNavigator::SharedPointer FilterNavigatorSP;
-        typedef RegexFilterNavigator::SharedPointer RegexFilterNavigatorSP;
+        typedef FilterContainer::ExactMatchContainerSP FilterContainerSP;
+        typedef FilterContainer::RegexMatchContainerSP RegexFilterContainerSP;
 #ifndef LLDB_DISABLE_PYTHON
-        typedef SynthNavigator::SharedPointer SynthNavigatorSP;
-        typedef RegexSynthNavigator::SharedPointer RegexSynthNavigatorSP;
+        typedef SynthContainer::ExactMatchContainerSP SynthContainerSP;
+        typedef SynthContainer::RegexMatchContainerSP RegexSynthContainerSP;
 #endif // #ifndef LLDB_DISABLE_PYTHON
         
         TypeCategoryImpl (IFormatChangeListener* clist,
                           ConstString name);
         
-        ValueNavigatorSP
-        GetValueNavigator ()
+        FormatContainerSP
+        GetTypeFormatsContainer ()
         {
-            return ValueNavigatorSP(m_value_nav);
+            return m_format_cont.GetExactMatch();
         }
         
-        RegexValueNavigatorSP
-        GetRegexValueNavigator ()
+        RegexFormatContainerSP
+        GetRegexTypeFormatsContainer ()
         {
-            return RegexValueNavigatorSP(m_regex_value_nav);
+            return m_format_cont.GetRegexMatch();
         }
         
-        SummaryNavigatorSP
-        GetSummaryNavigator ()
+        SummaryContainerSP
+        GetTypeSummariesContainer ()
         {
-            return SummaryNavigatorSP(m_summary_nav);
+            return m_summary_cont.GetExactMatch();
         }
         
-        RegexSummaryNavigatorSP
-        GetRegexSummaryNavigator ()
+        RegexSummaryContainerSP
+        GetRegexTypeSummariesContainer ()
         {
-            return RegexSummaryNavigatorSP(m_regex_summary_nav);
+            return m_summary_cont.GetRegexMatch();
         }
         
-        FilterNavigatorSP
-        GetFilterNavigator ()
+        FilterContainerSP
+        GetTypeFiltersContainer ()
         {
-            return FilterNavigatorSP(m_filter_nav);
+            return m_filter_cont.GetExactMatch();
         }
         
-        RegexFilterNavigatorSP
-        GetRegexFilterNavigator ()
+        RegexFilterContainerSP
+        GetRegexTypeFiltersContainer ()
         {
-            return RegexFilterNavigatorSP(m_regex_filter_nav);
+            return m_filter_cont.GetRegexMatch();
         }
 
-        ValueNavigator::MapValueType
+        FormatContainer::MapValueType
         GetFormatForType (lldb::TypeNameSpecifierImplSP type_sp);
         
-        SummaryNavigator::MapValueType
+        SummaryContainer::MapValueType
         GetSummaryForType (lldb::TypeNameSpecifierImplSP type_sp);
         
-        FilterNavigator::MapValueType
+        FilterContainer::MapValueType
         GetFilterForType (lldb::TypeNameSpecifierImplSP type_sp);
         
 #ifndef LLDB_DISABLE_PYTHON
-        SynthNavigator::MapValueType
+        SynthContainer::MapValueType
         GetSyntheticForType (lldb::TypeNameSpecifierImplSP type_sp);
 #endif
         
@@ -130,32 +153,32 @@ namespace lldb_private {
         lldb::TypeNameSpecifierImplSP
         GetTypeNameSpecifierForSummaryAtIndex (size_t index);
 
-        ValueNavigator::MapValueType
+        FormatContainer::MapValueType
         GetFormatAtIndex (size_t index);
         
-        SummaryNavigator::MapValueType
+        SummaryContainer::MapValueType
         GetSummaryAtIndex (size_t index);
         
-        FilterNavigator::MapValueType
+        FilterContainer::MapValueType
         GetFilterAtIndex (size_t index);
         
         lldb::TypeNameSpecifierImplSP
         GetTypeNameSpecifierForFilterAtIndex (size_t index);
         
 #ifndef LLDB_DISABLE_PYTHON
-        SynthNavigatorSP
-        GetSyntheticNavigator ()
+        SynthContainerSP
+        GetTypeSyntheticsContainer ()
         {
-            return SynthNavigatorSP(m_synth_nav);
+            return m_synth_cont.GetExactMatch();
         }
         
-        RegexSynthNavigatorSP
-        GetRegexSyntheticNavigator ()
+        RegexSynthContainerSP
+        GetRegexTypeSyntheticsContainer ()
         {
-            return RegexSynthNavigatorSP(m_regex_synth_nav);
+            return m_synth_cont.GetRegexMatch();
         }
         
-        SynthNavigator::MapValueType
+        SynthContainer::MapValueType
         GetSyntheticAtIndex (size_t index);
         
         lldb::TypeNameSpecifierImplSP
@@ -222,18 +245,14 @@ namespace lldb_private {
         typedef std::shared_ptr<TypeCategoryImpl> SharedPointer;
         
     private:
-        ValueNavigator::SharedPointer m_value_nav;
-        RegexValueNavigator::SharedPointer m_regex_value_nav;
+        FormatContainer m_format_cont;
         
-        SummaryNavigator::SharedPointer m_summary_nav;
-        RegexSummaryNavigator::SharedPointer m_regex_summary_nav;
+        SummaryContainer m_summary_cont;
 
-        FilterNavigator::SharedPointer m_filter_nav;
-        RegexFilterNavigator::SharedPointer m_regex_filter_nav;
+        FilterContainer m_filter_cont;
 
 #ifndef LLDB_DISABLE_PYTHON
-        SynthNavigator::SharedPointer m_synth_nav;
-        RegexSynthNavigator::SharedPointer m_regex_synth_nav;
+        SynthContainer m_synth_cont;
 #endif // #ifndef LLDB_DISABLE_PYTHON
         
         bool m_enabled;
@@ -257,18 +276,18 @@ namespace lldb_private {
         
         friend class TypeCategoryMap;
         
-        friend class FormatNavigator<ConstString, TypeFormatImpl>;
-        friend class FormatNavigator<lldb::RegularExpressionSP, TypeFormatImpl>;
+        friend class FormattersContainer<ConstString, TypeFormatImpl>;
+        friend class FormattersContainer<lldb::RegularExpressionSP, TypeFormatImpl>;
         
-        friend class FormatNavigator<ConstString, TypeSummaryImpl>;
-        friend class FormatNavigator<lldb::RegularExpressionSP, TypeSummaryImpl>;
+        friend class FormattersContainer<ConstString, TypeSummaryImpl>;
+        friend class FormattersContainer<lldb::RegularExpressionSP, TypeSummaryImpl>;
         
-        friend class FormatNavigator<ConstString, TypeFilterImpl>;
-        friend class FormatNavigator<lldb::RegularExpressionSP, TypeFilterImpl>;
+        friend class FormattersContainer<ConstString, TypeFilterImpl>;
+        friend class FormattersContainer<lldb::RegularExpressionSP, TypeFilterImpl>;
         
 #ifndef LLDB_DISABLE_PYTHON
-        friend class FormatNavigator<ConstString, ScriptedSyntheticChildren>;
-        friend class FormatNavigator<lldb::RegularExpressionSP, ScriptedSyntheticChildren>;
+        friend class FormattersContainer<ConstString, ScriptedSyntheticChildren>;
+        friend class FormattersContainer<lldb::RegularExpressionSP, ScriptedSyntheticChildren>;
 #endif // #ifndef LLDB_DISABLE_PYTHON
     };
     
diff --git a/include/lldb/DataFormatters/TypeCategoryMap.h b/include/lldb/DataFormatters/TypeCategoryMap.h
index 6bed187198939..88aaeb23bfd8f 100644
--- a/include/lldb/DataFormatters/TypeCategoryMap.h
+++ b/include/lldb/DataFormatters/TypeCategoryMap.h
@@ -18,7 +18,7 @@
 #include "lldb/lldb-public.h"
 #include "lldb/lldb-enumerations.h"
 
-#include "lldb/DataFormatters/FormatNavigator.h"
+#include "lldb/DataFormatters/FormattersContainer.h"
 #include "lldb/DataFormatters/TypeCategory.h"
 
 namespace lldb_private {
@@ -144,7 +144,7 @@ namespace lldb_private {
             return m_map_mutex;
         }
         
-        friend class FormatNavigator<KeyType, ValueType>;
+        friend class FormattersContainer<KeyType, ValueType>;
         friend class FormatManager;
     };
 } // namespace lldb_private
diff --git a/include/lldb/DataFormatters/TypeFormat.h b/include/lldb/DataFormatters/TypeFormat.h
index 77135c448ed14..20fa8f2d4e7f8 100644
--- a/include/lldb/DataFormatters/TypeFormat.h
+++ b/include/lldb/DataFormatters/TypeFormat.h
@@ -130,15 +130,12 @@ namespace lldb_private {
             uint32_t m_flags;
         };
         
-        TypeFormatImpl (lldb::Format f = lldb::eFormatInvalid,
-                        const Flags& flags = Flags());
+        TypeFormatImpl (const Flags& flags = Flags());
         
         typedef std::shared_ptr<TypeFormatImpl> SharedPointer;
         typedef bool(*ValueCallback)(void*, ConstString, const lldb::TypeFormatImplSP&);
         
-        ~TypeFormatImpl ()
-        {
-        }
+        virtual ~TypeFormatImpl () = default;
         
         bool
         Cascades () const
@@ -173,6 +170,66 @@ namespace lldb_private {
         {
             m_flags.SetSkipReferences(value);
         }
+
+        uint32_t
+        GetOptions ()
+        {
+            return m_flags.GetValue();
+        }
+        
+        void
+        SetOptions (uint32_t value)
+        {
+            m_flags.SetValue(value);
+        }
+        
+        uint32_t&
+        GetRevision ()
+        {
+            return m_my_revision;
+        }
+        
+        enum class Type
+        {
+            eTypeUnknown,
+            eTypeFormat,
+            eTypeEnum
+        };
+        
+        virtual Type
+        GetType ()
+        {
+            return Type::eTypeUnknown;
+        }
+        
+        // we are using a ValueObject* instead of a ValueObjectSP because we do not need to hold on to this for
+        // extended periods of time and we trust the ValueObject to stay around for as long as it is required
+        // for us to generate its value
+        virtual bool
+        FormatObject (ValueObject *valobj,
+                      std::string& dest) const = 0;
+        
+        virtual std::string
+        GetDescription() = 0;
+        
+    protected:
+        Flags m_flags;
+        uint32_t m_my_revision;
+        
+    private:
+        DISALLOW_COPY_AND_ASSIGN(TypeFormatImpl);
+    };
+    
+    class TypeFormatImpl_Format : public TypeFormatImpl
+    {
+    public:
+        TypeFormatImpl_Format (lldb::Format f = lldb::eFormatInvalid,
+                               const TypeFormatImpl::Flags& flags = Flags());
+        
+        typedef std::shared_ptr<TypeFormatImpl_Format> SharedPointer;
+        typedef bool(*ValueCallback)(void*, ConstString, const TypeFormatImpl_Format::SharedPointer&);
+        
+        virtual ~TypeFormatImpl_Format () = default;
         
         lldb::Format
         GetFormat () const
@@ -186,35 +243,69 @@ namespace lldb_private {
             m_format = fmt;
         }
         
-        uint32_t
-        GetOptions ()
+        virtual TypeFormatImpl::Type
+        GetType ()
         {
-            return m_flags.GetValue();
+            return TypeFormatImpl::Type::eTypeFormat;
+        }
+        
+        virtual bool
+        FormatObject (ValueObject *valobj,
+                      std::string& dest) const;
+        
+        virtual std::string
+        GetDescription();
+        
+    protected:
+        lldb::Format m_format;
+        
+    private:
+        DISALLOW_COPY_AND_ASSIGN(TypeFormatImpl_Format);
+    };
+    
+    class TypeFormatImpl_EnumType : public TypeFormatImpl
+    {
+    public:
+        TypeFormatImpl_EnumType (ConstString type_name = ConstString(""),
+                                 const TypeFormatImpl::Flags& flags = Flags());
+        
+        typedef std::shared_ptr<TypeFormatImpl_EnumType> SharedPointer;
+        typedef bool(*ValueCallback)(void*, ConstString, const TypeFormatImpl_EnumType::SharedPointer&);
+        
+        ~TypeFormatImpl_EnumType () = default;
+        
+        ConstString
+        GetTypeName ()
+        {
+            return m_enum_type;
         }
         
         void
-        SetOptions (uint32_t value)
+        SetTypeName (ConstString enum_type)
         {
-            m_flags.SetValue(value);
+            m_enum_type = enum_type;
         }
         
-        uint32_t&
-        GetRevision ()
+        virtual TypeFormatImpl::Type
+        GetType ()
         {
-            return m_my_revision;
+            return TypeFormatImpl::Type::eTypeEnum;
         }
         
-        std::string
+        virtual bool
+        FormatObject (ValueObject *valobj,
+                      std::string& dest) const;
+        
+        virtual std::string
         GetDescription();
         
     protected:
-        Flags m_flags;
-        lldb::Format m_format;
-        uint32_t m_my_revision;
+        ConstString m_enum_type;
+        mutable std::map<void*,ClangASTType> m_types;
         
     private:
-        DISALLOW_COPY_AND_ASSIGN(TypeFormatImpl);
-    };    
+        DISALLOW_COPY_AND_ASSIGN(TypeFormatImpl_EnumType);
+    };
 } // namespace lldb_private
 
 #endif	// lldb_TypeFormat_h_
diff --git a/include/lldb/DataFormatters/TypeSynthetic.h b/include/lldb/DataFormatters/TypeSynthetic.h
index 18b9d011e96ab..a25f11d64392b 100644
--- a/include/lldb/DataFormatters/TypeSynthetic.h
+++ b/include/lldb/DataFormatters/TypeSynthetic.h
@@ -32,10 +32,24 @@ namespace lldb_private {
     {
     protected:
         ValueObject &m_backend;
+        
+        void
+        SetValid (bool valid)
+        {
+            m_valid = valid;
+        }
+        
+        bool
+        IsValid ()
+        {
+            return m_valid;
+        }
+        
     public:
         
         SyntheticChildrenFrontEnd (ValueObject &backend) :
-        m_backend(backend)
+        m_backend(backend),
+        m_valid(true)
         {}
         
         virtual
@@ -71,6 +85,7 @@ namespace lldb_private {
         typedef std::unique_ptr<SyntheticChildrenFrontEnd> AutoPointer;
         
     private:
+        bool m_valid;
         DISALLOW_COPY_AND_ASSIGN(SyntheticChildrenFrontEnd);
     };
     
diff --git a/include/lldb/DataFormatters/ValueObjectPrinter.h b/include/lldb/DataFormatters/ValueObjectPrinter.h
index 4e23ceedcc168..375bb50c876d8 100644
--- a/include/lldb/DataFormatters/ValueObjectPrinter.h
+++ b/include/lldb/DataFormatters/ValueObjectPrinter.h
@@ -265,9 +265,6 @@ public:
     bool
     PrintValueObject ();
     
-    bool
-    PrintChildrenOneLiner (bool hide_names);
-    
 protected:
     
     // only this class (and subclasses, if any) should ever be concerned with
@@ -366,6 +363,9 @@ protected:
     PrintChildrenIfNeeded (bool value_printed,
                            bool summary_printed);
     
+    bool
+    PrintChildrenOneLiner (bool hide_names);
+    
 private:
     
     ValueObject *m_orig_valobj;
@@ -386,6 +386,8 @@ private:
     std::string m_summary;
     std::string m_error;
     
+    friend class StringSummaryFormat;
+    
     DISALLOW_COPY_AND_ASSIGN(ValueObjectPrinter);
 };