[lldb][Formatter] Consolidate libstdc++ and libc++ unique_ptr formatter tests into generic test (llvm#147031)

The libc++ test was a subset of the tests in libstdc++. This test moves
the libc++ test into `generic` and somne additional test-cases from
`libstdc++` (specifically the recursive unique_ptr case). It turns out
the libstdc++ formatter supports dereferencing using the "object" or
"obj" names. We could either drop those from the tests or support the
same for libc++. I took the latter approach but don't have strong
opinions on this.

Split out from llvm#146740

(cherry picked from commit 074ccde)

Author: Michael137

lldb/source/Plugins/Language/CPlusPlus/LibCxx.cpp

@@ -417,7 +417,7 @@ size_t lldb_private::formatters::LibcxxUniquePtrSyntheticFrontEnd::
     return 0;
   if (name == "deleter")
     return 1;
-  if (name == "$$dereference$$")
+  if (name == "obj" || name == "object" || name == "$$dereference$$")
     return 2;
   return UINT32_MAX;
 }

lldb/source/Plugins/Language/CPlusPlus/LibStdcppUniquePointer.cpp

@@ -44,8 +44,7 @@ class LibStdcppUniquePtrSyntheticFrontEnd : public SyntheticChildrenFrontEnd {
   // objects are only destroyed when every shared pointer to any of them
   // is destroyed, so we must not store a shared pointer to any ValueObject
   // derived from our backend ValueObject (since we're in the same cluster).
-  ValueObject* m_ptr_obj = nullptr;
-  ValueObject* m_obj_obj = nullptr;
+  ValueObject *m_ptr_obj = nullptr;
   ValueObject* m_del_obj = nullptr;
 
   ValueObjectSP GetTuple();
@@ -109,7 +108,6 @@ lldb::ChildCacheState LibStdcppUniquePtrSyntheticFrontEnd::Update() {
     if (del_obj)
       m_del_obj = del_obj->Clone(ConstString("deleter")).get();
   }
-  m_obj_obj = nullptr;
 
   return lldb::ChildCacheState::eRefetch;
 }
