This is an archive of the discontinued Mercurial Phabricator instance.

Differential D12523

rust: add `Debug` trait to a bunch of structs
Needs ReviewPublic

Authored by Alphare on Tue, Apr 12, 12:04 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Summary

This is useful when... debugging. Right now the output is not in the most
readable state it could be, but this is very low effort and is good enough
for now. We may want to write a nicer custom debug formatter for some of those
structs in the future.

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Revision Contents
Changeset List

Diff 33086

rust/hg-core/src/dirstate_tree/dirstate_map.rs

use crate::PatternFileWarning; use crate::PatternFileWarning;
use crate::StatusError; use crate::StatusError;
use crate::StatusOptions; use crate::StatusOptions;
/// Append to an existing data file if the amount of unreachable data (not used /// Append to an existing data file if the amount of unreachable data (not used
/// anymore) is less than this fraction of the total amount of existing data. /// anymore) is less than this fraction of the total amount of existing data.
const ACCEPTABLE_UNREACHABLE_BYTES_RATIO: f32 = 0.5; const ACCEPTABLE_UNREACHABLE_BYTES_RATIO: f32 = 0.5;
#[derive(Debug)]
pub struct DirstateMap<'on_disk> { pub struct DirstateMap<'on_disk> {
/// Contents of the `.hg/dirstate` file /// Contents of the `.hg/dirstate` file
pub(super) on_disk: &'on_disk [u8], pub(super) on_disk: &'on_disk [u8],
pub(super) root: ChildNodes<'on_disk>, pub(super) root: ChildNodes<'on_disk>,
/// Number of nodes anywhere in the tree that have `.entry.is_some()`. /// Number of nodes anywhere in the tree that have `.entry.is_some()`.
pub(super) nodes_with_entry_count: u32, pub(super) nodes_with_entry_count: u32,
/// map key would also work: all paths in a given map have the same parent /// map key would also work: all paths in a given map have the same parent
/// path, so comparing full paths gives the same result as comparing base /// path, so comparing full paths gives the same result as comparing base
/// names. However `HashMap` would waste time always re-hashing the same /// names. However `HashMap` would waste time always re-hashing the same
/// string prefix. /// string prefix.
pub(super) type NodeKey<'on_disk> = WithBasename<Cow<'on_disk, HgPath>>; pub(super) type NodeKey<'on_disk> = WithBasename<Cow<'on_disk, HgPath>>;
/// Similar to `&'tree Cow<'on_disk, HgPath>`, but can also be returned /// Similar to `&'tree Cow<'on_disk, HgPath>`, but can also be returned
/// for on-disk nodes that don’t actually have a `Cow` to borrow. /// for on-disk nodes that don’t actually have a `Cow` to borrow.
#[derive(Debug)]
pub(super) enum BorrowedPath<'tree, 'on_disk> { pub(super) enum BorrowedPath<'tree, 'on_disk> {
InMemory(&'tree HgPathBuf), InMemory(&'tree HgPathBuf),
OnDisk(&'on_disk HgPath), OnDisk(&'on_disk HgPath),
} }
#[derive(Debug)]
pub(super) enum ChildNodes<'on_disk> { pub(super) enum ChildNodes<'on_disk> {
InMemory(FastHashMap<NodeKey<'on_disk>, Node<'on_disk>>), InMemory(FastHashMap<NodeKey<'on_disk>, Node<'on_disk>>),
OnDisk(&'on_disk [on_disk::Node]), OnDisk(&'on_disk [on_disk::Node]),
} }
#[derive(Debug)]
pub(super) enum ChildNodesRef<'tree, 'on_disk> { pub(super) enum ChildNodesRef<'tree, 'on_disk> {
InMemory(&'tree FastHashMap<NodeKey<'on_disk>, Node<'on_disk>>), InMemory(&'tree FastHashMap<NodeKey<'on_disk>, Node<'on_disk>>),
OnDisk(&'on_disk [on_disk::Node]), OnDisk(&'on_disk [on_disk::Node]),
} }
#[derive(Debug)]
pub(super) enum NodeRef<'tree, 'on_disk> { pub(super) enum NodeRef<'tree, 'on_disk> {
InMemory(&'tree NodeKey<'on_disk>, &'tree Node<'on_disk>), InMemory(&'tree NodeKey<'on_disk>, &'tree Node<'on_disk>),
OnDisk(&'on_disk on_disk::Node), OnDisk(&'on_disk on_disk::Node),
} }
impl<'tree, 'on_disk> BorrowedPath<'tree, 'on_disk> { impl<'tree, 'on_disk> BorrowedPath<'tree, 'on_disk> {
pub fn detach_from_tree(&self) -> Cow<'on_disk, HgPath> { pub fn detach_from_tree(&self) -> Cow<'on_disk, HgPath> {
match *self { match *self {
match self { match self {
NodeRef::InMemory(_path, node) => node.tracked_descendants_count, NodeRef::InMemory(_path, node) => node.tracked_descendants_count,
NodeRef::OnDisk(node) => node.tracked_descendants_count.get(), NodeRef::OnDisk(node) => node.tracked_descendants_count.get(),
} }
} }
} }
/// Represents a file or a directory /// Represents a file or a directory
#[derive(Default)] #[derive(Default, Debug)]
pub(super) struct Node<'on_disk> { pub(super) struct Node<'on_disk> {
pub(super) data: NodeData, pub(super) data: NodeData,
pub(super) copy_source: Option<Cow<'on_disk, HgPath>>, pub(super) copy_source: Option<Cow<'on_disk, HgPath>>,
pub(super) children: ChildNodes<'on_disk>, pub(super) children: ChildNodes<'on_disk>,
/// How many (non-inclusive) descendants of this node have an entry. /// How many (non-inclusive) descendants of this node have an entry.
pub(super) descendants_with_entry_count: u32, pub(super) descendants_with_entry_count: u32,
/// How many (non-inclusive) descendants of this node have an entry whose /// How many (non-inclusive) descendants of this node have an entry whose
/// state is "tracked". /// state is "tracked".
pub(super) tracked_descendants_count: u32, pub(super) tracked_descendants_count: u32,
} }
#[derive(Debug)]
pub(super) enum NodeData { pub(super) enum NodeData {
Entry(DirstateEntry), Entry(DirstateEntry),
CachedDirectory { mtime: TruncatedTimestamp }, CachedDirectory { mtime: TruncatedTimestamp },
None, None,
} }
impl Default for NodeData { impl Default for NodeData {
fn default() -> Self { fn default() -> Self {

rust/hg-core/src/dirstate_tree/on_disk.rs

/// See *Optional hash of ignore patterns* section of /// See *Optional hash of ignore patterns* section of
/// `mercurial/helptext/internals/dirstate-v2.txt` /// `mercurial/helptext/internals/dirstate-v2.txt`
ignore_patterns_hash: IgnorePatternsHash, ignore_patterns_hash: IgnorePatternsHash,
} }
/// Fields are documented in the *The data file format* /// Fields are documented in the *The data file format*
/// section of `mercurial/helptext/internals/dirstate-v2.txt` /// section of `mercurial/helptext/internals/dirstate-v2.txt`
#[derive(BytesCast)] #[derive(BytesCast, Debug)]
#[repr(C)] #[repr(C)]
pub(super) struct Node { pub(super) struct Node {
full_path: PathSlice, full_path: PathSlice,
/// In bytes from `self.full_path.start` /// In bytes from `self.full_path.start`
base_name_start: PathSize, base_name_start: PathSize,
copy_source: OptPathSlice, copy_source: OptPathSlice,
const MTIME_SECOND_AMBIGUOUS = 1 << 12; const MTIME_SECOND_AMBIGUOUS = 1 << 12;
const DIRECTORY = 1 <<13; const DIRECTORY = 1 <<13;
const ALL_UNKNOWN_RECORDED = 1 <<14; const ALL_UNKNOWN_RECORDED = 1 <<14;
const ALL_IGNORED_RECORDED = 1 <<15; const ALL_IGNORED_RECORDED = 1 <<15;
} }
} }
/// Duration since the Unix epoch /// Duration since the Unix epoch
#[derive(BytesCast, Copy, Clone)] #[derive(BytesCast, Copy, Clone, Debug)]
#[repr(C)] #[repr(C)]
struct PackedTruncatedTimestamp { struct PackedTruncatedTimestamp {
truncated_seconds: U32Be, truncated_seconds: U32Be,
nanoseconds: U32Be, nanoseconds: U32Be,
} }
/// Counted in bytes from the start of the file /// Counted in bytes from the start of the file
/// ///
type PathSize = U16Be; type PathSize = U16Be;
/// A contiguous sequence of `len` times `Node`, representing the child nodes /// A contiguous sequence of `len` times `Node`, representing the child nodes
/// of either some other node or of the repository root. /// of either some other node or of the repository root.
/// ///
/// Always sorted by ascending `full_path`, to allow binary search. /// Always sorted by ascending `full_path`, to allow binary search.
/// Since nodes with the same parent nodes also have the same parent path, /// Since nodes with the same parent nodes also have the same parent path,
/// only the `base_name`s need to be compared during binary search. /// only the `base_name`s need to be compared during binary search.
#[derive(BytesCast, Copy, Clone)] #[derive(BytesCast, Copy, Clone, Debug)]
#[repr(C)] #[repr(C)]
struct ChildNodes { struct ChildNodes {
start: Offset, start: Offset,
len: Size, len: Size,
} }
/// A `HgPath` of `len` bytes /// A `HgPath` of `len` bytes
#[derive(BytesCast, Copy, Clone)] #[derive(BytesCast, Copy, Clone, Debug)]
#[repr(C)] #[repr(C)]
struct PathSlice { struct PathSlice {
start: Offset, start: Offset,
len: PathSize, len: PathSize,
} }
/// Either nothing if `start == 0`, or a `HgPath` of `len` bytes /// Either nothing if `start == 0`, or a `HgPath` of `len` bytes
type OptPathSlice = PathSlice; type OptPathSlice = PathSlice;