Add data formatter for libc++ std::tuple

[jingham]

It seems awkward to me to be returning empty ValueObjectSP's by returning nullptr and then relying on conversion. We don't do it that way in most of the other formatters. If there wasn't a strong reason for doing it this way I think it would be clearer to return the object you're supposed to return.

Other than that this looks fine.

source/Plugins/Language/CPlusPlus/LibCxxTuple.cpp

47 ↗

(On Diff #107282)

nullptr -> ValueObjectSP. It makes it clearer reading the thing what it is.

53 ↗

(On Diff #107282)

It looks a little weird to return nullptr for a function returning a ValueObjectSP. It would be clearer to return ValueObjectSP(), and that's what we do pretty much everywhere else.

55 ↗

(On Diff #107282)

ditto

[labath]

There wasn't a strong reason for using nullptr, I can convert those to ValueObjectSP().

Given that this was your only objection to this patch, I'm going to assume it is ok to land after this.

[labath]

s/nullptr/ValueObjectSP()

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/tuple/Makefile

+LEVEL = ../../../../../make
+
+CXX_SOURCES := main.cpp
+
+USE_LIBCPP := 1
+include $(LEVEL)/Makefile.rules

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/tuple/TestDataFormatterLibcxxTuple.py

+"""
+Test lldb data formatter subsystem.
+"""
+
+from __future__ import print_function
+
+
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+
+class TestDataFormatterLibcxxTuple(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    def setUp(self):
+        TestBase.setUp(self)
+        self.line = line_number('main.cpp', '// break here')
+        ns = 'ndk' if lldbplatformutil.target_is_android() else ''
+        self.namespace = 'std::__' + ns + '1'
+
+    @add_test_categories(["libc++"])
+    def test(self):
+        """Test that std::tuple is displayed correctly"""
+        self.build()
+        lldbutil.run_to_source_breakpoint(self, '// break here',
+                lldb.SBFileSpec("main.cpp", False))
+
+        tuple_name = self.namespace + '::tuple'
+        self.expect("frame variable empty",
+                    substrs=[tuple_name,
+                             'size=0',
+                             '{}'])
+
+        self.expect("frame variable one_elt",
+                    substrs=[tuple_name,
+                             'size=1',
+                             '{',
+                             '[0] = 47',
+                             '}'])
+
+        self.expect("frame variable three_elts",
+                    substrs=[tuple_name,
+                             'size=3',
+                             '{',
+                             '[0] = 1',
+                             '[1] = 47',
+                             '[2] = "foo"',
+                             '}'])

lldb/trunk/packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/tuple/main.cpp

+#include <tuple>
+#include <string>
+
+using namespace std;
+
+int main() {
+  tuple<> empty;
+  tuple<int> one_elt{47};
+  tuple<int, long, string> three_elts{1, 47l, "foo"};
+  return 0; // break here
+}

lldb/trunk/source/Plugins/Language/CPlusPlus/CMakeLists.txt

 add_lldb_library(lldbPluginCPlusPlusLanguage PLUGIN
   BlockPointer.cpp
   CPlusPlusLanguage.cpp
   CPlusPlusNameParser.cpp
   CxxStringTypes.cpp
   LibCxx.cpp
   LibCxxAtomic.cpp
   LibCxxInitializerList.cpp
   LibCxxList.cpp
   LibCxxMap.cpp
+  LibCxxTuple.cpp
   LibCxxUnorderedMap.cpp
   LibCxxVector.cpp
   LibStdcpp.cpp
   LibStdcppTuple.cpp
   LibStdcppUniquePointer.cpp
 
   LINK_LIBS
     lldbCore
     lldbDataFormatters
     lldbHost
     lldbSymbol
     lldbTarget
     lldbUtility
   LINK_COMPONENTS
     Support
 )

lldb/trunk/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp

AddCXXSynthetic(
       ConstString("^(std::__(ndk)?1::)unordered_(multi)?(map|set)<.+> >$"),
       stl_synth_flags, true);
   AddCXXSynthetic(
       cpp_category_sp,
       lldb_private::formatters::LibcxxInitializerListSyntheticFrontEndCreator,
       "libc++ std::initializer_list synthetic children",
       ConstString("^std::initializer_list<.+>(( )?&)?$"), stl_synth_flags,
       true);
+  AddCXXSynthetic(cpp_category_sp, LibcxxTupleFrontEndCreator,
+                  "libc++ std::tuple synthetic children",
+                  ConstString("^std::__(ndk)?1::tuple<.*>(( )?&)?$"), stl_synth_flags,
+                  true);
   AddCXXSynthetic(
       cpp_category_sp,
       lldb_private::formatters::LibcxxAtomicSyntheticFrontEndCreator,
       "libc++ std::atomic synthetic children",
       ConstString("^std::__(ndk)?1::atomic<.+>$"), stl_synth_flags, true);
 
   cpp_category_sp->GetRegexTypeSyntheticsContainer()->Add(
       RegularExpressionSP(new RegularExpression(
AddCXXSummary(cpp_category_sp,
                 "libc++ std::multimap summary provider",
                 ConstString("^std::__(ndk)?1::multimap<.+>(( )?&)?$"),
                 stl_summary_flags, true);
   AddCXXSummary(
       cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider,
       "libc++ std::unordered containers summary provider",
       ConstString("^(std::__(ndk)?1::)unordered_(multi)?(map|set)<.+> >$"),
       stl_summary_flags, true);
+  AddCXXSummary(cpp_category_sp, LibcxxContainerSummaryProvider,
+                "libc++ std::tuple summary provider",
+                ConstString("^std::__(ndk)?1::tuple<.*>(( )?&)?$"), stl_summary_flags,
+                true);
   AddCXXSummary(
       cpp_category_sp, lldb_private::formatters::LibCxxAtomicSummaryProvider,
       "libc++ std::atomic summary provider",
       ConstString("^std::__(ndk)?1::atomic<.+>$"), stl_summary_flags, true);
 
   stl_summary_flags.SetSkipPointers(true);
 
   AddCXXSummary(cpp_category_sp,

lldb/trunk/source/Plugins/Language/CPlusPlus/LibCxx.h

 
 SyntheticChildrenFrontEnd *
 LibcxxInitializerListSyntheticFrontEndCreator(CXXSyntheticChildren *,
                                               lldb::ValueObjectSP);
 
 SyntheticChildrenFrontEnd *LibcxxFunctionFrontEndCreator(CXXSyntheticChildren *,
                                                          lldb::ValueObjectSP);
 
+SyntheticChildrenFrontEnd *LibcxxTupleFrontEndCreator(CXXSyntheticChildren *,
+                                                      lldb::ValueObjectSP);
+
 } // namespace formatters
 } // namespace lldb_private
 
 #endif // liblldb_LibCxx_h_

lldb/trunk/source/Plugins/Language/CPlusPlus/LibCxxTuple.cpp

+//===-- LibCxxTuple.cpp -----------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "LibCxx.h"
+#include "lldb/DataFormatters/FormattersHelpers.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+namespace {
+
+class TupleFrontEnd: public SyntheticChildrenFrontEnd {
+public:
+  TupleFrontEnd(ValueObject &valobj) : SyntheticChildrenFrontEnd(valobj) {
+    Update();
+  }
+
+  size_t GetIndexOfChildWithName(const ConstString &name) override {
+    return formatters::ExtractIndexFromString(name.GetCString());
+  }
+
+  bool MightHaveChildren() override { return true; }
+  bool Update() override;
+  size_t CalculateNumChildren() override { return m_elements.size(); }
+  ValueObjectSP GetChildAtIndex(size_t idx) override;
+
+private:
+  std::vector<ValueObjectSP> m_elements;
+  ValueObjectSP m_base_sp;
+};
+}
+
+bool TupleFrontEnd::Update() {
+  m_elements.clear();
+  m_base_sp = m_backend.GetChildMemberWithName(ConstString("base_"), true);
+  if (! m_base_sp)
+    return false;
+  m_elements.assign(m_base_sp->GetCompilerType().GetNumDirectBaseClasses(),
+                    ValueObjectSP());
+  return false;
+}
+
+ValueObjectSP TupleFrontEnd::GetChildAtIndex(size_t idx) {
+  if (idx >= m_elements.size())
+    return ValueObjectSP();
+  if (!m_base_sp)
+    return ValueObjectSP();
+  if (m_elements[idx])
+    return m_elements[idx];
+
+  CompilerType holder_type =
+      m_base_sp->GetCompilerType().GetDirectBaseClassAtIndex(idx, nullptr);
+  if (!holder_type)
+    return ValueObjectSP();
+  ValueObjectSP holder_sp = m_base_sp->GetChildAtIndex(idx, true);
+  if (!holder_sp)
+    return ValueObjectSP();
+
+  ValueObjectSP elem_sp = holder_sp->GetChildAtIndex(0, true);
+  if (elem_sp)
+    m_elements[idx] =
+        elem_sp->Clone(ConstString(llvm::formatv("[{0}]", idx).str()));
+
+  return m_elements[idx];
+}
+
+SyntheticChildrenFrontEnd *
+formatters::LibcxxTupleFrontEndCreator(CXXSyntheticChildren *,
+                                       lldb::ValueObjectSP valobj_sp) {
+  if (valobj_sp)
+    return new TupleFrontEnd(*valobj_sp);
+  return nullptr;
+}