4 files changed, 312 insertions, 0 deletions

diff --git a/lib/README.md b/lib/README.md
new file mode 100644
index 000000000..6b2eeac2c
--- /dev/null
+++ b/lib/README.md
@@ -0,0 +1,2 @@
+Crates in this directory are published to crates.io and obey semver.
+They *could* live in a separate repo, but we want to experiment with a monorepo setup.
diff --git a/lib/arena/Cargo.toml b/lib/arena/Cargo.toml
new file mode 100644
index 000000000..f4d2ecb6c
--- /dev/null
+++ b/lib/arena/Cargo.toml
@@ -0,0 +1,10 @@
+[package]
+name = "la-arena"
+version = "0.2.0"
+description = "Simple index-based arena without deletion."
+license = "MIT OR Apache-2.0"
+repository = "https://github.com/rust-analyzer/rust-analyzer"
+documentation = "https://docs.rs/la-arena"
+categories = ["data-structures", "memory-management", "rust-patterns"]
+authors = ["rust-analyzer developers"]
+edition = "2018"
diff --git a/lib/arena/src/lib.rs b/lib/arena/src/lib.rs
new file mode 100644
index 000000000..230a50291
--- /dev/null
+++ b/lib/arena/src/lib.rs
@@ -0,0 +1,231 @@
+//! Yet another index-based arena.
+
+#![warn(missing_docs)]
+
+use std::{
+    fmt,
+    hash::{Hash, Hasher},
+    iter::FromIterator,
+    marker::PhantomData,
+    ops::{Index, IndexMut},
+};
+
+mod map;
+pub use map::ArenaMap;
+
+/// The raw index of a value in an arena.
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct RawIdx(u32);
+
+impl From<RawIdx> for u32 {
+    fn from(raw: RawIdx) -> u32 {
+        raw.0
+    }
+}
+
+impl From<u32> for RawIdx {
+    fn from(idx: u32) -> RawIdx {
+        RawIdx(idx)
+    }
+}
+
+impl fmt::Debug for RawIdx {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.0.fmt(f)
+    }
+}
+
+impl fmt::Display for RawIdx {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.0.fmt(f)
+    }
+}
+
+/// The index of a value allocated in an arena that holds `T`s.
+pub struct Idx<T> {
+    raw: RawIdx,
+    _ty: PhantomData<fn() -> T>,
+}
+
+impl<T> Clone for Idx<T> {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+impl<T> Copy for Idx<T> {}
+
+impl<T> PartialEq for Idx<T> {
+    fn eq(&self, other: &Idx<T>) -> bool {
+        self.raw == other.raw
+    }
+}
+impl<T> Eq for Idx<T> {}
+
+impl<T> Hash for Idx<T> {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.raw.hash(state)
+    }
+}
+
+impl<T> fmt::Debug for Idx<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let mut type_name = std::any::type_name::<T>();
+        if let Some(idx) = type_name.rfind(':') {
+            type_name = &type_name[idx + 1..]
+        }
+        write!(f, "Idx::<{}>({})", type_name, self.raw)
+    }
+}
+
+impl<T> Idx<T> {
+    /// Creates a new index from a [`RawIdx`].
+    pub fn from_raw(raw: RawIdx) -> Self {
+        Idx { raw, _ty: PhantomData }
+    }
+
+    /// Converts this index into the underlying [`RawIdx`].
+    pub fn into_raw(self) -> RawIdx {
+        self.raw
+    }
+}
+
+/// Yet another index-based arena.
+#[derive(Clone, PartialEq, Eq)]
+pub struct Arena<T> {
+    data: Vec<T>,
+}
+
+impl<T: fmt::Debug> fmt::Debug for Arena<T> {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        fmt.debug_struct("Arena").field("len", &self.len()).field("data", &self.data).finish()
+    }
+}
+
+impl<T> Arena<T> {
+    /// Creates a new empty arena.
+    ///
+    /// ```
+    /// let arena: la_arena::Arena<i32> = la_arena::Arena::new();
+    /// assert!(arena.is_empty());
+    /// ```
+    pub const fn new() -> Arena<T> {
+        Arena { data: Vec::new() }
+    }
+
+    /// Empties the arena, removing all contained values.
+    ///
+    /// ```
+    /// let mut arena = la_arena::Arena::new();
+    ///
+    /// arena.alloc(1);
+    /// arena.alloc(2);
+    /// arena.alloc(3);
+    /// assert_eq!(arena.len(), 3);
+    ///
+    /// arena.clear();
+    /// assert!(arena.is_empty());
+    /// ```
+    pub fn clear(&mut self) {
+        self.data.clear();
+    }
+
+    /// Returns the length of the arena.
+    ///
+    /// ```
+    /// let mut arena = la_arena::Arena::new();
+    /// assert_eq!(arena.len(), 0);
+    ///
+    /// arena.alloc("foo");
+    /// assert_eq!(arena.len(), 1);
+    ///
+    /// arena.alloc("bar");
+    /// assert_eq!(arena.len(), 2);
+    ///
+    /// arena.alloc("baz");
+    /// assert_eq!(arena.len(), 3);
+    /// ```
+    pub fn len(&self) -> usize {
+        self.data.len()
+    }
+
+    /// Returns whether the arena contains no elements.
+    ///
+    /// ```
+    /// let mut arena = la_arena::Arena::new();
+    /// assert!(arena.is_empty());
+    ///
+    /// arena.alloc(0.5);
+    /// assert!(!arena.is_empty());
+    /// ```
+    pub fn is_empty(&self) -> bool {
+        self.data.is_empty()
+    }
+
+    /// Allocates a new value on the arena, returning the value’s index.
+    ///
+    /// ```
+    /// let mut arena = la_arena::Arena::new();
+    /// let idx = arena.alloc(50);
+    ///
+    /// assert_eq!(arena[idx], 50);
+    /// ```
+    pub fn alloc(&mut self, value: T) -> Idx<T> {
+        let idx = RawIdx(self.data.len() as u32);
+        self.data.push(value);
+        Idx::from_raw(idx)
+    }
+
+    /// Returns an iterator over the arena’s elements.
+    ///
+    /// ```
+    /// let mut arena = la_arena::Arena::new();
+    /// let idx1 = arena.alloc(20);
+    /// let idx2 = arena.alloc(40);
+    /// let idx3 = arena.alloc(60);
+    ///
+    /// let mut iterator = arena.iter();
+    /// assert_eq!(iterator.next(), Some((idx1, &20)));
+    /// assert_eq!(iterator.next(), Some((idx2, &40)));
+    /// assert_eq!(iterator.next(), Some((idx3, &60)));
+    /// ```
+    pub fn iter(
+        &self,
+    ) -> impl Iterator<Item = (Idx<T>, &T)> + ExactSizeIterator + DoubleEndedIterator {
+        self.data.iter().enumerate().map(|(idx, value)| (Idx::from_raw(RawIdx(idx as u32)), value))
+    }
+
+    /// Reallocates the arena to make it take up as little space as possible.
+    pub fn shrink_to_fit(&mut self) {
+        self.data.shrink_to_fit();
+    }
+}
+
+impl<T> Default for Arena<T> {
+    fn default() -> Arena<T> {
+        Arena { data: Vec::new() }
+    }
+}
+
+impl<T> Index<Idx<T>> for Arena<T> {
+    type Output = T;
+    fn index(&self, idx: Idx<T>) -> &T {
+        let idx = idx.into_raw().0 as usize;
+        &self.data[idx]
+    }
+}
+
+impl<T> IndexMut<Idx<T>> for Arena<T> {
+    fn index_mut(&mut self, idx: Idx<T>) -> &mut T {
+        let idx = idx.into_raw().0 as usize;
+        &mut self.data[idx]
+    }
+}
+
+impl<T> FromIterator<T> for Arena<T> {
+    fn from_iter<I>(iter: I) -> Self
+    where
+        I: IntoIterator<Item = T>,
+    {
+        Arena { data: Vec::from_iter(iter) }
+    }
+}
diff --git a/lib/arena/src/map.rs b/lib/arena/src/map.rs
new file mode 100644
index 000000000..d8acfe051
--- /dev/null
+++ b/lib/arena/src/map.rs
@@ -0,0 +1,69 @@
+use std::marker::PhantomData;
+
+use crate::Idx;
+
+/// A map from arena indexes to some other type.
+/// Space requirement is O(highest index).
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct ArenaMap<IDX, V> {
+    v: Vec<Option<V>>,
+    _ty: PhantomData<IDX>,
+}
+
+impl<T, V> ArenaMap<Idx<T>, V> {
+    /// Inserts a value associated with a given arena index into the map.
+    pub fn insert(&mut self, idx: Idx<T>, t: V) {
+        let idx = Self::to_idx(idx);
+
+        self.v.resize_with((idx + 1).max(self.v.len()), || None);
+        self.v[idx] = Some(t);
+    }
+
+    /// Returns a reference to the value associated with the provided index
+    /// if it is present.
+    pub fn get(&self, idx: Idx<T>) -> Option<&V> {
+        self.v.get(Self::to_idx(idx)).and_then(|it| it.as_ref())
+    }
+
+    /// Returns a mutable reference to the value associated with the provided index
+    /// if it is present.
+    pub fn get_mut(&mut self, idx: Idx<T>) -> Option<&mut V> {
+        self.v.get_mut(Self::to_idx(idx)).and_then(|it| it.as_mut())
+    }
+
+    /// Returns an iterator over the values in the map.
+    pub fn values(&self) -> impl Iterator<Item = &V> {
+        self.v.iter().filter_map(|o| o.as_ref())
+    }
+
+    /// Returns an iterator over mutable references to the values in the map.
+    pub fn values_mut(&mut self) -> impl Iterator<Item = &mut V> {
+        self.v.iter_mut().filter_map(|o| o.as_mut())
+    }
+
+    /// Returns an iterator over the arena indexes and values in the map.
+    pub fn iter(&self) -> impl Iterator<Item = (Idx<T>, &V)> {
+        self.v.iter().enumerate().filter_map(|(idx, o)| Some((Self::from_idx(idx), o.as_ref()?)))
+    }
+
+    fn to_idx(idx: Idx<T>) -> usize {
+        u32::from(idx.into_raw()) as usize
+    }
+
+    fn from_idx(idx: usize) -> Idx<T> {
+        Idx::from_raw((idx as u32).into())
+    }
+}
+
+impl<T, V> std::ops::Index<Idx<V>> for ArenaMap<Idx<V>, T> {
+    type Output = T;
+    fn index(&self, idx: Idx<V>) -> &T {
+        self.v[Self::to_idx(idx)].as_ref().unwrap()
+    }
+}
+
+impl<T, V> Default for ArenaMap<Idx<V>, T> {
+    fn default() -> Self {
+        ArenaMap { v: Vec::new(), _ty: PhantomData }
+    }
+}