[lldb][DataFormatter] Add std::ranges::ref_view formatter

[Michael137]

Summary

This patch adds a formatter for std::ranges::ref_view<T>.
It simply holds a T*, so all this formatter does is dereference
this pointer and format it as T would be.

Testing

• Added API tests

[Michael137]

• Use typedef in test

[Michael137]

• Clean up test

[aprantl]

Small nitpicks, otherwise good!

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

42

Personally I prefer

///Pointer to the dereferenced __range_ member.
lldb::ValueObjectSP m_range_sp = nullptr;

for longer comments.

56

I wonder if it would be more readable to move those one-line function definitions into the declaration?

[Michael137]

• Move short definitions inline
• Fix doxygen comment

[Michael137]

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

42

Done

56

Looks better, done

[aprantl]

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

37

To be very nitpicking: LLVM style wants full sentences in comments, so let's add a . at the end. :-)

[labath]

You may want to check that this kind of automatic dereferencing does not send lldb into a tailspin if the printed data structure is recursive. I know we had problems like that with smart pointer pretty printers.

I'd try some code like:

#include <ranges>
#include <vector>

struct A {
  std::ranges::ref_view<std::vector<A>> a;
};

int main() {
    std::vector<A> v;
    v.push_back(A{v});
    v[0].a = v;
    // print v ?
}

[Michael137]

In D138558#3963732, @labath wrote:

You may want to check that this kind of automatic dereferencing does not send lldb into a tailspin if the printed data structure is recursive. I know we had problems like that with smart pointer pretty printers.

I'd try some code like:

#include <ranges>
#include <vector>

struct A {
  std::ranges::ref_view<std::vector<A>> a;
};

int main() {
    std::vector<A> v;
    v.push_back(A{v});
    v[0].a = v;
    // print v ?
}

@labath good point

E.g., the following would cause such unbounded recursion (didn't find a good way of triggering it using the actual ref_view since it's not default constructible, but it's probably doable):

#include <vector>

namespace std {
inline namespace __1 {
namespace ranges {
template<typename T>
struct ref_view {
    T* __range_;
};
}
}
}

struct Foo {
    std::ranges::ref_view<std::vector<Foo>> a;
};

int main() {
    Foo f;
    std::vector<Foo> v;
    v.push_back(f);

    std::ranges::ref_view<std::vector<Foo>> r{.__range_ = &v};
    f.a = r;

    return 0;
}

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

 add_lldb_library(lldbPluginCPlusPlusLanguage PLUGIN
   BlockPointer.cpp
   Coroutines.cpp
   CPlusPlusLanguage.cpp
   CPlusPlusNameParser.cpp
   CxxStringTypes.cpp
   GenericBitset.cpp
   GenericOptional.cpp
   LibCxx.cpp
   LibCxxAtomic.cpp
   LibCxxInitializerList.cpp
   LibCxxList.cpp
   LibCxxMap.cpp
   LibCxxQueue.cpp
+  LibCxxRangesRefView.cpp
   LibCxxSpan.cpp
   LibCxxTuple.cpp
   LibCxxUnorderedMap.cpp
   LibCxxVariant.cpp
   LibCxxVector.cpp
   LibStdcpp.cpp
   LibStdcppTuple.cpp
   LibStdcppUniquePointer.cpp

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

AddCXXSynthetic(
       "libc++ std::atomic synthetic children",
       ConstString("^std::__[[:alnum:]]+::atomic<.+>$"), stl_synth_flags, true);
   AddCXXSynthetic(
       cpp_category_sp,
       lldb_private::formatters::LibcxxStdSpanSyntheticFrontEndCreator,
       "libc++ std::span synthetic children",
       ConstString("^std::__[[:alnum:]]+::span<.+>(( )?&)?$"), stl_deref_flags,
       true);
+  AddCXXSynthetic(
+      cpp_category_sp,
+      lldb_private::formatters::LibcxxStdRangesRefViewSyntheticFrontEndCreator,
+      "libc++ std::ranges::ref_view synthetic children",
+      ConstString("^std::__[[:alnum:]]+::ranges::ref_view<.+>(( )?&)?$"),
+      stl_deref_flags, true);
 
   cpp_category_sp->AddTypeSynthetic(
       "^(std::__[[:alnum:]]+::)deque<.+>(( )?&)?$", eFormatterMatchRegex,
       SyntheticChildrenSP(new ScriptedSyntheticChildren(
           stl_synth_flags,
           "lldb.formatters.cpp.libcxx.stddeque_SynthProvider")));
 
   AddCXXSynthetic(

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

 SyntheticChildrenFrontEnd *
 LibcxxVariantFrontEndCreator(CXXSyntheticChildren *,
                              lldb::ValueObjectSP valobj_sp);
 
 SyntheticChildrenFrontEnd *
 LibcxxStdSpanSyntheticFrontEndCreator(CXXSyntheticChildren *,
                                       lldb::ValueObjectSP);
 
+SyntheticChildrenFrontEnd *
+LibcxxStdRangesRefViewSyntheticFrontEndCreator(CXXSyntheticChildren *,
+                                               lldb::ValueObjectSP);
+
 } // namespace formatters
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_LANGUAGE_CPLUSPLUS_LIBCXX_H

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

+//===-- LibCxxRangesRefView.cpp -------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "LibCxx.h"
+
+#include "lldb/Core/ValueObject.h"
+#include "lldb/DataFormatters/FormattersHelpers.h"
+#include "lldb/Utility/ConstString.h"
+#include "llvm/ADT/APSInt.h"
+
+using namespace lldb;
+using namespace lldb_private;
+using namespace lldb_private::formatters;
+
+namespace lldb_private {
+namespace formatters {
+
+class LibcxxStdRangesRefViewSyntheticFrontEnd
+    : public SyntheticChildrenFrontEnd {
+public:
+  LibcxxStdRangesRefViewSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp);
+
+  ~LibcxxStdRangesRefViewSyntheticFrontEnd() override = default;
+
+  size_t CalculateNumChildren() override;
+
+  lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;
+
+  bool Update() override;
+
+  bool MightHaveChildren() override;
+
+  size_t GetIndexOfChildWithName(ConstString name) override;
+
+private:
+  lldb::ValueObjectSP m_range_sp = nullptr; ///< Pointer to the dereferenced
+                                            ///< __range_ member
+};
+
+lldb_private::formatters::LibcxxStdRangesRefViewSyntheticFrontEnd::
+    LibcxxStdRangesRefViewSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)
+    : SyntheticChildrenFrontEnd(*valobj_sp) {
+  if (valobj_sp)
+    Update();
+}
+
+size_t lldb_private::formatters::LibcxxStdRangesRefViewSyntheticFrontEnd::
+    CalculateNumChildren() {
+  return 1;
+}
+
+lldb::ValueObjectSP lldb_private::formatters::
+    LibcxxStdRangesRefViewSyntheticFrontEnd::GetChildAtIndex(size_t idx) {
+  return m_range_sp;
+}
+
+bool lldb_private::formatters::LibcxxStdRangesRefViewSyntheticFrontEnd::
+    Update() {
+  ValueObjectSP range_ptr =
+      GetChildMemberWithName(m_backend, {ConstString("__range_")});
+  if (!range_ptr)
+    return false;
+
+  lldb_private::Status error;
+  m_range_sp = range_ptr->Dereference(error);
+
+  return error.Success();
+}
+
+bool lldb_private::formatters::LibcxxStdRangesRefViewSyntheticFrontEnd::
+    MightHaveChildren() {
+  return true;
+}
+
+size_t lldb_private::formatters::LibcxxStdRangesRefViewSyntheticFrontEnd::
+    GetIndexOfChildWithName(ConstString name) {
+  return 0;
+}
+
+lldb_private::SyntheticChildrenFrontEnd *
+LibcxxStdRangesRefViewSyntheticFrontEndCreator(CXXSyntheticChildren *,
+                                               lldb::ValueObjectSP valobj_sp) {
+  if (!valobj_sp)
+    return nullptr;
+  CompilerType type = valobj_sp->GetCompilerType();
+  if (!type.IsValid())
+    return nullptr;
+  return new LibcxxStdRangesRefViewSyntheticFrontEnd(valobj_sp);
+}
+
+} // namespace formatters
+} // namespace lldb_private

lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/ranges/ref_view/Makefile

+USE_LIBCPP := 1
+
+CXX_SOURCES := main.cpp
+CXXFLAGS_EXTRAS := -std=c++20
+
+include Makefile.rules

lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/ranges/ref_view/TestDataFormatterLibcxxRangesRefView.py

+"""
+Test LLDB's std::ranges::ref_view formatter
+"""
+
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+
+class LibcxxRangesRefViewDataFormatterTestCase(TestBase):
+
+    def check_string_vec_children(self):
+        return [ValueCheck(name='[0]', summary='"First"'),
+                ValueCheck(name='[1]', summary='"Second"'),
+                ValueCheck(name='[2]', summary='"Third"'),
+                ValueCheck(name='[3]', summary='"Fourth"')]
+
+    def check_string_vec_ref_view(self):
+        return ValueCheck(
+                name='*__range_',
+                summary='size=4',
+                children=self.check_string_vec_children())
+
+    def check_foo(self):
+        return ValueCheck(
+                name="vec",
+                children=self.check_string_vec_children())
+
+    @add_test_categories(["libc++"])
+    def test_with_run_command(self):
+        """Test that std::ranges::ref_view is formatted correctly when printed.
+        """
+        self.build()
+        (self.target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(
+            self, 'Break here', lldb.SBFileSpec('main.cpp', False))
+
+        # Check ref_view over a std::string
+        self.expect_var_path('single',
+                             children=[ValueCheck(
+                                           name='*__range_',
+                                           summary='"First"')])
+
+        # Check all_view, which is a ref_view in this case
+        self.expect_var_path('all',
+                             children=[self.check_string_vec_ref_view()])
+
+        # Check take_view format. Embeds a ref_view
+        self.expect_var_path('subset',
+                             children=[
+                                 ValueCheck(children=[self.check_string_vec_ref_view()]),
+                                 ValueCheck(name='__count_', value='2')
+                             ])
+
+        lldbutil.continue_to_breakpoint(self.process(), bkpt)
+
+        # Check ref_view over custom type 'struct Foo'
+        self.expect_var_path('view',
+                             children=[ValueCheck(
+                                        name='*__range_',
+                                        children=[
+                                            ValueCheck(name='[0]', type="Foo", children=[self.check_foo()]),
+                                            ValueCheck(name='[1]', type="Foo", children=[self.check_foo()])
+                                            ])
+                                       ])

lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/ranges/ref_view/main.cpp

+#include <cstdio>
+#include <ranges>
+#include <string>
+#include <vector>
+
+using string_vec = std::vector<std::string>;
+
+string_vec svec{"First", "Second", "Third", "Fourth"};
+
+struct Foo {
+  std::vector<std::string> vec = svec;
+};
+
+int main() {
+  {
+    auto single = std::ranges::ref_view(svec[0]);
+    auto all = std::views::all(svec);
+    auto subset = all | std::views::take(2);
+    std::puts("Break here");
+  }
+
+  {
+    Foo f[2];
+    auto view = std::ranges::ref_view(f);
+    std::puts("Break here");
+  }
+}