Add LLDB providers for BTreeMap and BTreeSet

Fixes #111868

Author: ede1998

library/alloc/src/collections/btree/node.rs

@@ -93,7 +93,7 @@ impl<K, V> LeafNode<K, V> {
 /// node, allowing code to act on leaf and internal nodes generically without having to even check
 /// which of the two a pointer is pointing at. This property is enabled by the use of `repr(C)`.
 #[repr(C)]
-// gdb_providers.py uses this type name for introspection.
+// gdb_providers.py and lldb_providers.py use this type name for introspection.
 struct InternalNode<K, V> {
     data: LeafNode<K, V>,
 

src/etc/lldb_lookup.py

@@ -42,6 +42,11 @@ def summary_lookup(valobj: lldb.SBValue, _dict: LLDBOpaque) -> str:
     if rust_type == RustType.STD_HASH_SET:
         return SizeSummaryProvider(valobj, _dict)
 
+    if rust_type == RustType.STD_BTREE_MAP:
+        return SizeSummaryProvider(valobj, _dict)
+    if rust_type == RustType.STD_BTREE_SET:
+        return SizeSummaryProvider(valobj, _dict)
+
     if rust_type == RustType.STD_RC:
         return StdRcSummaryProvider(valobj, _dict)
     if rust_type == RustType.STD_ARC:
@@ -105,6 +110,11 @@ def synthetic_lookup(valobj: lldb.SBValue, _dict: LLDBOpaque) -> object:
         else:
             return StdOldHashMapSyntheticProvider(hash_map, _dict, show_values=False)
 
+    if rust_type == RustType.STD_BTREE_MAP:
+        return StdBTreeMapSyntheticProvider(valobj, _dict)
+    if rust_type == RustType.STD_BTREE_SET:
+        return StdBTreeMapSyntheticProvider(valobj, _dict, show_values=False)
+
     if rust_type == RustType.STD_RC:
         return StdRcSyntheticProvider(valobj, _dict)
     if rust_type == RustType.STD_ARC:

src/etc/lldb_providers.py

@@ -1151,6 +1151,129 @@ def has_children(self) -> bool:
         return True
 
 
+def children_of_node(node_ptr: SBValue, height: int):
+    def cast_to_internal(node: SBValue) -> SBValue:
+        # BTreeMap implementation does ad-hoc polymorphism between LeafNode and InternalNode
+        # with raw pointers.
+        # https://github.com/rust-lang/rust/issues/90520#issuecomment-2211103129
+        internal_type_name = node.type.GetPointeeType().name.replace(
+            "LeafNode", "InternalNode", 1
+        )
+        target = node.GetTarget()
+        internal_type = target.FindFirstType(internal_type_name)
+        return node.Cast(internal_type.GetPointerType())
+
+    def unwrap_item_from_array_of_maybe_uninit(arr: SBValue, index: int) -> SBValue:
+        element = arr.GetChildAtIndex(index)
+        return element.GetChildMemberWithName("value").GetChildMemberWithName("value")
+
+    if node_ptr.type.name.startswith("alloc::collections::btree::node::BoxedNode<"):
+        # BACKCOMPAT: rust 1.49
+        node_ptr = node_ptr.GetChildMemberWithName("ptr")
+    node_ptr = unwrap_unique_or_non_null(node_ptr)
+    leaf = node_ptr.Dereference()
+    keys = leaf.GetChildMemberWithName("keys")
+    vals = leaf.GetChildMemberWithName("vals")
+    length = leaf.GetChildMemberWithName("len").unsigned
+    edges = cast_to_internal(node_ptr).GetChildMemberWithName("edges") if height > 0 else None
+
+    for i in range(length + 1):
+        if height > 0:
+            child_ptr = unwrap_item_from_array_of_maybe_uninit(edges, i)
+            yield from children_of_node(child_ptr, height - 1)
+        if i < length:
+           # Avoid "Cannot perform pointer math on incomplete type" on zero-sized arrays.
+           key_type_size = keys.type.size
+           val_type_size = vals.type.size
+           key = (
+               unwrap_item_from_array_of_maybe_uninit(keys, i)
+               if key_type_size > 0
+               else node_ptr.EvaluateExpression("()")
+           )
+           val = (
+               unwrap_item_from_array_of_maybe_uninit(vals, i)
+               if val_type_size > 0
+               else node_ptr.EvaluateExpression("()")
+           )
+           yield key, val
+
+def strip_till_parentheses(text: str) -> str:
+    start = text.find('(')
+    end = text.find(')')
+    if start == -1 or end == -1:
+        return text
+    return text[start: end + 1]
+
+
+class StdBTreeMapSyntheticProvider:
+    def __init__(self, valobj: SBValue, _dict: LLDBOpaque, show_values: bool = True):
+        self.valobj = valobj
+        self._dict = _dict
+        self.show_values = True
+
+    def num_children(self) -> int:
+        return self.size
+
+    def get_child_index(self, name: str) -> int:
+        index = name.lstrip("[").rstrip("]")
+        if index.isdigit():
+            return int(index)
+        else:
+            return -1
+
+    def get_child_at_index(self, index: int) -> SBValue:
+        key, value = self.items[index]
+        if self.show_values:
+           data = key.GetData()
+           assert data.Append(value.GetData()), "Failed to create key value pair"
+           return self.valobj.CreateValueFromData(
+                "[%s]" % index, data, self.pair_type
+           )
+        return self.valobj.CreateValueFromData(
+            "[%s]" % index, key.GetData(), key.type
+        )
+
+    def update(self) -> bool:
+        self.size = self.valobj.GetChildMemberWithName("length").unsigned
+        self.items = []
+
+        # Determine the type for the tuple (Key, Value)
+        # - get_template_args helper breaks on console because type is shown as
+        #   `core::marker::PhantomData<(&str, &str) *>`
+        # - Type lookup after get_template_args helper fails with codelldb for unclear reasons
+        # - Native `template_args[0]` from LLDB fails with codelldb and just says `T` if printed
+        #   on console
+        marker_type_name = self.valobj.GetChildMemberWithName("_marker").GetTypeName()
+        pair_type_name = strip_till_parentheses(marker_type_name)
+        target = self.valobj.GetTarget()
+        self.pair_type = target.FindFirstType(pair_type_name)
+
+        if self.size == 0:
+            return
+
+        root = self.valobj.GetChildMemberWithName("root")
+
+        if root.type.name.startswith("core::option::Option<"):
+            target = self.valobj.GetTarget()
+            type_some = target.FindFirstType(get_template_args(root.GetTypeName())[0])
+            root = root.Cast(type_some)
+
+        height = root.GetChildMemberWithName("height")
+        node_ptr = root.GetChildMemberWithName("node")
+
+        self.items = [
+            (key, value)
+            for key, value in children_of_node(node_ptr, height.unsigned)
+        ]
+
+        assert len(self.items) == self.size
+
+        return False
+
+    def has_children(self) -> bool:
+        return True
+
+
 def StdRcSummaryProvider(valobj: SBValue, _dict: LLDBOpaque) -> str:
     strong = valobj.GetChildMemberWithName("strong").GetValueAsUnsigned()
     weak = valobj.GetChildMemberWithName("weak").GetValueAsUnsigned()