newtype wrappers for lane index and alias id

Author: philocalyst

asyncgit/src/graph/buffer.rs

@@ -1,4 +1,5 @@
 use super::chunk::{Chunk, Markers};
+use super::AliasId;
 use std::collections::BTreeMap;
 
 /// A single mutation of the lane state, recorded while processing one
@@ -39,7 +40,7 @@ pub struct Buffer {
 
 	/// Aliases of merge commits whose second parent still needs a new
 	/// lane.
-	merge_commits: Vec<usize>,
+	merge_commits: Vec<AliasId>,
 
 	/// Scratch list of the [`DeltaOp`]s recorded for processing commit
 	pending_delta: Vec<DeltaOp>,
@@ -64,7 +65,7 @@ impl Buffer {
 
 	/// Remember `alias` as a merge commit whose second parent must be
 	/// given its own lane.
-	pub fn track_merge_commit(&mut self, alias: usize) {
+	pub fn track_merge_commit(&mut self, alias: AliasId) {
 		self.merge_commits.push(alias);
 	}
 
@@ -104,7 +105,7 @@ impl Buffer {
 
 	fn find_lane_awaiting_parent(
 		&self,
-		alias: Option<usize>,
+		alias: Option<AliasId>,
 	) -> Option<usize> {
 		let alias = alias?;
 		self.current.iter().position(|slot| {
@@ -119,7 +120,7 @@ impl Buffer {
 
 	fn consume_alias_in_other_chunks(
 		&mut self,
-		alias: usize,
+		alias: AliasId,
 		skip_index: usize,
 	) {
 		for index in 0..self.current.len() {

asyncgit/src/graph/chunk.rs

@@ -1,3 +1,5 @@
+use super::AliasId;
+
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum Markers {
 	Uncommitted,
@@ -6,8 +8,8 @@ pub enum Markers {
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct Chunk {
-	pub alias: Option<usize>,
-	pub parent_a: Option<usize>,
-	pub parent_b: Option<usize>,
+	pub alias: Option<AliasId>,
+	pub parent_a: Option<AliasId>,
+	pub parent_b: Option<AliasId>,
 	pub marker: Markers,
 }

asyncgit/src/graph/mod.rs

@@ -11,13 +11,39 @@ pub const MAX_LANE_COLORS: usize = 16;
 // Yes, there are repositories where this is exceeded
 // Are they very rare? Yes.
 // On most terminals can more than 256 lanes even be represneted usefully? Not really.
-pub type LaneIdx = u8;
+#[derive(Clone, Copy, Debug, Default)]
+pub struct LaneIndex(u8);
 
-/// Convert a lane position into the compact [`LaneIdx`]
-/// representation. This way we can keep full granularity when computing,
-/// but not when storing.
-pub(crate) fn to_lane_idx(lane: usize) -> LaneIdx {
-	LaneIdx::try_from(lane).unwrap_or(LaneIdx::MAX)
+/// Numeric alias assigned to each commit in the graph.
+///
+/// The alias is a dense integer index created by [`GraphOids`](super::oids::GraphOids)
+/// that avoids storing full [`CommitId`](crate::sync::CommitId)s inside the lane state.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
+pub struct AliasId(usize);
+
+impl std::ops::Deref for AliasId {
+	type Target = usize;
+	fn deref(&self) -> &usize {
+		&self.0
+	}
+}
+
+impl From<usize> for AliasId {
+	fn from(v: usize) -> Self {
+		Self(v)
+	}
+}
+
+impl From<usize> for LaneIndex {
+	fn from(lane: usize) -> Self {
+		Self(u8::try_from(lane).unwrap_or(u8::MAX))
+	}
+}
+
+impl From<LaneIndex> for usize {
+	fn from(lane: LaneIndex) -> Self {
+		lane.0 as usize
+	}
 }
 
 /// The type of connection between nodes in the graph.
@@ -53,10 +79,10 @@ pub enum ConnectionType {
 #[derive(Clone, Debug, Default)]
 pub struct GraphRow {
 	/// Number of active lanes at this commit row
-	pub lane_count: LaneIdx,
+	pub lane_count: LaneIndex,
 
 	/// Which lane index this commit sits on
-	pub commit_lane: LaneIdx,
+	pub commit_lane: LaneIndex,
 
 	/// Whether this is a merge commit (two parents)
 	pub is_merge: bool,
@@ -70,13 +96,13 @@ pub struct GraphRow {
 	/// Connections emitted per lane:
 	/// None = empty space
 	/// Some((ConnectionType, `color_index`)) = draw this connector in this color
-	pub lanes: Vec<Option<(ConnectionType, LaneIdx)>>,
+	pub lanes: Vec<Option<(ConnectionType, LaneIndex)>>,
 
 	/// Horizontal merge bridge: if this commit merges rightward,
 	/// (`from_lane`, `to_lane`) — the span to draw ─ ╭ ╮ across
-	pub merge_bridge: Option<(LaneIdx, LaneIdx)>,
+	pub merge_bridge: Option<(LaneIndex, LaneIndex)>,
 
 	/// Horizontal branch bridges: if this commit spawns branches,
 	/// spans to draw ─ ╭ ╮ across
-	pub branches: Vec<(LaneIdx, LaneIdx)>,
+	pub branches: Vec<(LaneIndex, LaneIndex)>,
 }

asyncgit/src/graph/oids.rs

@@ -1,8 +1,9 @@
+use super::AliasId;
 use crate::sync::CommitId;
 use std::collections::HashMap;
 
 /// mapping of `CommitId` to a numeric alias
-pub struct GraphOids(HashMap<CommitId, usize>);
+pub struct GraphOids(HashMap<CommitId, AliasId>);
 
 impl Default for GraphOids {
 	fn default() -> Self {
@@ -17,18 +18,18 @@ impl GraphOids {
 	}
 
 	/// Get the alias for `id`, assigning a new one if it doesn't exist yet.
-	pub fn get_or_insert(&mut self, id: &CommitId) -> usize {
+	pub fn get_or_insert(&mut self, id: &CommitId) -> AliasId {
 		if let Some(&alias) = self.0.get(id) {
 			return alias;
 		}
 
-		let alias = self.0.len();
+		let alias = AliasId::from(self.0.len());
 		self.0.insert(*id, alias);
 		alias
 	}
 
 	/// Look up the alias for `id`, returning `None` if not found.
-	pub fn get(&self, id: &CommitId) -> Option<usize> {
+	pub fn get(&self, id: &CommitId) -> Option<AliasId> {
 		self.0.get(id).copied()
 	}
 }

asyncgit/src/graph/walker.rs

@@ -1,15 +1,13 @@
 use super::buffer::Buffer;
 use super::chunk::{Chunk, Markers};
 use super::oids::GraphOids;
-use super::{
-	to_lane_idx, ConnectionType, GraphRow, LaneIdx, MAX_LANE_COLORS,
-};
+use super::{AliasId, ConnectionType, GraphRow, LaneIndex, MAX_LANE_COLORS};
 use crate::sync::CommitId;
 use std::collections::{HashMap, HashSet};
 
 /// Get the lanes color index, which cycles through the ste palette.
-fn lane_color(lane: usize) -> LaneIdx {
-	to_lane_idx(lane % MAX_LANE_COLORS)
+fn lane_color(lane: usize) -> LaneIndex {
+	LaneIndex::from(lane % MAX_LANE_COLORS)
 }
 
 use bitflags::bitflags;
@@ -103,9 +101,9 @@ const fn dirs_conn(dirs: Dirs, dotted: bool) -> ConnectionType {
 /// The line with a vertical component is the chosen way with color
 /// ensuring lanes stay visually continuous
 fn overlay_cell(
-	cell: &mut Option<(ConnectionType, LaneIdx)>,
+	cell: &mut Option<(ConnectionType, LaneIndex)>,
 	add: Dirs,
-	color: LaneIdx,
+	color: LaneIndex,
 ) {
 	if let Some((conn, existing_color)) = cell {
 		if let Some(existing) = conn_dirs(*conn) {
@@ -135,7 +133,7 @@ pub struct GraphWalker {
 	pub branch_lane_map: HashMap<CommitId, usize>,
 
 	/// Maps a merge commit's alias to the alias of its second parent.
-	pub merge_parents: HashMap<usize, usize>,
+	pub merge_parents: HashMap<AliasId, AliasId>,
 }
 
 impl Default for GraphWalker {
@@ -236,7 +234,7 @@ impl GraphWalker {
 	}
 
 	fn draw_merge_bridge(
-		lanes: &mut [Option<(ConnectionType, LaneIdx)>],
+		lanes: &mut [Option<(ConnectionType, LaneIndex)>],
 		merge_bridge: Option<(usize, usize)>,
 		commit_lane: usize,
 		current: &[Option<Chunk>],
@@ -287,15 +285,15 @@ impl GraphWalker {
 	}
 
 	fn draw_branching_lanes(
-		lanes: &mut Vec<Option<(ConnectionType, LaneIdx)>>,
+		lanes: &mut Vec<Option<(ConnectionType, LaneIndex)>>,
 		branching_lanes: &[usize],
 		commit_lane: usize,
-	) -> Vec<(LaneIdx, LaneIdx)> {
+	) -> Vec<(LaneIndex, LaneIndex)> {
 		let mut branches = Vec::new();
 		for &branch_lane in branching_lanes {
 			let from = std::cmp::min(branch_lane, commit_lane);
 			let to = std::cmp::max(branch_lane, commit_lane);
-			branches.push((to_lane_idx(from), to_lane_idx(to)));
+			branches.push((LaneIndex::from(from), LaneIndex::from(to)));
 
 			if lanes.len() <= to {
 				lanes.resize(to + 1, None);
@@ -403,24 +401,24 @@ impl GraphWalker {
 		);
 
 		GraphRow {
-			lane_count: to_lane_idx(current.iter().flatten().count()),
-			commit_lane: to_lane_idx(commit_lane),
+			lane_count: LaneIndex::from(current.iter().flatten().count()),
+			commit_lane: LaneIndex::from(commit_lane),
 			is_merge,
 			is_branch_tip,
 			is_stash,
 			lanes,
 			merge_bridge: merge_bridge
-				.map(|(f, t)| (to_lane_idx(f), to_lane_idx(t))),
+				.map(|(f, t)| (LaneIndex::from(f), LaneIndex::from(t))),
 			branches,
 		}
 	}
 
 	#[allow(clippy::too_many_arguments)]
 	fn fill_lanes(
 		&self,
-		lanes: &mut [Option<(ConnectionType, LaneIdx)>],
+		lanes: &mut [Option<(ConnectionType, LaneIndex)>],
 		curr: &[Option<Chunk>],
-		alias: Option<usize>,
+		alias: Option<AliasId>,
 		head_id: Option<&CommitId>,
 		is_stash: bool,
 		is_merge: bool,
@@ -473,10 +471,10 @@ impl GraphWalker {
 	/// between its two ends, merging with whatever each cell already
 	/// shows.
 	fn draw_bridge_span(
-		lanes: &mut [Option<(ConnectionType, LaneIdx)>],
+		lanes: &mut [Option<(ConnectionType, LaneIndex)>],
 		from: usize,
 		to: usize,
-		color: LaneIdx,
+		color: LaneIndex,
 	) {
 		for lane in lanes.iter_mut().take(to).skip(from + 1) {
 			overlay_cell(lane, Dirs::LEFT | Dirs::RIGHT, color);