Implement B-Tree deletion and respective tests.

Key Changes:
 - Implement removal through SortedDictionary subscript
 - Implement _BTree.contains for efficient existence checking
 - Add tests
   - _Node.UnsafeHandle.rotation/collapse tests
   - _BTree.removeAny tests
 - Expand benchmarks
   - Add C++ reference lookup benchmarks
   - Correct old benchmarks

Minor Changes:
 - Remove B-Tree benchmarks, correct SortedDictionary benchmarks
 - Adjust debug B-Tree printer to show both numElements and numTotalElements
 - Add total count synchronization invariant check
 - Implement CustomReflectable for B-Tree

Author: vihanb

Benchmarks/Benchmarks/CppBenchmarks.swift

@@ -729,14 +729,14 @@ extension Benchmark {
 
     //--------------------------------------------------------------------------
 
-//    self.addSimple(
-//      title: "std::map<intptr_t, intptr_t> insert",
-//      input: [Int].self
-//    ) { input in
-//      input.withUnsafeBufferPointer { buffer in
-//        cpp_map_insert_integers(buffer.baseAddress, buffer.count)
-//      }
-//    }
+    self.addSimple(
+      title: "std::map<intptr_t, intptr_t> insert",
+      input: [Int].self
+    ) { input in
+      input.withUnsafeBufferPointer { buffer in
+        cpp_map_insert_integers(buffer.baseAddress, buffer.count)
+      }
+    }
 
     self.add(
       title: "std::map<intptr_t, intptr_t> successful find",
@@ -745,7 +745,7 @@ extension Benchmark {
       let map = CppMap(input)
       return { timer in
         lookups.withUnsafeBufferPointer { buffer in
-          cpp_map_lookups(map.ptr, buffer.baseAddress, buffer.count, true)
+          cpp_map_lookups(map.ptr, buffer.baseAddress, buffer.count)
         }
       }
     }

Benchmarks/Benchmarks/SortedDictionaryBenchmarks.swift

@@ -13,77 +13,44 @@ import CollectionsBenchmark
 
 extension Benchmark {
   public mutating func addSortedDictionaryBenchmarks() {
-//    self.add(
-//      title: "SortedDictionary<Int, Int> init(uniqueKeysWithValues:)",
-//      input: [Int].self
-//    ) { input in
-//      let keysAndValues = input.lazy.map { (key: $0, value: 2 * $0) }
-//
-//      return { timer in
-//        blackHole(SortedDictionary(uniqueKeysWithValues: keysAndValues))
-//      }
-//    }
-//
-//    self.add(
-//      title: "SortedDictionary<Int, Int> subscript, append",
-//      input: [Int].self
-//    ) { input in
-//      let keysAndValues = input.lazy.map { (key: $0, value: 2 * $0) }
-//      var sortedDictionary = SortedDictionary<Int, Int>()
-//
-//      return { timer in
-//        for (key, value) in keysAndValues {
-//          sortedDictionary[key] = value
-//        }
-//        blackHole(sortedDictionary)
-//      }
-//    }
-    
     self.add(
-      title: "SortedDictionary<Int, Int> subscript, successful lookups",
+      title: "SortedDictionary<Int, Int> init(uniqueKeysWithValues:)",
       input: [Int].self
     ) { input in
       let keysAndValues = input.lazy.map { (key: $0, value: 2 * $0) }
-      let sortedDictionary = SortedDictionary<Int, Int>(uniqueKeysWithValues: keysAndValues)
-      
+
+      return { timer in
+        blackHole(SortedDictionary(uniqueKeysWithValues: keysAndValues))
+      }
+    }
+
+    self.add(
+      title: "SortedDictionary<Int, Int> subscript, append",
+      input: [Int].self
+    ) { input in
+      let keysAndValues = input.lazy.map { (key: $0, value: 2 * $0) }
+      var sortedDictionary = SortedDictionary<Int, Int>()
+
       return { timer in
         for (key, value) in keysAndValues {
-          precondition(sortedDictionary[key] == value)
+          sortedDictionary[key] = value
         }
+        blackHole(sortedDictionary)
       }
     }
 
-//    self.add(
-//      title: "SortedDictionary<Int, Int>._BTree firstValue",
-//      input: [Int].self
-//    ) { input in
-//      let keysAndValues = input.lazy.map { (key: $0, value: 2 * $0) }
-//      var tree = _BTree<Int, Int>()
-//
-//      for (key, value) in keysAndValues {
-//        tree.insertOrUpdate((key, value))
-//      }
-//
-//      return { timer in
-//        for (key, value) in keysAndValues {
-//          precondition(tree.anyValue(for: key) != nil)
-//        }
-//      }
-//    }
-    
-//    self.add(
-//      title: "SortedDictionary<Int, Int>._BTree insertOrUpdate(element:)",
-//      input: [Int].self
-//    ) { input in
-//      let keysAndValues = input.lazy.map { (key: $0, value: 2 * $0) }
-//
-//      return { timer in
-//        var tree = _BTree<Int, Int>()
-//        for (key, value) in keysAndValues {
-//          tree.insertOrUpdate((key, value))
-//        }
-//        blackHole(tree)
-//      }
-//    }
+    self.add(
+      title: "SortedDictionary<Int, Int> subscript, successful lookups",
+      input: ([Int], [Int]).self
+    ) { input, lookups in
+      let keysAndValues = input.lazy.map { (key: $0, value: 2 * $0) }
+      let sortedDictionary = SortedDictionary<Int, Int>(uniqueKeysWithValues: keysAndValues)
+
+      return { timer in
+        for key in lookups {
+          precondition(sortedDictionary._root.contains(key: key))
+        }
+      }
+    }
   }
 }

Benchmarks/CppBenchmarks/include/MapBenchmarks.h

@@ -29,7 +29,8 @@ extern void cpp_map_destroy(void *ptr);
 
 extern void cpp_map_insert_integers(const intptr_t *start, size_t count);
 
-extern void cpp_map_lookups(void *ptr, const intptr_t *start, size_t count, bool expectMatch);
+extern void cpp_map_lookups(void *ptr, const intptr_t *start, size_t count);
+extern void cpp_map_subscript(void *ptr, const intptr_t *start, size_t count);
 
 #ifdef __cplusplus
 }

Benchmarks/CppBenchmarks/src/MapBenchmarks.cpp

@@ -51,11 +51,20 @@ auto find(custom_map* map, intptr_t value)
 }
 
 void
