Hide VecMap

Summary:
There are certain things I'd want to try, in particular, allocate `RawTable` with entries instead of separate allocation.

Public `VecMap` stands in the way.

Reviewed By: bobyangyf

Differential Revision: D40923063

fbshipit-source-id: 5098c50eaaa65b159dfd4fe8002cd3c51b078f28

Author: stepancheg

starlark_map/src/lib.rs

@@ -31,7 +31,7 @@ pub mod small_map;
 pub mod small_set;
 // TODO(nga): make private.
 mod iter;
-pub mod vec_map;
+pub(crate) mod vec_map;
 
 pub use equivalent::Equivalent;
 pub use hash_value::StarlarkHashValue;

starlark_map/src/small_map/mod.rs

@@ -123,26 +123,6 @@ impl<K, V> SmallMap<K, V> {
         }
     }
 
-    #[inline]
-    pub fn into_raw_parts(self) -> (VecMap<K, V>, Option<Box<RawTable<usize>>>) {
-        (self.entries, self.index)
-    }
-
-    #[inline]
-    pub unsafe fn from_raw_parts(
-        entries: VecMap<K, V>,
-        index: Option<Box<RawTable<usize>>>,
-    ) -> SmallMap<K, V> {
-        if let Some(index) = &index {
-            // Quick smoke test.
-            // We don't validate indices are correct hence this function is unsafe.
-            assert!(entries.len() == index.len());
-        } else {
-            assert!(entries.len() <= NO_INDEX_THRESHOLD);
-        }
-        SmallMap { entries, index }
-    }
-
     /// Key references iterator.
     #[inline]
     pub fn keys(&self) -> Keys<K, V> {

starlark_map/src/vec_map/iter.rs

@@ -109,7 +109,7 @@ impl<'a, K: 'a, V: 'a> ExactSizeIterator for ValuesMut<'a, K, V> {
 }
 
 #[derive(Clone_)]
-pub struct Iter<'a, K: 'a, V: 'a> {
+pub(crate) struct Iter<'a, K: 'a, V: 'a> {
     pub(crate) iter: IterHashed<'a, K, V>,
 }
 
@@ -161,7 +161,7 @@ impl<'a, K: 'a, V: 'a> ExactSizeIterator for IterHashed<'a, K, V> {
     }
 }
 
-pub struct IterMut<'a, K: 'a, V: 'a> {
+pub(crate) struct IterMut<'a, K: 'a, V: 'a> {
     pub(crate) iter: std::slice::IterMut<'a, Bucket<K, V>>,
 }
 
@@ -189,7 +189,7 @@ impl<'a, K: 'a, V: 'a> ExactSizeIterator for IterMut<'a, K, V> {
     }
 }
 
-pub struct IntoIterHashed<K, V> {
+pub(crate) struct IntoIterHashed<K, V> {
     pub(crate) iter: std::vec::IntoIter<Bucket<K, V>>,
 }
 
@@ -217,7 +217,7 @@ impl<K, V> DoubleEndedIterator for IntoIterHashed<K, V> {
     def_double_ended_iter!();
 }
 
-pub struct IntoIter<K, V> {
+pub(crate) struct IntoIter<K, V> {
     pub(crate) iter: IntoIterHashed<K, V>,
 }
 

starlark_map/src/vec_map/mod.rs

@@ -26,11 +26,11 @@ use gazebo::prelude::*;
 use crate::equivalent::Equivalent;
 use crate::hash_value::StarlarkHashValue;
 use crate::hashed::Hashed;
-pub use crate::vec_map::iter::IntoIter;
+pub(crate) use crate::vec_map::iter::IntoIter;
 pub(crate) use crate::vec_map::iter::IntoIterHashed;
-pub use crate::vec_map::iter::Iter;
+pub(crate) use crate::vec_map::iter::Iter;
 pub(crate) use crate::vec_map::iter::IterHashed;
-pub use crate::vec_map::iter::IterMut;
+pub(crate) use crate::vec_map::iter::IterMut;
 pub(crate) use crate::vec_map::iter::Keys;
 pub(crate) use crate::vec_map::iter::Values;
 pub(crate) use crate::vec_map::iter::ValuesMut;
@@ -54,20 +54,20 @@ impl<K: Hash, V: Hash> Hash for Bucket<K, V> {
 }
 
 #[derive(Debug, Clone, Eq, PartialEq, Default_)]
-pub struct VecMap<K, V> {
+pub(crate) struct VecMap<K, V> {
     buckets: Vec<Bucket<K, V>>,
 }
 
 impl<K, V> VecMap<K, V> {
     #[inline]
-    pub const fn new() -> Self {
+    pub(crate) const fn new() -> Self {
         VecMap {
             buckets: Vec::new(),
         }
     }
 
     #[inline]
-    pub fn with_capacity(n: usize) -> Self {
+    pub(crate) fn with_capacity(n: usize) -> Self {
         VecMap {
             buckets: Vec::with_capacity(n),
         }
@@ -140,7 +140,7 @@ impl<K, V> VecMap<K, V> {
     }
 
     #[inline]
-    pub fn insert_hashed_unique_unchecked(&mut self, key: Hashed<K>, value: V) {
+    pub(crate) fn insert_hashed_unique_unchecked(&mut self, key: Hashed<K>, value: V) {
         self.buckets.push(Bucket {
             hash: key.hash(),
             key: key.into_key(),
@@ -173,12 +173,12 @@ impl<K, V> VecMap<K, V> {
     }
 
     #[inline]
-    pub fn len(&self) -> usize {
+    pub(crate) fn len(&self) -> usize {
         self.buckets.len()
     }
 
     #[inline]
-    pub fn is_empty(&self) -> bool {
+    pub(crate) fn is_empty(&self) -> bool {
         self.buckets.is_empty()
     }
 
@@ -226,7 +226,7 @@ impl<K, V> VecMap<K, V> {
     }
 
     #[inline]
-    pub fn into_iter_hashed(self) -> IntoIterHashed<K, V> {
+    pub(crate) fn into_iter_hashed(self) -> IntoIterHashed<K, V> {
         // See the comments on VMIntoIterHash for why this one looks different
         IntoIterHashed {
             iter: self.buckets.into_iter(),