misc: Fix broken doc links, remove "pool" from index_map.rs

compiler/cl-ast/src/ast.rs

@@ -5,12 +5,13 @@
 //! - [Item] and [ItemKind]: Top-level constructs
 //! - [Stmt] and [StmtKind]: Statements
 //! - [Expr] and [ExprKind]: Expressions
-//!   - [Assign], [Binary], and [Unary] expressions
-//!   - [AssignKind], [BinaryKind], and [UnaryKind] operators
+//!   - [Assign], [Modify], [Binary], and [Unary] expressions
+//!   - [ModifyKind], [BinaryKind], and [UnaryKind] operators
 //! - [Ty] and [TyKind]: Type qualifiers
 //! - [Path]: Path expressions
 use cl_structures::{intern::interned::Interned, span::*};
 
+/// An [Interned] static [str], used in place of an identifier
 pub type Sym = Interned<'static, str>;
 
 /// Whether a binding ([Static] or [Let]) or reference is mutable or not
@@ -388,7 +389,7 @@ pub enum ExprKind {
     Continue(Continue),
 }
 
-/// An [Assign]ment expression: [`Expr`] ([`AssignKind`] [`Expr`])\+
+/// An [Assign]ment expression: [`Expr`] ([`ModifyKind`] [`Expr`])\+
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct Assign {
     pub parts: Box<(ExprKind, ExprKind)>,

compiler/cl-ast/src/lib.rs

@@ -6,7 +6,7 @@
 //! - [Stmt] and [StmtKind]: Statements
 //! - [Expr] and [ExprKind]: Expressions
 //!   - [Assign], [Binary], and [Unary] expressions
-//!   - [AssignKind], [BinaryKind], and [UnaryKind] operators
+//!   - [ModifyKind], [BinaryKind], and [UnaryKind] operators
 //! - [Ty] and [TyKind]: Type qualifiers
 //! - [Path]: Path expressions
 #![warn(clippy::all)]

compiler/cl-parser/src/parser.rs

@@ -756,7 +756,7 @@ macro path_like() {
 }
 /// # Path parsing
 impl<'t> Parser<'t> {
-    /// [PathPart] = `super` | `self` | [Identifier]
+    /// [PathPart] = `super` | `self` | [`Identifier`](TokenKind::Identifier)
     pub fn path_part(&mut self) -> PResult<PathPart> {
         const PARSING: Parsing = Parsing::PathPart;
         let out = match self.peek_kind(PARSING)? {
@@ -981,7 +981,7 @@ impl<'t> Parser<'t> {
         Ok(Structor { to, init })
     }
 
-    /// [Fielder] = [Identifier] (`:` [Expr])?
+    /// [Fielder] = [`Identifier`](TokenKind::Identifier) (`:` [Expr])?
     pub fn fielder(&mut self) -> PResult<Fielder> {
         const PARSING: Parsing = Parsing::Fielder;
         Ok(Fielder {

compiler/cl-structures/src/index_map.rs

@@ -1,4 +1,5 @@
-//! Trivially-copyable, easily comparable typed [indices](MapIndex), and a [Pool] to contain them
+//! Trivially-copyable, easily comparable typed [indices](MapIndex),
+//! and an [IndexMap] to contain them.
 //!
 //! # Examples
 //!
@@ -9,8 +10,8 @@
 //!     NumbersKey
 //! }
 //!
-//! // then, create a pool with that type
-//! let mut numbers: Pool<i32, NumbersKey> = Pool::new();
+//! // then, create a map with that type
+//! let mut numbers: IndexMap<i32, NumbersKey> = IndexMap::new();
 //! let first = numbers.insert(1);
 //! let second = numbers.insert(2);
 //! let third = numbers.insert(3);
@@ -27,7 +28,7 @@
 //! assert_eq!(Some(&100000), numbers.get(first));
 //! ```
 
-/// Creates newtype indices over [`usize`] for use as [Pool] keys.
+/// Creates newtype indices over [`usize`] for use as [IndexMap] keys.
 #[macro_export]
 macro_rules! make_index {($($(#[$meta:meta])* $name:ident),*$(,)?) => {$(
     $(#[$meta])*
@@ -58,24 +59,22 @@ pub use make_index;
 
 use self::iter::MapIndexIter;
 
-/// An index into a [Pool]. For full type-safety,
-/// there should be a unique [InternKey] for each [Pool]
+/// An index into a [IndexMap]. For full type-safety,
+/// there should be a unique [MapIndex] for each [IndexMap].
 pub trait MapIndex: std::fmt::Debug {
     /// Constructs an [`MapIndex`] from a [`usize`] without checking bounds.
     ///
-    /// # Safety
-    ///
     /// The provided value should be within the bounds of its associated container.
     // ID::from_raw_unchecked here isn't *actually* unsafe, since bounds should always be
     // checked, however, the function has unverifiable preconditions.
     fn from_usize(value: usize) -> Self;
-    /// Gets the index of the [`InternKey`] by value
+    /// Gets the index of the [`MapIndex`] by value
     fn get(&self) -> usize;
 }
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct IndexMap<K: MapIndex, V> {
-    pool: Vec<V>,
+    map: Vec<V>,
     id_type: std::marker::PhantomData<K>,
 }
 
@@ -84,48 +83,48 @@ impl<V, K: MapIndex> IndexMap<K, V> {
         Self::default()
     }
     pub fn get(&self, index: K) -> Option<&V> {
-        self.pool.get(index.get())
+        self.map.get(index.get())
     }
     pub fn get_mut(&mut self, index: K) -> Option<&mut V> {
-        self.pool.get_mut(index.get())
+        self.map.get_mut(index.get())
     }
 
     pub fn get_many_mut<const N: usize>(
         &mut self,
         indices: [K; N],
     ) -> Result<[&mut V; N], GetManyMutError<N>> {
-        self.pool.get_many_mut(indices.map(|id| id.get()))
+        self.map.get_many_mut(indices.map(|id| id.get()))
     }
 
     pub fn iter(&self) -> impl Iterator<Item = &V> {
-        self.pool.iter()
+        self.map.iter()
     }
     pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut V> {
-        self.pool.iter_mut()
+        self.map.iter_mut()
     }
     pub fn key_iter(&self) -> iter::MapIndexIter<K> {
-        // Safety: Pool currently has pool.len() entries, and data cannot be removed
-        MapIndexIter::new(0..self.pool.len())
+        // Safety: IndexMap currently has map.len() entries, and data cannot be removed
+        MapIndexIter::new(0..self.map.len())
     }
 
-    /// Constructs an [ID](InternKey) from a [usize], if it's within bounds
+    /// Constructs an [ID](MapIndex) from a [usize], if it's within bounds
     #[doc(hidden)]
     pub fn try_key_from(&self, value: usize) -> Option<K> {
-        (value < self.pool.len()).then(|| K::from_usize(value))
+        (value < self.map.len()).then(|| K::from_usize(value))
     }
 
     pub fn insert(&mut self, value: V) -> K {
-        let id = self.pool.len();
-        self.pool.push(value);
+        let id = self.map.len();
+        self.map.push(value);
 
-        // Safety: value was pushed to `self.pool[id]`
+        // Safety: value was pushed to `self.map[id]`
         K::from_usize(id)
     }
 }
 
 impl<K: MapIndex, V> Default for IndexMap<K, V> {
     fn default() -> Self {
-        Self { pool: vec![], id_type: std::marker::PhantomData }
+        Self { map: vec![], id_type: std::marker::PhantomData }
     }
 }
 
@@ -133,16 +132,16 @@ impl<K: MapIndex, V> Index<K> for IndexMap<K, V> {
     type Output = V;
 
     fn index(&self, index: K) -> &Self::Output {
-        match self.pool.get(index.get()) {
-            None => panic!("Index {:?} out of bounds in pool!", index),
+        match self.map.get(index.get()) {
+            None => panic!("Index {:?} out of bounds in IndexMap!", index),
             Some(value) => value,
         }
     }
 }
 impl<K: MapIndex, V> IndexMut<K> for IndexMap<K, V> {
     fn index_mut(&mut self, index: K) -> &mut Self::Output {
-        match self.pool.get_mut(index.get()) {
-            None => panic!("Index {:?} out of bounds in pool!", index),
+        match self.map.get_mut(index.get()) {
+            None => panic!("Index {:?} out of bounds in IndexMap!", index),
             Some(value) => value,
         }
     }
@@ -153,11 +152,11 @@ mod iter {
 
     use super::MapIndex;
 
-    /// Iterates over the keys of a [Pool](super::Pool) independently of the pool itself.
+    /// Iterates over the keys of an [IndexMap](super::IndexMap), independently of the map.
     ///
-    /// This is guaranteed to never overrun the length of the pool,
-    /// but is *NOT* guaranteed to iterate over all elements of the pool
-    /// if the pool is extended during iteration.
+    /// This is guaranteed to never overrun the length of the map,
+    /// but is *NOT* guaranteed to iterate over all elements of the map
+    /// if the map is extended during iteration.
     #[derive(Clone, Debug, PartialEq, Eq, Hash)]
     pub struct MapIndexIter<K: MapIndex> {
         range: Range<usize>,
@@ -165,12 +164,12 @@ mod iter {
     }
 
     impl<K: MapIndex> MapIndexIter<K> {
-        /// Creates a new [InternKeyIter] producing the given [InternKey]
+        /// Creates a new [MapIndexIter] producing the given [MapIndex]
         ///
         /// # Safety:
-        /// - Range must not exceed bounds of the associated [Pool](super::Pool)
-        /// - Items must not be removed from the pool
-        /// - Items must be contiguous within the pool
+        /// - Range must not exceed bounds of the associated [IndexMap](super::IndexMap)
+        /// - Items must not be removed from the map
+        /// - Items must be contiguous within the map
         pub(super) fn new(range: Range<usize>) -> Self {
             Self { range, _id: Default::default() }
         }
@@ -180,7 +179,7 @@ mod iter {
         type Item = ID;
 
         fn next(&mut self) -> Option<Self::Item> {
-            // Safety: InternKeyIter can only be created by InternKeyIter::new()
+            // Safety: MapIndexIter can only be created by MapIndexIter::new()
             Some(ID::from_usize(self.range.next()?))
         }
         fn size_hint(&self) -> (usize, Option<usize>) {