Move display/display_set into List

Author: dcreager

crates/ruff_index/src/list.rs

@@ -559,12 +559,12 @@ mod tests {
     // ----
     // Sets
 
-    impl<K> ListBuilder<K>
+    impl<K> List<K>
     where
         K: Display,
     {
-        fn display_set(&self, list: &List<K, ()>) -> String {
-            let list = list.read();
+        fn display_set(&self) -> String {
+            let list = self.read();
             let elements: Vec<_> = list.iter_set_reverse().collect();
             let mut result = String::new();
             result.push('[');
@@ -589,22 +589,22 @@ mod tests {
         let set12 = set1.insert(2);
         let set123 = set12.insert(3);
         let set1232 = set123.insert(2);
-        assert_eq!(builder.display_set(&empty), "[]");
-        assert_eq!(builder.display_set(&set1), "[1]");
-        assert_eq!(builder.display_set(&set12), "[1, 2]");
-        assert_eq!(builder.display_set(&set123), "[1, 2, 3]");
-        assert_eq!(builder.display_set(&set1232), "[1, 2, 3]");
+        assert_eq!(empty.display_set(), "[]");
+        assert_eq!(set1.display_set(), "[1]");
+        assert_eq!(set12.display_set(), "[1, 2]");
+        assert_eq!(set123.display_set(), "[1, 2, 3]");
+        assert_eq!(set1232.display_set(), "[1, 2, 3]");
 
         // And in reverse order
         let set3 = empty.insert(3);
         let set32 = set3.insert(2);
         let set321 = set32.insert(1);
         let set3212 = set321.insert(2);
-        assert_eq!(builder.display_set(&empty), "[]");
-        assert_eq!(builder.display_set(&set3), "[3]");
-        assert_eq!(builder.display_set(&set32), "[2, 3]");
-        assert_eq!(builder.display_set(&set321), "[1, 2, 3]");
-        assert_eq!(builder.display_set(&set3212), "[1, 2, 3]");
+        assert_eq!(empty.display_set(), "[]");
+        assert_eq!(set3.display_set(), "[3]");
+        assert_eq!(set32.display_set(), "[2, 3]");
+        assert_eq!(set321.display_set(), "[1, 2, 3]");
+        assert_eq!(set3212.display_set(), "[1, 2, 3]");
     }
 
     #[test]
@@ -630,21 +630,21 @@ mod tests {
         }
 
         let result = intersect(&empty, &empty);
-        assert_eq!(builder.display_set(&result), "[]");
+        assert_eq!(result.display_set(), "[]");
         let result = intersect(&empty, &set1234);
-        assert_eq!(builder.display_set(&result), "[]");
+        assert_eq!(result.display_set(), "[]");
         let result = intersect(&empty, &set2457);
-        assert_eq!(builder.display_set(&result), "[]");
+        assert_eq!(result.display_set(), "[]");
         let result = intersect(&set1, &set1234);
-        assert_eq!(builder.display_set(&result), "[1]");
+        assert_eq!(result.display_set(), "[1]");
         let result = intersect(&set1, &set2457);
-        assert_eq!(builder.display_set(&result), "[]");
+        assert_eq!(result.display_set(), "[]");
         let result = intersect(&set2, &set1234);
-        assert_eq!(builder.display_set(&result), "[2]");
+        assert_eq!(result.display_set(), "[2]");
         let result = intersect(&set2, &set2457);
-        assert_eq!(builder.display_set(&result), "[2]");
+        assert_eq!(result.display_set(), "[2]");
         let result = intersect(&set1234, &set2457);
-        assert_eq!(builder.display_set(&result), "[2, 4]");
+        assert_eq!(result.display_set(), "[2, 4]");
     }
 
     #[test]
@@ -670,33 +670,33 @@ mod tests {
         }
 
         let result = union(&empty, &empty);
-        assert_eq!(builder.display_set(&result), "[]");
+        assert_eq!(result.display_set(), "[]");
         let result = union(&empty, &set1234);
-        assert_eq!(builder.display_set(&result), "[1, 2, 3, 4]");
+        assert_eq!(result.display_set(), "[1, 2, 3, 4]");
         let result = union(&empty, &set2457);
-        assert_eq!(builder.display_set(&result), "[2, 4, 5, 7]");
+        assert_eq!(result.display_set(), "[2, 4, 5, 7]");
         let result = union(&set1, &set1234);
-        assert_eq!(builder.display_set(&result), "[1, 2, 3, 4]");
+        assert_eq!(result.display_set(), "[1, 2, 3, 4]");
         let result = union(&set1, &set2457);
-        assert_eq!(builder.display_set(&result), "[1, 2, 4, 5, 7]");
+        assert_eq!(result.display_set(), "[1, 2, 4, 5, 7]");
         let result = union(&set2, &set1234);
-        assert_eq!(builder.display_set(&result), "[1, 2, 3, 4]");
+        assert_eq!(result.display_set(), "[1, 2, 3, 4]");
         let result = union(&set2, &set2457);
-        assert_eq!(builder.display_set(&result), "[2, 4, 5, 7]");
+        assert_eq!(result.display_set(), "[2, 4, 5, 7]");
         let result = union(&set1234, &set2457);
-        assert_eq!(builder.display_set(&result), "[1, 2, 3, 4, 5, 7]");
+        assert_eq!(result.display_set(), "[1, 2, 3, 4, 5, 7]");
     }
 
     // ----
     // Maps
 
-    impl<K, V> ListBuilder<K, V>
+    impl<K, V> List<K, V>
     where
         K: Display,
         V: Display,
     {
-        fn display(&self, list: &List<K, V>) -> String {
-            let list = list.read();
+        fn display(&self) -> String {
+            let list = self.read();
             let entries: Vec<_> = list.iter_reverse().collect();
             let mut result = String::new();
             result.push('[');
@@ -721,22 +721,22 @@ mod tests {
         let map12 = map1.insert_if_vacant(2, 2);
         let map123 = map12.insert_if_vacant(3, 3);
         let map1232 = map123.insert_if_vacant(2, 4);
-        assert_eq!(builder.display(&empty), "[]");
-        assert_eq!(builder.display(&map1), "[1:1]");
-        assert_eq!(builder.display(&map12), "[1:1, 2:2]");
-        assert_eq!(builder.display(&map123), "[1:1, 2:2, 3:3]");
-        assert_eq!(builder.display(&map1232), "[1:1, 2:2, 3:3]");
+        assert_eq!(empty.display(), "[]");
+        assert_eq!(map1.display(), "[1:1]");
+        assert_eq!(map12.display(), "[1:1, 2:2]");
+        assert_eq!(map123.display(), "[1:1, 2:2, 3:3]");
+        assert_eq!(map1232.display(), "[1:1, 2:2, 3:3]");
 
         // And in reverse order
         let map3 = empty.insert_if_vacant(3, 3);
         let map32 = map3.insert_if_vacant(2, 2);
         let map321 = map32.insert_if_vacant(1, 1);
         let map3212 = map321.insert_if_vacant(2, 4);
-        assert_eq!(builder.display(&empty), "[]");
-        assert_eq!(builder.display(&map3), "[3:3]");
-        assert_eq!(builder.display(&map32), "[2:2, 3:3]");
-        assert_eq!(builder.display(&map321), "[1:1, 2:2, 3:3]");
-        assert_eq!(builder.display(&map3212), "[1:1, 2:2, 3:3]");
+        assert_eq!(empty.display(), "[]");
+        assert_eq!(map3.display(), "[3:3]");
+        assert_eq!(map32.display(), "[2:2, 3:3]");
+        assert_eq!(map321.display(), "[1:1, 2:2, 3:3]");
+        assert_eq!(map3212.display(), "[1:1, 2:2, 3:3]");
     }
 
     #[test]
@@ -762,21 +762,21 @@ mod tests {
         }
 
         let result = intersect(&empty, &empty);
-        assert_eq!(builder.display(&result), "[]");
+        assert_eq!(result.display(), "[]");
         let result = intersect(&empty, &map1234);
-        assert_eq!(builder.display(&result), "[]");
+        assert_eq!(result.display(), "[]");
         let result = intersect(&empty, &map2457);
-        assert_eq!(builder.display(&result), "[]");
+        assert_eq!(result.display(), "[]");
         let result = intersect(&map1, &map1234);
-        assert_eq!(builder.display(&result), "[1:2]");
+        assert_eq!(result.display(), "[1:2]");
         let result = intersect(&map1, &map2457);
-        assert_eq!(builder.display(&result), "[]");
+        assert_eq!(result.display(), "[]");
         let result = intersect(&map2, &map1234);
-        assert_eq!(builder.display(&result), "[2:22]");
+        assert_eq!(result.display(), "[2:22]");
         let result = intersect(&map2, &map2457);
-        assert_eq!(builder.display(&result), "[2:40]");
+        assert_eq!(result.display(), "[2:40]");
         let result = intersect(&map1234, &map2457);
-        assert_eq!(builder.display(&result), "[2:22, 4:44]");
+        assert_eq!(result.display(), "[2:22, 4:44]");
     }
 
     #[test]
@@ -802,24 +802,21 @@ mod tests {
         }
 
         let result = union(&empty, &empty);
-        assert_eq!(builder.display(&result), "[]");
+        assert_eq!(result.display(), "[]");
         let result = union(&empty, &map1234);
-        assert_eq!(builder.display(&result), "[1:1, 2:2, 3:3, 4:4]");
+        assert_eq!(result.display(), "[1:1, 2:2, 3:3, 4:4]");
         let result = union(&empty, &map2457);
-        assert_eq!(builder.display(&result), "[2:20, 4:40, 5:50, 7:70]");
+        assert_eq!(result.display(), "[2:20, 4:40, 5:50, 7:70]");
         let result = union(&map1, &map1234);
-        assert_eq!(builder.display(&result), "[1:2, 2:2, 3:3, 4:4]");
+        assert_eq!(result.display(), "[1:2, 2:2, 3:3, 4:4]");
         let result = union(&map1, &map2457);
-        assert_eq!(builder.display(&result), "[1:1, 2:20, 4:40, 5:50, 7:70]");
+        assert_eq!(result.display(), "[1:1, 2:20, 4:40, 5:50, 7:70]");
         let result = union(&map2, &map1234);
-        assert_eq!(builder.display(&result), "[1:1, 2:22, 3:3, 4:4]");
+        assert_eq!(result.display(), "[1:1, 2:22, 3:3, 4:4]");
         let result = union(&map2, &map2457);
-        assert_eq!(builder.display(&result), "[2:40, 4:40, 5:50, 7:70]");
+        assert_eq!(result.display(), "[2:40, 4:40, 5:50, 7:70]");
         let result = union(&map1234, &map2457);
-        assert_eq!(
-            builder.display(&result),
-            "[1:1, 2:22, 3:3, 4:44, 5:50, 7:70]"
-        );
+        assert_eq!(result.display(), "[1:1, 2:22, 3:3, 4:44, 5:50, 7:70]");
     }
 }