-cpp_map_lookups(void *ptr, const intptr_t *start, size_t count, bool expectMatch)
+cpp_map_lookups(void *ptr, const intptr_t *start, size_t count)
 {
   auto map = static_cast<custom_map *>(ptr);
   for (auto it = start; it < start + count; ++it) {
-    auto found = find(map, *it) != map->end();
-    if (found != expectMatch) { abort(); }
+    auto isCorrect = find(map, *it)->second == *it * 2;
+    if (!isCorrect) { abort(); }
+  }
+}
+
+void
+cpp_map_subscript(void *ptr, const intptr_t *start, size_t count)
+{
+  auto map = static_cast<custom_map *>(ptr);
+  for (auto it = start; it < start + count; ++it) {
+    black_hole((*map)[*it]);
   }
 }

Sources/SortedCollections/BTree/_BTree+CustomReflectable.swift

@@ -0,0 +1,18 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift Collections open source project
+//
+// Copyright (c) 2021 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+//
+//===----------------------------------------------------------------------===//
+
+extension _BTree: CustomReflectable {
+  /// The custom mirror for this instance.
+  @inlinable
+  internal var customMirror: Mirror {
+    Mirror(self, unlabeledChildren: self, displayStyle: .dictionary)
+  }
+}

Sources/SortedCollections/BTree/_BTree.Index.swift

@@ -10,10 +10,8 @@
 //===----------------------------------------------------------------------===//
 
 extension _BTree {
+  
   /// An index to an element of the BTree represented as a path.
-  /// - Warning: operations using this type do not perform checks if the
-  ///     tree is still valid. Therefore, operations using this may result in
-  ///     undefined behavior if the tree is muated or deallocated.
   @usableFromInline
   internal struct Index: Comparable {
     /// The path to the element in the BTree. A `nil` value indicates

Sources/SortedCollections/BTree/_BTree.swift

@@ -180,12 +180,61 @@ extension _BTree {
 
     // TODO: Don't create CoW copy until needed.
     // TODO: Handle root deletion
-    return self.root.update { $0.removeAny(key: key) }
+    let removedElement = self.root.update { $0.removeAny(key: key) }
+    
+    // Check if the tree height needs to be reduced
+    if self.root.read({ $0.numElements == 0 && !$0.isLeaf }) {
+      let newRoot: Node = self.root.update { handle in
+        let newRoot = handle.moveChild(at: 0)
+        handle.drop()
+        return newRoot
+      }
+      
+      self.root = newRoot
+    }
+    
+    return removedElement
   }
 }
 
 // MARK: Read Operations
-extension _BTree {  
+extension _BTree {
+  /// Determines if a key exists within a tree.
+  ///
+  /// - Parameter key: The key to search for.
+  /// - Returns: Whether or not the key was found.
+  @inlinable
+  internal func contains(key: Key) -> Bool {
+    // the retain/release calls
+    // Retain
+    var node: Node? = self.root
+    
+    while let currentNode = node {
+      let found: Bool = currentNode.read { handle in
+        let slot = handle.firstSlot(for: key)
+        
+        if slot < handle.numElements && handle[keyAt: slot] == key {
+          return true
+        } else {
+          if handle.isLeaf {
+            node = nil
+          } else {
+            // Release
+            // Retain
+            node = handle[childAt: slot]
+          }
+        }
+        
+        return false
+      }
+      
+      if found { return true }
+    }
+    
+    return false
+  }
+  
+  
   /// Returns the value corresponding to the first found instance of the key.
   ///
   /// This may not be the first instance of the key. This is marginally more efficient

Sources/SortedCollections/BTree/_Node.UnsafeHandle+CustomDebugStringConvertible.swift

@@ -14,7 +14,7 @@ extension _Node.UnsafeHandle: CustomDebugStringConvertible {
   #if DEBUG
   private enum PrintPosition { case start, end, middle }
   private func indentDescription(_ node: _Node<Key, Value>.UnsafeHandle, position: PrintPosition) -> String {
-    let label = "(\(node.numTotalElements))"
+    let label = "(\(node.numElements)/\(node.numTotalElements))"
 
     let spaces = String(repeating: " ", count: label.count)
 
@@ -54,6 +54,20 @@ extension _Node.UnsafeHandle: CustomDebugStringConvertible {
 
   /// A textual representation of this instance, suitable for debugging.
   private func describeNode(_ node: _Node<Key, Value>.UnsafeHandle) -> String {
+    if node.numElements == 0 {
+      var result = ""
+      if !node.isLeaf {
+        node[childAt: 0].read { handle in
+          result += indentDescription(handle, position: .start) + "\n"
+        }
+        
+        result += "┗━ << EMPTY >>"
+      } else {
+        result = "╺━ << EMPTY >>"
+      }
+      return result
+    }
+    
     var result = ""
     for slot in 0..<node.numElements {
       if !node.isLeaf {