This is an archive of the discontinued Mercurial Phabricator instance.

Differential D12608

node: manually implement Debug
ClosedPublic

Authored by durin42 on Thu, May 5, 2:51 PM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG34decbaf4da3: node: manually implement Debug
rHG312e01ef6d77: node: manually implement Debug
Summary

I got too irritated today with the default Debug implementation of
hg::revlog::Node while playing with a new parser. This isn't quite
what I wanted, but it wasn't much code and it at least gives you
output that's easy to visually compare to a node.hex()ed identifier
from the Python side of things.

Sadly, this doesn't influence the output in lldb or the VSCode
debugger extension that uses lldb under the covers, but it at least
means debug prints are a little more useful.

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

durin42 created this revision.Thu, May 5, 2:51 PM
Alphare accepted this revision.Mon, May 9, 11:38 AM
This revision is now accepted and ready to land.Mon, May 9, 11:38 AM
durin42 added a commit: rHG312e01ef6d77: node: manually implement Debug.Mon, May 9, 11:53 AM
Closed by commit rHG312e01ef6d77: node: manually implement Debug (authored by durin42). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mrust/hg-core/src/revlog/node.rs (11 lines)

Diff 33383

rust/hg-core/src/revlog/node.rs

/// All other callers outside of unit tests should just handle `Node` values /// All other callers outside of unit tests should just handle `Node` values
/// and never make any assumption on the actual length, using [`nybbles_len`] /// and never make any assumption on the actual length, using [`nybbles_len`]
/// if they need a loop boundary. /// if they need a loop boundary.
/// ///
/// All methods that create a `Node` either take a type that enforces /// All methods that create a `Node` either take a type that enforces
/// the size or return an error at runtime. /// the size or return an error at runtime.
/// ///
/// [`nybbles_len`]: #method.nybbles_len /// [`nybbles_len`]: #method.nybbles_len
#[derive(Copy, Clone, Debug, PartialEq, BytesCast, derive_more::From)] #[derive(Copy, Clone, PartialEq, BytesCast, derive_more::From)]
#[repr(transparent)] #[repr(transparent)]
pub struct Node { pub struct Node {
data: NodeData, data: NodeData,
} }
impl fmt::Debug for Node {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let n = format!("{:x?}", self.data);
// We're using debug_tuple because it makes the output a little
// more compact without losing data.
f.debug_tuple("Node").field(&n).finish()
}
}
/// The node value for NULL_REVISION /// The node value for NULL_REVISION
pub const NULL_NODE: Node = Node { pub const NULL_NODE: Node = Node {
data: [0; NODE_BYTES_LENGTH], data: [0; NODE_BYTES_LENGTH],
}; };
/// Return an error if the slice has an unexpected length /// Return an error if the slice has an unexpected length
impl<'a> TryFrom<&'a [u8]> for &'a Node { impl<'a> TryFrom<&'a [u8]> for &'a Node {
type Error = (); type Error = ();