@@ -123,15 +121,13 @@ LibStdcppUniquePtrSyntheticFrontEnd::GetChildAtIndex(uint32_t idx) {
   if (idx == 1 && m_del_obj)
     return m_del_obj->GetSP();
   if (idx == 2) {
-    if (m_ptr_obj && !m_obj_obj) {
-      Status error;
-      ValueObjectSP obj_obj = m_ptr_obj->Dereference(error);
-      if (error.Success()) {
-        m_obj_obj = obj_obj->Clone(ConstString("object")).get();
+    if (m_ptr_obj) {
+      Status status;
+      auto value_sp = m_ptr_obj->Dereference(status);
+      if (status.Success()) {
+        return value_sp;
       }
     }
-    if (m_obj_obj)
-      return m_obj_obj->GetSP();
   }
   return lldb::ValueObjectSP();
 }

lldb/test/API/functionalities/data-formatter/data-formatter-stl/libstdcpp/unique_ptr/Makefile renamed to lldb/test/API/functionalities/data-formatter/data-formatter-stl/generic/unique_ptr/Makefile

@@ -1,5 +1,4 @@
 CXX_SOURCES := main.cpp
-
-USE_LIBSTDCPP := 1
+CXXFLAGS_EXTRAS := -std=c++14
 
 include Makefile.rules

lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/unique_ptr/TestDataFormatterLibcxxUniquePtr.py renamed to lldb/test/API/functionalities/data-formatter/data-formatter-stl/generic/unique_ptr/TestDataFormatterStdUniquePtr.py

@@ -1,49 +1,23 @@
 """
-Test lldb data formatter for libc++ std::unique_ptr.
+Test lldb data formatter for std::unique_ptr.
 """
 
-
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class TestCase(TestBase):
-    def make_expected_type(self, pointee_type: str, qualifiers: str = "") -> str:
-        if qualifiers:
-            qualifiers = " " + qualifiers
-
-        if self.expectedCompiler(["clang"]) and self.expectedCompilerVersion(
-            [">", "16.0"]
-        ):
-            return f"std::unique_ptr<{pointee_type}>{qualifiers}"
-        else:
-            return f"std::unique_ptr<{pointee_type}, std::default_delete<{pointee_type}> >{qualifiers}"
-
-    def make_expected_basic_string_ptr(self) -> str:
-        if self.expectedCompiler(["clang"]) and self.expectedCompilerVersion(
-            [">", "16.0"]
-        ):
-            return f"std::unique_ptr<std::string>"
-        else:
-            return (
-                "std::unique_ptr<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, "
-                "std::default_delete<std::basic_string<char, std::char_traits<char>, std::allocator<char> > > >"
-            )
-
-    @add_test_categories(["libc++"])
-    def test_unique_ptr_variables(self):
+    def do_test(self):
         """Test `frame variable` output for `std::unique_ptr` types."""
-        self.build()
 
         lldbutil.run_to_source_breakpoint(
             self, "// break here", lldb.SBFileSpec("main.cpp")
         )
 
         valobj = self.expect_var_path(
             "up_empty",
-            type=self.make_expected_type("int"),
             summary="nullptr",
             children=[ValueCheck(name="pointer")],
         )
@@ -57,36 +31,32 @@ def test_unique_ptr_variables(self):
 
         valobj = self.expect_var_path(
             "up_int",
-            type=self.make_expected_type("int"),
             summary="10",
             children=[ValueCheck(name="pointer")],
         )
         self.assertNotEqual(valobj.child[0].unsigned, 0)
 
         valobj = self.expect_var_path(
             "up_int_ref",
-            type=self.make_expected_type("int", qualifiers="&"),
             summary="10",
             children=[ValueCheck(name="pointer")],
         )
         self.assertNotEqual(valobj.child[0].unsigned, 0)
 
         valobj = self.expect_var_path(
             "up_int_ref_ref",
-            type=self.make_expected_type("int", qualifiers="&&"),
             summary="10",
             children=[ValueCheck(name="pointer")],
         )
         self.assertNotEqual(valobj.child[0].unsigned, 0)
 
         valobj = self.expect_var_path(
             "up_str",
-            type=self.make_expected_basic_string_ptr(),
             summary='"hello"',
             children=[ValueCheck(name="pointer", summary='"hello"')],
         )
 
-        valobj = self.expect_var_path("up_user", type=self.make_expected_type("User"))
+        valobj = self.expect_var_path("up_user")
         self.assertRegex(valobj.summary, "^User @ 0x0*[1-9a-f][0-9a-f]+$")
         self.assertNotEqual(valobj.child[0].unsigned, 0)
 
@@ -115,3 +85,67 @@ def test_unique_ptr_variables(self):
 
         self.expect_var_path("up_user->id", type="int", value="30")
         self.expect_var_path("up_user->name", type="std::string", summary='"steph"')
+
+    @add_test_categories(["libstdcxx"])
+    def test_libstdcxx(self):
+        self.build(dictionary={"USE_LIBSTDCPP": 1})
+        self.do_test()
+
+    @add_test_categories(["libc++"])
+    def test_libcxx(self):
+        self.build(dictionary={"USE_LIBCPP": 1})
+        self.do_test()
+
+    def do_test_recursive_unique_ptr(self):
+        # Tests that LLDB can handle when we have a loop in the unique_ptr
+        # reference chain and that it correctly handles the different options
+        # for the frame variable command in this case.
+        self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
+
+        lldbutil.run_break_set_by_source_regexp(self, "Set break point at this line.")
+        self.runCmd("run", RUN_SUCCEEDED)
+        self.expect(
+            "thread list",
+            STOPPED_DUE_TO_BREAKPOINT,
+            substrs=["stopped", "stop reason = breakpoint"],
+        )
+
+        self.expect("frame variable f1->next", substrs=["next = NodeU @"])
+        self.expect(
+            "frame variable --ptr-depth=1 f1->next",
+            substrs=["next = NodeU @", "value = 2"],
+        )
+        self.expect(
+            "frame variable --ptr-depth=2 f1->next",
+            substrs=["next = NodeU @", "value = 1", "value = 2"],
+        )
+
+        frame = self.frame()
+        self.assertTrue(frame.IsValid())
+        self.assertEqual(
+            2,
+            frame.GetValueForVariablePath("f1->next.object.value").GetValueAsUnsigned(),
+        )
+        self.assertEqual(
+            2, frame.GetValueForVariablePath("f1->next->value").GetValueAsUnsigned()
+        )
+        self.assertEqual(
+            1,
+            frame.GetValueForVariablePath(
+                "f1->next.object.next.obj.value"
+            ).GetValueAsUnsigned(),
+        )
+        self.assertEqual(
+            1,
+            frame.GetValueForVariablePath("f1->next->next->value").GetValueAsUnsigned(),
+        )
+
+    @add_test_categories(["libstdcxx"])
+    def test_recursive_unique_ptr_libstdcxx(self):
+        self.build(dictionary={"USE_LIBSTDCPP": 1})
+        self.do_test_recursive_unique_ptr()
+
+    @add_test_categories(["libc++"])
+    def test_recursive_unique_ptr_libcxx(self):
+        self.build(dictionary={"USE_LIBCPP": 1})
+        self.do_test_recursive_unique_ptr()

lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/unique_ptr/main.cpp renamed to lldb/test/API/functionalities/data-formatter/data-formatter-stl/generic/unique_ptr/main.cpp

@@ -6,15 +6,29 @@ struct User {
   std::string name = "steph";
 };
 
+struct NodeU {
+  std::unique_ptr<NodeU> next;
+  int value;
+};
+
 // libc++ stores unique_ptr data in a compressed pair, which has a specialized
 // representation when the type of the second element is an empty class. So
 // we need a deleter class with a dummy data member to trigger the other path.
 struct NonEmptyIntDeleter {
-  void operator()(int* ptr) { delete ptr; }
+  void operator()(int *ptr) { delete ptr; }
 
   int dummy_ = 9999;
 };
 
+static void recursive() {
+  // Set up a structure where we have a loop in the unique_ptr chain.
+  NodeU *f1 = new NodeU{nullptr, 1};
+  NodeU *f2 = new NodeU{nullptr, 2};
+  f1->next.reset(f2);
+  f2->next.reset(f1);
+  std::puts("Set break point at this line.");
+}
+
 int main() {
   std::unique_ptr<int> up_empty;
   std::unique_ptr<int> up_int = std::make_unique<int>(10);
@@ -24,6 +38,13 @@ int main() {
   std::unique_ptr<User> up_user = std::make_unique<User>();
   auto up_non_empty_deleter =
       std::unique_ptr<int, NonEmptyIntDeleter>(new int(1234));
+  std::unique_ptr<NodeU> ptr_node =
+      std::unique_ptr<NodeU>(new NodeU{nullptr, 2});
+  ptr_node = std::unique_ptr<NodeU>(new NodeU{std::move(ptr_node), 1});
+
+  std::puts("// break here");
+
+  recursive();
 
-  return 0; // break here
+  return 0;
 }