This is an archive of the discontinued Mercurial Phabricator instance.

Differential D12477

rust: add `Debug` trait to a bunch of structs
ClosedPublic

Authored by Alphare on Apr 6 2022, 10:13 AM.

Details

Reviewers
marmoute
Group Reviewers
hg-reviewers
Commits
rHG0ef1ef20e951: rust: add `Debug` trait to a bunch of structs
rHG2f58e707e452: rust: add `Debug` trait to a bunch of structs
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
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

Alphare created this revision.Apr 6 2022, 10:13 AM
marmoute accepted this revision.Apr 8 2022, 7:38 AM
Alphare added a commit: rHG2f58e707e452: rust: add `Debug` trait to a bunch of structs.Apr 8 2022, 11:57 AM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHG2f58e707e452: rust: add `Debug` trait to a bunch of structs (authored by Alphare). · Explain Why
This revision was automatically updated to reflect the committed changes.
baymax updated this revision to Diff 32949.Apr 8 2022, 12:30 PM

✅ refresh by Heptapod after a successful CI run (🐙 💚)

baymax updated this revision to Diff 33051.Apr 12 2022, 11:05 AM

✅ refresh by Heptapod after a successful CI run (🐙 💚)

baymax updated this revision to Diff 33133.Apr 12 2022, 12:09 PM

✅ refresh by Heptapod after a successful CI run (🐙 💚)

Revision Contents
Changeset List

Diff 32914

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;