rust-clippy: merge "revlog" module definition and struct implementation
authorRaphaël Gomès <rgomes@octobus.net>
Tue, 10 Jan 2023 11:20:54 +0100
changeset 49937 750409505286
parent 49936 2cd8352f7e11
child 49938 e3274e02d08e
rust-clippy: merge "revlog" module definition and struct implementation Module inception is confusing when looking for code and almost never the right choice.
rust/hg-core/src/copy_tracing/tests.rs
rust/hg-core/src/operations/cat.rs
rust/hg-core/src/operations/debugdata.rs
rust/hg-core/src/operations/list_tracked_files.rs
rust/hg-core/src/repo.rs
rust/hg-core/src/revlog.rs
rust/hg-core/src/revlog/changelog.rs
rust/hg-core/src/revlog/filelog.rs
rust/hg-core/src/revlog/manifest.rs
rust/hg-core/src/revlog/mod.rs
rust/hg-core/src/revlog/revlog.rs
rust/hg-core/src/revset.rs
rust/rhg/src/error.rs
--- a/rust/hg-core/src/copy_tracing/tests.rs	Tue Jan 10 10:57:15 2023 +0100
+++ b/rust/hg-core/src/copy_tracing/tests.rs	Tue Jan 10 11:20:54 2023 +0100
@@ -118,7 +118,7 @@
     // keys to copy source values. Note: the arrows for map literal syntax
     // point **backwards** compared to the logical direction of copy!
 
-    use crate::NULL_REVISION as NULL;
+    use crate::revlog::NULL_REVISION as NULL;
     use Action::*;
     use MergeCase::*;
 
--- a/rust/hg-core/src/operations/cat.rs	Tue Jan 10 10:57:15 2023 +0100
+++ b/rust/hg-core/src/operations/cat.rs	Tue Jan 10 11:20:54 2023 +0100
@@ -6,8 +6,8 @@
 // GNU General Public License version 2 or any later version.
 
 use crate::repo::Repo;
-use crate::revlog::revlog::RevlogError;
 use crate::revlog::Node;
+use crate::revlog::RevlogError;
 
 use crate::utils::hg_path::HgPath;
 
--- a/rust/hg-core/src/operations/debugdata.rs	Tue Jan 10 10:57:15 2023 +0100
+++ b/rust/hg-core/src/operations/debugdata.rs	Tue Jan 10 11:20:54 2023 +0100
@@ -7,7 +7,7 @@
 
 use crate::repo::Repo;
 use crate::requirements;
-use crate::revlog::revlog::{Revlog, RevlogError};
+use crate::revlog::{Revlog, RevlogError};
 
 /// Kind of data to debug
 #[derive(Debug, Copy, Clone)]
--- a/rust/hg-core/src/operations/list_tracked_files.rs	Tue Jan 10 10:57:15 2023 +0100
+++ b/rust/hg-core/src/operations/list_tracked_files.rs	Tue Jan 10 11:20:54 2023 +0100
@@ -10,7 +10,7 @@
 use crate::errors::HgError;
 use crate::repo::Repo;
 use crate::revlog::manifest::Manifest;
-use crate::revlog::revlog::RevlogError;
+use crate::revlog::RevlogError;
 use crate::utils::hg_path::HgPath;
 use crate::DirstateError;
 use rayon::prelude::*;
--- a/rust/hg-core/src/repo.rs	Tue Jan 10 10:57:15 2023 +0100
+++ b/rust/hg-core/src/repo.rs	Tue Jan 10 11:20:54 2023 +0100
@@ -8,7 +8,7 @@
 use crate::lock::{try_with_lock_no_wait, LockError};
 use crate::manifest::{Manifest, Manifestlog};
 use crate::revlog::filelog::Filelog;
-use crate::revlog::revlog::RevlogError;
+use crate::revlog::RevlogError;
 use crate::utils::files::get_path_from_bytes;
 use crate::utils::hg_path::HgPath;
 use crate::utils::SliceExt;
--- a/rust/hg-core/src/revlog.rs	Tue Jan 10 10:57:15 2023 +0100
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,72 +0,0 @@
-// Copyright 2018-2020 Georges Racinet <georges.racinet@octobus.net>
-//           and Mercurial contributors
-//
-// This software may be used and distributed according to the terms of the
-// GNU General Public License version 2 or any later version.
-//! Mercurial concepts for handling revision history
-
-pub mod node;
-pub mod nodemap;
-mod nodemap_docket;
-pub mod path_encode;
-pub use node::{FromHexError, Node, NodePrefix};
-pub mod changelog;
-pub mod filelog;
-pub mod index;
-pub mod manifest;
-pub mod patch;
-pub mod revlog;
-
-/// Mercurial revision numbers
-///
-/// As noted in revlog.c, revision numbers are actually encoded in
-/// 4 bytes, and are liberally converted to ints, whence the i32
-pub type Revision = i32;
-
-/// Marker expressing the absence of a parent
-///
-/// Independently of the actual representation, `NULL_REVISION` is guaranteed
-/// to be smaller than all existing revisions.
-pub const NULL_REVISION: Revision = -1;
-
-/// Same as `mercurial.node.wdirrev`
-///
-/// This is also equal to `i32::max_value()`, but it's better to spell
-/// it out explicitely, same as in `mercurial.node`
-#[allow(clippy::unreadable_literal)]
-pub const WORKING_DIRECTORY_REVISION: Revision = 0x7fffffff;
-
-pub const WORKING_DIRECTORY_HEX: &str =
-    "ffffffffffffffffffffffffffffffffffffffff";
-
-/// The simplest expression of what we need of Mercurial DAGs.
-pub trait Graph {
-    /// Return the two parents of the given `Revision`.
-    ///
-    /// Each of the parents can be independently `NULL_REVISION`
-    fn parents(&self, rev: Revision) -> Result<[Revision; 2], GraphError>;
-}
-
-#[derive(Clone, Debug, PartialEq)]
-pub enum GraphError {
-    ParentOutOfRange(Revision),
-    WorkingDirectoryUnsupported,
-}
-
-/// The Mercurial Revlog Index
-///
-/// This is currently limited to the minimal interface that is needed for
-/// the [`nodemap`](nodemap/index.html) module
-pub trait RevlogIndex {
-    /// Total number of Revisions referenced in this index
-    fn len(&self) -> usize;
-
-    fn is_empty(&self) -> bool {
-        self.len() == 0
-    }
-
-    /// Return a reference to the Node or `None` if rev is out of bounds
-    ///
-    /// `NULL_REVISION` is not considered to be out of bounds.
-    fn node(&self, rev: Revision) -> Option<&Node>;
-}
--- a/rust/hg-core/src/revlog/changelog.rs	Tue Jan 10 10:57:15 2023 +0100
+++ b/rust/hg-core/src/revlog/changelog.rs	Tue Jan 10 11:20:54 2023 +0100
@@ -1,7 +1,7 @@
 use crate::errors::HgError;
-use crate::revlog::revlog::{Revlog, RevlogEntry, RevlogError};
 use crate::revlog::Revision;
 use crate::revlog::{Node, NodePrefix};
+use crate::revlog::{Revlog, RevlogEntry, RevlogError};
 use crate::utils::hg_path::HgPath;
 use crate::vfs::Vfs;
 use itertools::Itertools;
--- a/rust/hg-core/src/revlog/filelog.rs	Tue Jan 10 10:57:15 2023 +0100
+++ b/rust/hg-core/src/revlog/filelog.rs	Tue Jan 10 11:20:54 2023 +0100
@@ -1,10 +1,10 @@
 use crate::errors::HgError;
 use crate::repo::Repo;
 use crate::revlog::path_encode::path_encode;
-use crate::revlog::revlog::RevlogEntry;
-use crate::revlog::revlog::{Revlog, RevlogError};
 use crate::revlog::NodePrefix;
 use crate::revlog::Revision;
+use crate::revlog::RevlogEntry;
+use crate::revlog::{Revlog, RevlogError};
 use crate::utils::files::get_path_from_bytes;
 use crate::utils::hg_path::HgPath;
 use crate::utils::SliceExt;
--- a/rust/hg-core/src/revlog/manifest.rs	Tue Jan 10 10:57:15 2023 +0100
+++ b/rust/hg-core/src/revlog/manifest.rs	Tue Jan 10 11:20:54 2023 +0100
@@ -1,7 +1,7 @@
 use crate::errors::HgError;
-use crate::revlog::revlog::{Revlog, RevlogError};
 use crate::revlog::Revision;
 use crate::revlog::{Node, NodePrefix};
+use crate::revlog::{Revlog, RevlogError};
 use crate::utils::hg_path::HgPath;
 use crate::utils::SliceExt;
 use crate::vfs::Vfs;
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/rust/hg-core/src/revlog/mod.rs	Tue Jan 10 11:20:54 2023 +0100
@@ -0,0 +1,710 @@
+// Copyright 2018-2023 Georges Racinet <georges.racinet@octobus.net>
+//           and Mercurial contributors
+//
+// This software may be used and distributed according to the terms of the
+// GNU General Public License version 2 or any later version.
+//! Mercurial concepts for handling revision history
+
+pub mod node;
+pub mod nodemap;
+mod nodemap_docket;
+pub mod path_encode;
+pub use node::{FromHexError, Node, NodePrefix};
+pub mod changelog;
+pub mod filelog;
+pub mod index;
+pub mod manifest;
+pub mod patch;
+
+use std::borrow::Cow;
+use std::io::Read;
+use std::ops::Deref;
+use std::path::Path;
+
+use flate2::read::ZlibDecoder;
+use sha1::{Digest, Sha1};
+use zstd;
+
+use self::node::{NODE_BYTES_LENGTH, NULL_NODE};
+use self::nodemap_docket::NodeMapDocket;
+use super::index::Index;
+use super::nodemap::{NodeMap, NodeMapError};
+use crate::errors::HgError;
+use crate::vfs::Vfs;
+
+/// Mercurial revision numbers
+///
+/// As noted in revlog.c, revision numbers are actually encoded in
+/// 4 bytes, and are liberally converted to ints, whence the i32
+pub type Revision = i32;
+
+/// Marker expressing the absence of a parent
+///
+/// Independently of the actual representation, `NULL_REVISION` is guaranteed
+/// to be smaller than all existing revisions.
+pub const NULL_REVISION: Revision = -1;
+
+/// Same as `mercurial.node.wdirrev`
+///
+/// This is also equal to `i32::max_value()`, but it's better to spell
+/// it out explicitely, same as in `mercurial.node`
+#[allow(clippy::unreadable_literal)]
+pub const WORKING_DIRECTORY_REVISION: Revision = 0x7fffffff;
+
+pub const WORKING_DIRECTORY_HEX: &str =
+    "ffffffffffffffffffffffffffffffffffffffff";
+
+/// The simplest expression of what we need of Mercurial DAGs.
+pub trait Graph {
+    /// Return the two parents of the given `Revision`.
+    ///
+    /// Each of the parents can be independently `NULL_REVISION`
+    fn parents(&self, rev: Revision) -> Result<[Revision; 2], GraphError>;
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub enum GraphError {
+    ParentOutOfRange(Revision),
+    WorkingDirectoryUnsupported,
+}
+
+/// The Mercurial Revlog Index
+///
+/// This is currently limited to the minimal interface that is needed for
+/// the [`nodemap`](nodemap/index.html) module
+pub trait RevlogIndex {
+    /// Total number of Revisions referenced in this index
+    fn len(&self) -> usize;
+
+    fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    /// Return a reference to the Node or `None` if rev is out of bounds
+    ///
+    /// `NULL_REVISION` is not considered to be out of bounds.
+    fn node(&self, rev: Revision) -> Option<&Node>;
+}
+
+const REVISION_FLAG_CENSORED: u16 = 1 << 15;
+const REVISION_FLAG_ELLIPSIS: u16 = 1 << 14;
+const REVISION_FLAG_EXTSTORED: u16 = 1 << 13;
+const REVISION_FLAG_HASCOPIESINFO: u16 = 1 << 12;
+
+// Keep this in sync with REVIDX_KNOWN_FLAGS in
+// mercurial/revlogutils/flagutil.py
+const REVIDX_KNOWN_FLAGS: u16 = REVISION_FLAG_CENSORED
+    | REVISION_FLAG_ELLIPSIS
+    | REVISION_FLAG_EXTSTORED
+    | REVISION_FLAG_HASCOPIESINFO;
+
+const NULL_REVLOG_ENTRY_FLAGS: u16 = 0;
+
+#[derive(Debug, derive_more::From)]
+pub enum RevlogError {
+    InvalidRevision,
+    /// Working directory is not supported
+    WDirUnsupported,
+    /// Found more than one entry whose ID match the requested prefix
+    AmbiguousPrefix,
+    #[from]
+    Other(HgError),
+}
+
+impl From<NodeMapError> for RevlogError {
+    fn from(error: NodeMapError) -> Self {
+        match error {
+            NodeMapError::MultipleResults => RevlogError::AmbiguousPrefix,
+            NodeMapError::RevisionNotInIndex(rev) => RevlogError::corrupted(
+                format!("nodemap point to revision {} not in index", rev),
+            ),
+        }
+    }
+}
+
+fn corrupted<S: AsRef<str>>(context: S) -> HgError {
+    HgError::corrupted(format!("corrupted revlog, {}", context.as_ref()))
+}
+
+impl RevlogError {
+    fn corrupted<S: AsRef<str>>(context: S) -> Self {
+        RevlogError::Other(corrupted(context))
+    }
+}
+
+/// Read only implementation of revlog.
+pub struct Revlog {
+    /// When index and data are not interleaved: bytes of the revlog index.
+    /// When index and data are interleaved: bytes of the revlog index and
+    /// data.
+    index: Index,
+    /// When index and data are not interleaved: bytes of the revlog data
+    data_bytes: Option<Box<dyn Deref<Target = [u8]> + Send>>,
+    /// When present on disk: the persistent nodemap for this revlog
+    nodemap: Option<nodemap::NodeTree>,
+}
+
+impl Revlog {
+    /// Open a revlog index file.
+    ///
+    /// It will also open the associated data file if index and data are not
+    /// interleaved.
+    pub fn open(
+        store_vfs: &Vfs,
+        index_path: impl AsRef<Path>,
+        data_path: Option<&Path>,
+        use_nodemap: bool,
+    ) -> Result<Self, HgError> {
+        let index_path = index_path.as_ref();
+        let index = {
+            match store_vfs.mmap_open_opt(&index_path)? {
+                None => Index::new(Box::new(vec![])),
+                Some(index_mmap) => {
+                    let index = Index::new(Box::new(index_mmap))?;
+                    Ok(index)
+                }
+            }
+        }?;
+
+        let default_data_path = index_path.with_extension("d");
+
+        // type annotation required
+        // won't recognize Mmap as Deref<Target = [u8]>
+        let data_bytes: Option<Box<dyn Deref<Target = [u8]> + Send>> =
+            if index.is_inline() {
+                None
+            } else {
+                let data_path = data_path.unwrap_or(&default_data_path);
+                let data_mmap = store_vfs.mmap_open(data_path)?;
+                Some(Box::new(data_mmap))
+            };
+
+        let nodemap = if index.is_inline() || !use_nodemap {
+            None
+        } else {
+            NodeMapDocket::read_from_file(store_vfs, index_path)?.map(
+                |(docket, data)| {
+                    nodemap::NodeTree::load_bytes(
+                        Box::new(data),
+                        docket.data_length,
+                    )
+                },
+            )
+        };
+
+        Ok(Revlog {
+            index,
+            data_bytes,
+            nodemap,
+        })
+    }
+
+    /// Return number of entries of the `Revlog`.
+    pub fn len(&self) -> usize {
+        self.index.len()
+    }
+
+    /// Returns `true` if the `Revlog` has zero `entries`.
+    pub fn is_empty(&self) -> bool {
+        self.index.is_empty()
+    }
+
+    /// Returns the node ID for the given revision number, if it exists in this
+    /// revlog
+    pub fn node_from_rev(&self, rev: Revision) -> Option<&Node> {
+        if rev == NULL_REVISION {
+            return Some(&NULL_NODE);
+        }
+        Some(self.index.get_entry(rev)?.hash())
+    }
+
+    /// Return the revision number for the given node ID, if it exists in this
+    /// revlog
+    pub fn rev_from_node(
+        &self,
+        node: NodePrefix,
+    ) -> Result<Revision, RevlogError> {
+        if node.is_prefix_of(&NULL_NODE) {
+            return Ok(NULL_REVISION);
+        }
+
+        if let Some(nodemap) = &self.nodemap {
+            return nodemap
+                .find_bin(&self.index, node)?
+                .ok_or(RevlogError::InvalidRevision);
+        }
+
+        // Fallback to linear scan when a persistent nodemap is not present.
+        // This happens when the persistent-nodemap experimental feature is not
+        // enabled, or for small revlogs.
+        //
+        // TODO: consider building a non-persistent nodemap in memory to
+        // optimize these cases.
+        let mut found_by_prefix = None;
+        for rev in (0..self.len() as Revision).rev() {
+            let index_entry = self.index.get_entry(rev).ok_or_else(|| {
+                HgError::corrupted(
+                    "revlog references a revision not in the index",
+                )
+            })?;
+            if node == *index_entry.hash() {
+                return Ok(rev);
+            }
+            if node.is_prefix_of(index_entry.hash()) {
+                if found_by_prefix.is_some() {
+                    return Err(RevlogError::AmbiguousPrefix);
+                }
+                found_by_prefix = Some(rev)
+            }
+        }
+        found_by_prefix.ok_or(RevlogError::InvalidRevision)
+    }
+
+    /// Returns whether the given revision exists in this revlog.
+    pub fn has_rev(&self, rev: Revision) -> bool {
+        self.index.get_entry(rev).is_some()
+    }
+
+    /// Return the full data associated to a revision.
+    ///
+    /// All entries required to build the final data out of deltas will be
+    /// retrieved as needed, and the deltas will be applied to the inital
+    /// snapshot to rebuild the final data.
+    pub fn get_rev_data(
+        &self,
+        rev: Revision,
+    ) -> Result<Cow<[u8]>, RevlogError> {
+        if rev == NULL_REVISION {
+            return Ok(Cow::Borrowed(&[]));
+        };
+        Ok(self.get_entry(rev)?.data()?)
+    }
+
+    /// Check the hash of some given data against the recorded hash.
+    pub fn check_hash(
+        &self,
+        p1: Revision,
+        p2: Revision,
+        expected: &[u8],
+        data: &[u8],
+    ) -> bool {
+        let e1 = self.index.get_entry(p1);
+        let h1 = match e1 {
+            Some(ref entry) => entry.hash(),
+            None => &NULL_NODE,
+        };
+        let e2 = self.index.get_entry(p2);
+        let h2 = match e2 {
+            Some(ref entry) => entry.hash(),
+            None => &NULL_NODE,
+        };
+
+        hash(data, h1.as_bytes(), h2.as_bytes()) == expected
+    }
+
+    /// Build the full data of a revision out its snapshot
+    /// and its deltas.
+    fn build_data_from_deltas(
+        snapshot: RevlogEntry,
+        deltas: &[RevlogEntry],
+    ) -> Result<Vec<u8>, HgError> {
+        let snapshot = snapshot.data_chunk()?;
+        let deltas = deltas
+            .iter()
+            .rev()
+            .map(RevlogEntry::data_chunk)
+            .collect::<Result<Vec<_>, _>>()?;
+        let patches: Vec<_> =
+            deltas.iter().map(|d| patch::PatchList::new(d)).collect();
+        let patch = patch::fold_patch_lists(&patches);
+        Ok(patch.apply(&snapshot))
+    }
+
+    /// Return the revlog data.
+    fn data(&self) -> &[u8] {
+        match &self.data_bytes {
+            Some(data_bytes) => data_bytes,
+            None => panic!(
+                "forgot to load the data or trying to access inline data"
+            ),
+        }
+    }
+
+    pub fn make_null_entry(&self) -> RevlogEntry {
+        RevlogEntry {
+            revlog: self,
+            rev: NULL_REVISION,
+            bytes: b"",
+            compressed_len: 0,
+            uncompressed_len: 0,
+            base_rev_or_base_of_delta_chain: None,
+            p1: NULL_REVISION,
+            p2: NULL_REVISION,
+            flags: NULL_REVLOG_ENTRY_FLAGS,
+            hash: NULL_NODE,
+        }
+    }
+
+    /// Get an entry of the revlog.
+    pub fn get_entry(
+        &self,
+        rev: Revision,
+    ) -> Result<RevlogEntry, RevlogError> {
+        if rev == NULL_REVISION {
+            return Ok(self.make_null_entry());
+        }
+        let index_entry = self
+            .index
+            .get_entry(rev)
+            .ok_or(RevlogError::InvalidRevision)?;
+        let start = index_entry.offset();
+        let end = start + index_entry.compressed_len() as usize;
+        let data = if self.index.is_inline() {
+            self.index.data(start, end)
+        } else {
+            &self.data()[start..end]
+        };
+        let entry = RevlogEntry {
+            revlog: self,
+            rev,
+            bytes: data,
+            compressed_len: index_entry.compressed_len(),
+            uncompressed_len: index_entry.uncompressed_len(),
+            base_rev_or_base_of_delta_chain: if index_entry
+                .base_revision_or_base_of_delta_chain()
+                == rev
+            {
+                None
+            } else {
+                Some(index_entry.base_revision_or_base_of_delta_chain())
+            },
+            p1: index_entry.p1(),
+            p2: index_entry.p2(),
+            flags: index_entry.flags(),
+            hash: *index_entry.hash(),
+        };
+        Ok(entry)
+    }
+
+    /// when resolving internal references within revlog, any errors
+    /// should be reported as corruption, instead of e.g. "invalid revision"
+    fn get_entry_internal(
+        &self,
+        rev: Revision,
+    ) -> Result<RevlogEntry, HgError> {
+        self.get_entry(rev)
+            .map_err(|_| corrupted(format!("revision {} out of range", rev)))
+    }
+}
+
+/// The revlog entry's bytes and the necessary informations to extract
+/// the entry's data.
+#[derive(Clone)]
+pub struct RevlogEntry<'a> {
+    revlog: &'a Revlog,
+    rev: Revision,
+    bytes: &'a [u8],
+    compressed_len: u32,
+    uncompressed_len: i32,
+    base_rev_or_base_of_delta_chain: Option<Revision>,
+    p1: Revision,
+    p2: Revision,
+    flags: u16,
+    hash: Node,
+}
+
+impl<'a> RevlogEntry<'a> {
+    pub fn revision(&self) -> Revision {
+        self.rev
+    }
+
+    pub fn node(&self) -> &Node {
+        &self.hash
+    }
+
+    pub fn uncompressed_len(&self) -> Option<u32> {
+        u32::try_from(self.uncompressed_len).ok()
+    }
+
+    pub fn has_p1(&self) -> bool {
+        self.p1 != NULL_REVISION
+    }
+
+    pub fn p1_entry(&self) -> Result<Option<RevlogEntry>, RevlogError> {
+        if self.p1 == NULL_REVISION {
+            Ok(None)
+        } else {
+            Ok(Some(self.revlog.get_entry(self.p1)?))
+        }
+    }
+
+    pub fn p2_entry(&self) -> Result<Option<RevlogEntry>, RevlogError> {
+        if self.p2 == NULL_REVISION {
+            Ok(None)
+        } else {
+            Ok(Some(self.revlog.get_entry(self.p2)?))
+        }
+    }
+
+    pub fn p1(&self) -> Option<Revision> {
+        if self.p1 == NULL_REVISION {
+            None
+        } else {
+            Some(self.p1)
+        }
+    }
+
+    pub fn p2(&self) -> Option<Revision> {
+        if self.p2 == NULL_REVISION {
+            None
+        } else {
+            Some(self.p2)
+        }
+    }
+
+    pub fn is_censored(&self) -> bool {
+        (self.flags & REVISION_FLAG_CENSORED) != 0
+    }
+
+    pub fn has_length_affecting_flag_processor(&self) -> bool {
+        // Relevant Python code: revlog.size()
+        // note: ELLIPSIS is known to not change the content
+        (self.flags & (REVIDX_KNOWN_FLAGS ^ REVISION_FLAG_ELLIPSIS)) != 0
+    }
+
+    /// The data for this entry, after resolving deltas if any.
+    pub fn rawdata(&self) -> Result<Cow<'a, [u8]>, HgError> {
+        let mut entry = self.clone();
+        let mut delta_chain = vec![];
+
+        // The meaning of `base_rev_or_base_of_delta_chain` depends on
+        // generaldelta. See the doc on `ENTRY_DELTA_BASE` in
+        // `mercurial/revlogutils/constants.py` and the code in
+        // [_chaininfo] and in [index_deltachain].
+        let uses_generaldelta = self.revlog.index.uses_generaldelta();
+        while let Some(base_rev) = entry.base_rev_or_base_of_delta_chain {
+            let base_rev = if uses_generaldelta {
+                base_rev
+            } else {
+                entry.rev - 1
+            };
+            delta_chain.push(entry);
+            entry = self.revlog.get_entry_internal(base_rev)?;
+        }
+
+        let data = if delta_chain.is_empty() {
+            entry.data_chunk()?
+        } else {
+            Revlog::build_data_from_deltas(entry, &delta_chain)?.into()
+        };
+
+        Ok(data)
+    }
+
+    fn check_data(
+        &self,
+        data: Cow<'a, [u8]>,
+    ) -> Result<Cow<'a, [u8]>, HgError> {
+        if self.revlog.check_hash(
+            self.p1,
+            self.p2,
+            self.hash.as_bytes(),
+            &data,
+        ) {
+            Ok(data)
+        } else {
+            if (self.flags & REVISION_FLAG_ELLIPSIS) != 0 {
+                return Err(HgError::unsupported(
+                    "ellipsis revisions are not supported by rhg",
+                ));
+            }
+            Err(corrupted(format!(
+                "hash check failed for revision {}",
+                self.rev
+            )))
+        }
+    }
+
+    pub fn data(&self) -> Result<Cow<'a, [u8]>, HgError> {
+        let data = self.rawdata()?;
+        if self.is_censored() {
+            return Err(HgError::CensoredNodeError);
+        }
+        self.check_data(data)
+    }
+
+    /// Extract the data contained in the entry.
+    /// This may be a delta. (See `is_delta`.)
+    fn data_chunk(&self) -> Result<Cow<'a, [u8]>, HgError> {
+        if self.bytes.is_empty() {
+            return Ok(Cow::Borrowed(&[]));
+        }
+        match self.bytes[0] {
+            // Revision data is the entirety of the entry, including this
+            // header.
+            b'\0' => Ok(Cow::Borrowed(self.bytes)),
+            // Raw revision data follows.
+            b'u' => Ok(Cow::Borrowed(&self.bytes[1..])),
+            // zlib (RFC 1950) data.
+            b'x' => Ok(Cow::Owned(self.uncompressed_zlib_data()?)),
+            // zstd data.
+            b'\x28' => Ok(Cow::Owned(self.uncompressed_zstd_data()?)),
+            // A proper new format should have had a repo/store requirement.
+            format_type => Err(corrupted(format!(
+                "unknown compression header '{}'",
+                format_type
+            ))),
+        }
+    }
+
+    fn uncompressed_zlib_data(&self) -> Result<Vec<u8>, HgError> {
+        let mut decoder = ZlibDecoder::new(self.bytes);
+        if self.is_delta() {
+            let mut buf = Vec::with_capacity(self.compressed_len as usize);
+            decoder
+                .read_to_end(&mut buf)
+                .map_err(|e| corrupted(e.to_string()))?;
+            Ok(buf)
+        } else {
+            let cap = self.uncompressed_len.max(0) as usize;
+            let mut buf = vec![0; cap];
+            decoder
+                .read_exact(&mut buf)
+                .map_err(|e| corrupted(e.to_string()))?;
+            Ok(buf)
+        }
+    }
+
+    fn uncompressed_zstd_data(&self) -> Result<Vec<u8>, HgError> {
+        if self.is_delta() {
+            let mut buf = Vec::with_capacity(self.compressed_len as usize);
+            zstd::stream::copy_decode(self.bytes, &mut buf)
+                .map_err(|e| corrupted(e.to_string()))?;
+            Ok(buf)
+        } else {
+            let cap = self.uncompressed_len.max(0) as usize;
+            let mut buf = vec![0; cap];
+            let len = zstd::bulk::decompress_to_buffer(self.bytes, &mut buf)
+                .map_err(|e| corrupted(e.to_string()))?;
+            if len != self.uncompressed_len as usize {
+                Err(corrupted("uncompressed length does not match"))
+            } else {
+                Ok(buf)
+            }
+        }
+    }
+
+    /// Tell if the entry is a snapshot or a delta
+    /// (influences on decompression).
+    fn is_delta(&self) -> bool {
+        self.base_rev_or_base_of_delta_chain.is_some()
+    }
+}
+
+/// Calculate the hash of a revision given its data and its parents.
+fn hash(
+    data: &[u8],
+    p1_hash: &[u8],
+    p2_hash: &[u8],
+) -> [u8; NODE_BYTES_LENGTH] {
+    let mut hasher = Sha1::new();
+    let (a, b) = (p1_hash, p2_hash);
+    if a > b {
+        hasher.update(b);
+        hasher.update(a);
+    } else {
+        hasher.update(a);
+        hasher.update(b);
+    }
+    hasher.update(data);
+    *hasher.finalize().as_ref()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::index::{IndexEntryBuilder, INDEX_ENTRY_SIZE};
+    use itertools::Itertools;
+
+    #[test]
+    fn test_empty() {
+        let temp = tempfile::tempdir().unwrap();
+        let vfs = Vfs { base: temp.path() };
+        std::fs::write(temp.path().join("foo.i"), b"").unwrap();
+        let revlog = Revlog::open(&vfs, "foo.i", None, false).unwrap();
+        assert!(revlog.is_empty());
+        assert_eq!(revlog.len(), 0);
+        assert!(revlog.get_entry(0).is_err());
+        assert!(!revlog.has_rev(0));
+    }
+
+    #[test]
+    fn test_inline() {
+        let temp = tempfile::tempdir().unwrap();
+        let vfs = Vfs { base: temp.path() };
+        let node0 = Node::from_hex("2ed2a3912a0b24502043eae84ee4b279c18b90dd")
+            .unwrap();
+        let node1 = Node::from_hex("b004912a8510032a0350a74daa2803dadfb00e12")
+            .unwrap();
+        let node2 = Node::from_hex("dd6ad206e907be60927b5a3117b97dffb2590582")
+            .unwrap();
+        let entry0_bytes = IndexEntryBuilder::new()
+            .is_first(true)
+            .with_version(1)
+            .with_inline(true)
+            .with_offset(INDEX_ENTRY_SIZE)
+            .with_node(node0)
+            .build();
+        let entry1_bytes = IndexEntryBuilder::new()
+            .with_offset(INDEX_ENTRY_SIZE)
+            .with_node(node1)
+            .build();
+        let entry2_bytes = IndexEntryBuilder::new()
+            .with_offset(INDEX_ENTRY_SIZE)
+            .with_p1(0)
+            .with_p2(1)
+            .with_node(node2)
+            .build();
+        let contents = vec![entry0_bytes, entry1_bytes, entry2_bytes]
+            .into_iter()
+            .flatten()
+            .collect_vec();
+        std::fs::write(temp.path().join("foo.i"), contents).unwrap();
+        let revlog = Revlog::open(&vfs, "foo.i", None, false).unwrap();
+
+        let entry0 = revlog.get_entry(0).ok().unwrap();
+        assert_eq!(entry0.revision(), 0);
+        assert_eq!(*entry0.node(), node0);
+        assert!(!entry0.has_p1());
+        assert_eq!(entry0.p1(), None);
+        assert_eq!(entry0.p2(), None);
+        let p1_entry = entry0.p1_entry().unwrap();
+        assert!(p1_entry.is_none());
+        let p2_entry = entry0.p2_entry().unwrap();
+        assert!(p2_entry.is_none());
+
+        let entry1 = revlog.get_entry(1).ok().unwrap();
+        assert_eq!(entry1.revision(), 1);
+        assert_eq!(*entry1.node(), node1);
+        assert!(!entry1.has_p1());
+        assert_eq!(entry1.p1(), None);
+        assert_eq!(entry1.p2(), None);
+        let p1_entry = entry1.p1_entry().unwrap();
+        assert!(p1_entry.is_none());
+        let p2_entry = entry1.p2_entry().unwrap();
+        assert!(p2_entry.is_none());
+
+        let entry2 = revlog.get_entry(2).ok().unwrap();
+        assert_eq!(entry2.revision(), 2);
+        assert_eq!(*entry2.node(), node2);
+        assert!(entry2.has_p1());
+        assert_eq!(entry2.p1(), Some(0));
+        assert_eq!(entry2.p2(), Some(1));
+        let p1_entry = entry2.p1_entry().unwrap();
+        assert!(p1_entry.is_some());
+        assert_eq!(p1_entry.unwrap().revision(), 0);
+        let p2_entry = entry2.p2_entry().unwrap();
+        assert!(p2_entry.is_some());
+        assert_eq!(p2_entry.unwrap().revision(), 1);
+    }
+}
--- a/rust/hg-core/src/revlog/revlog.rs	Tue Jan 10 10:57:15 2023 +0100
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,642 +0,0 @@
-use std::borrow::Cow;
-use std::io::Read;
-use std::ops::Deref;
-use std::path::Path;
-
-use flate2::read::ZlibDecoder;
-use sha1::{Digest, Sha1};
-use zstd;
-
-use super::index::Index;
-use super::node::{NodePrefix, NODE_BYTES_LENGTH, NULL_NODE};
-use super::nodemap;
-use super::nodemap::{NodeMap, NodeMapError};
-use super::nodemap_docket::NodeMapDocket;
-use super::patch;
-use crate::errors::HgError;
-use crate::revlog::Revision;
-use crate::vfs::Vfs;
-use crate::{Node, NULL_REVISION};
-
-const REVISION_FLAG_CENSORED: u16 = 1 << 15;
-const REVISION_FLAG_ELLIPSIS: u16 = 1 << 14;
-const REVISION_FLAG_EXTSTORED: u16 = 1 << 13;
-const REVISION_FLAG_HASCOPIESINFO: u16 = 1 << 12;
-
-// Keep this in sync with REVIDX_KNOWN_FLAGS in
-// mercurial/revlogutils/flagutil.py
-const REVIDX_KNOWN_FLAGS: u16 = REVISION_FLAG_CENSORED
-    | REVISION_FLAG_ELLIPSIS
-    | REVISION_FLAG_EXTSTORED
-    | REVISION_FLAG_HASCOPIESINFO;
-
-const NULL_REVLOG_ENTRY_FLAGS: u16 = 0;
-
-#[derive(Debug, derive_more::From)]
-pub enum RevlogError {
-    InvalidRevision,
-    /// Working directory is not supported
-    WDirUnsupported,
-    /// Found more than one entry whose ID match the requested prefix
-    AmbiguousPrefix,
-    #[from]
-    Other(HgError),
-}
-
-impl From<NodeMapError> for RevlogError {
-    fn from(error: NodeMapError) -> Self {
-        match error {
-            NodeMapError::MultipleResults => RevlogError::AmbiguousPrefix,
-            NodeMapError::RevisionNotInIndex(rev) => RevlogError::corrupted(
-                format!("nodemap point to revision {} not in index", rev),
-            ),
-        }
-    }
-}
-
-fn corrupted<S: AsRef<str>>(context: S) -> HgError {
-    HgError::corrupted(format!("corrupted revlog, {}", context.as_ref()))
-}
-
-impl RevlogError {
-    fn corrupted<S: AsRef<str>>(context: S) -> Self {
-        RevlogError::Other(corrupted(context))
-    }
-}
-
-/// Read only implementation of revlog.
-pub struct Revlog {
-    /// When index and data are not interleaved: bytes of the revlog index.
-    /// When index and data are interleaved: bytes of the revlog index and
-    /// data.
-    index: Index,
-    /// When index and data are not interleaved: bytes of the revlog data
-    data_bytes: Option<Box<dyn Deref<Target = [u8]> + Send>>,
-    /// When present on disk: the persistent nodemap for this revlog
-    nodemap: Option<nodemap::NodeTree>,
-}
-
-impl Revlog {
-    /// Open a revlog index file.
-    ///
-    /// It will also open the associated data file if index and data are not
-    /// interleaved.
-    pub fn open(
-        store_vfs: &Vfs,
-        index_path: impl AsRef<Path>,
-        data_path: Option<&Path>,
-        use_nodemap: bool,
-    ) -> Result<Self, HgError> {
-        let index_path = index_path.as_ref();
-        let index = {
-            match store_vfs.mmap_open_opt(&index_path)? {
-                None => Index::new(Box::new(vec![])),
-                Some(index_mmap) => {
-                    let index = Index::new(Box::new(index_mmap))?;
-                    Ok(index)
-                }
-            }
-        }?;
-
-        let default_data_path = index_path.with_extension("d");
-
-        // type annotation required
-        // won't recognize Mmap as Deref<Target = [u8]>
-        let data_bytes: Option<Box<dyn Deref<Target = [u8]> + Send>> =
-            if index.is_inline() {
-                None
-            } else {
-                let data_path = data_path.unwrap_or(&default_data_path);
-                let data_mmap = store_vfs.mmap_open(data_path)?;
-                Some(Box::new(data_mmap))
-            };
-
-        let nodemap = if index.is_inline() || !use_nodemap {
-            None
-        } else {
-            NodeMapDocket::read_from_file(store_vfs, index_path)?.map(
-                |(docket, data)| {
-                    nodemap::NodeTree::load_bytes(
-                        Box::new(data),
-                        docket.data_length,
-                    )
-                },
-            )
-        };
-
-        Ok(Revlog {
-            index,
-            data_bytes,
-            nodemap,
-        })
-    }
-
-    /// Return number of entries of the `Revlog`.
-    pub fn len(&self) -> usize {
-        self.index.len()
-    }
-
-    /// Returns `true` if the `Revlog` has zero `entries`.
-    pub fn is_empty(&self) -> bool {
-        self.index.is_empty()
-    }
-
-    /// Returns the node ID for the given revision number, if it exists in this
-    /// revlog
-    pub fn node_from_rev(&self, rev: Revision) -> Option<&Node> {
-        if rev == NULL_REVISION {
-            return Some(&NULL_NODE);
-        }
-        Some(self.index.get_entry(rev)?.hash())
-    }
-
-    /// Return the revision number for the given node ID, if it exists in this
-    /// revlog
-    pub fn rev_from_node(
-        &self,
-        node: NodePrefix,
-    ) -> Result<Revision, RevlogError> {
-        if node.is_prefix_of(&NULL_NODE) {
-            return Ok(NULL_REVISION);
-        }
-
-        if let Some(nodemap) = &self.nodemap {
-            return nodemap
-                .find_bin(&self.index, node)?
-                .ok_or(RevlogError::InvalidRevision);
-        }
-
-        // Fallback to linear scan when a persistent nodemap is not present.
-        // This happens when the persistent-nodemap experimental feature is not
-        // enabled, or for small revlogs.
-        //
-        // TODO: consider building a non-persistent nodemap in memory to
-        // optimize these cases.
-        let mut found_by_prefix = None;
-        for rev in (0..self.len() as Revision).rev() {
-            let index_entry = self.index.get_entry(rev).ok_or_else(|| {
-                HgError::corrupted(
-                    "revlog references a revision not in the index",
-                )
-            })?;
-            if node == *index_entry.hash() {
-                return Ok(rev);
-            }
-            if node.is_prefix_of(index_entry.hash()) {
-                if found_by_prefix.is_some() {
-                    return Err(RevlogError::AmbiguousPrefix);
-                }
-                found_by_prefix = Some(rev)
-            }
-        }
-        found_by_prefix.ok_or(RevlogError::InvalidRevision)
-    }
-
-    /// Returns whether the given revision exists in this revlog.
-    pub fn has_rev(&self, rev: Revision) -> bool {
-        self.index.get_entry(rev).is_some()
-    }
-
-    /// Return the full data associated to a revision.
-    ///
-    /// All entries required to build the final data out of deltas will be
-    /// retrieved as needed, and the deltas will be applied to the inital
-    /// snapshot to rebuild the final data.
-    pub fn get_rev_data(
-        &self,
-        rev: Revision,
-    ) -> Result<Cow<[u8]>, RevlogError> {
-        if rev == NULL_REVISION {
-            return Ok(Cow::Borrowed(&[]));
-        };
-        Ok(self.get_entry(rev)?.data()?)
-    }
-
-    /// Check the hash of some given data against the recorded hash.
-    pub fn check_hash(
-        &self,
-        p1: Revision,
-        p2: Revision,
-        expected: &[u8],
-        data: &[u8],
-    ) -> bool {
-        let e1 = self.index.get_entry(p1);
-        let h1 = match e1 {
-            Some(ref entry) => entry.hash(),
-            None => &NULL_NODE,
-        };
-        let e2 = self.index.get_entry(p2);
-        let h2 = match e2 {
-            Some(ref entry) => entry.hash(),
-            None => &NULL_NODE,
-        };
-
-        hash(data, h1.as_bytes(), h2.as_bytes()) == expected
-    }
-
-    /// Build the full data of a revision out its snapshot
-    /// and its deltas.
-    fn build_data_from_deltas(
-        snapshot: RevlogEntry,
-        deltas: &[RevlogEntry],
-    ) -> Result<Vec<u8>, HgError> {
-        let snapshot = snapshot.data_chunk()?;
-        let deltas = deltas
-            .iter()
-            .rev()
-            .map(RevlogEntry::data_chunk)
-            .collect::<Result<Vec<_>, _>>()?;
-        let patches: Vec<_> =
-            deltas.iter().map(|d| patch::PatchList::new(d)).collect();
-        let patch = patch::fold_patch_lists(&patches);
-        Ok(patch.apply(&snapshot))
-    }
-
-    /// Return the revlog data.
-    fn data(&self) -> &[u8] {
-        match &self.data_bytes {
-            Some(data_bytes) => data_bytes,
-            None => panic!(
-                "forgot to load the data or trying to access inline data"
-            ),
-        }
-    }
-
-    pub fn make_null_entry(&self) -> RevlogEntry {
-        RevlogEntry {
-            revlog: self,
-            rev: NULL_REVISION,
-            bytes: b"",
-            compressed_len: 0,
-            uncompressed_len: 0,
-            base_rev_or_base_of_delta_chain: None,
-            p1: NULL_REVISION,
-            p2: NULL_REVISION,
-            flags: NULL_REVLOG_ENTRY_FLAGS,
-            hash: NULL_NODE,
-        }
-    }
-
-    /// Get an entry of the revlog.
-    pub fn get_entry(
-        &self,
-        rev: Revision,
-    ) -> Result<RevlogEntry, RevlogError> {
-        if rev == NULL_REVISION {
-            return Ok(self.make_null_entry());
-        }
-        let index_entry = self
-            .index
-            .get_entry(rev)
-            .ok_or(RevlogError::InvalidRevision)?;
-        let start = index_entry.offset();
-        let end = start + index_entry.compressed_len() as usize;
-        let data = if self.index.is_inline() {
-            self.index.data(start, end)
-        } else {
-            &self.data()[start..end]
-        };
-        let entry = RevlogEntry {
-            revlog: self,
-            rev,
-            bytes: data,
-            compressed_len: index_entry.compressed_len(),
-            uncompressed_len: index_entry.uncompressed_len(),
-            base_rev_or_base_of_delta_chain: if index_entry
-                .base_revision_or_base_of_delta_chain()
-                == rev
-            {
-                None
-            } else {
-                Some(index_entry.base_revision_or_base_of_delta_chain())
-            },
-            p1: index_entry.p1(),
-            p2: index_entry.p2(),
-            flags: index_entry.flags(),
-            hash: *index_entry.hash(),
-        };
-        Ok(entry)
-    }
-
-    /// when resolving internal references within revlog, any errors
-    /// should be reported as corruption, instead of e.g. "invalid revision"
-    fn get_entry_internal(
-        &self,
-        rev: Revision,
-    ) -> Result<RevlogEntry, HgError> {
-        self.get_entry(rev)
-            .map_err(|_| corrupted(format!("revision {} out of range", rev)))
-    }
-}
-
-/// The revlog entry's bytes and the necessary informations to extract
-/// the entry's data.
-#[derive(Clone)]
-pub struct RevlogEntry<'a> {
-    revlog: &'a Revlog,
-    rev: Revision,
-    bytes: &'a [u8],
-    compressed_len: u32,
-    uncompressed_len: i32,
-    base_rev_or_base_of_delta_chain: Option<Revision>,
-    p1: Revision,
-    p2: Revision,
-    flags: u16,
-    hash: Node,
-}
-
-impl<'a> RevlogEntry<'a> {
-    pub fn revision(&self) -> Revision {
-        self.rev
-    }
-
-    pub fn node(&self) -> &Node {
-        &self.hash
-    }
-
-    pub fn uncompressed_len(&self) -> Option<u32> {
-        u32::try_from(self.uncompressed_len).ok()
-    }
-
-    pub fn has_p1(&self) -> bool {
-        self.p1 != NULL_REVISION
-    }
-
-    pub fn p1_entry(&self) -> Result<Option<RevlogEntry>, RevlogError> {
-        if self.p1 == NULL_REVISION {
-            Ok(None)
-        } else {
-            Ok(Some(self.revlog.get_entry(self.p1)?))
-        }
-    }
-
-    pub fn p2_entry(&self) -> Result<Option<RevlogEntry>, RevlogError> {
-        if self.p2 == NULL_REVISION {
-            Ok(None)
-        } else {
-            Ok(Some(self.revlog.get_entry(self.p2)?))
-        }
-    }
-
-    pub fn p1(&self) -> Option<Revision> {
-        if self.p1 == NULL_REVISION {
-            None
-        } else {
-            Some(self.p1)
-        }
-    }
-
-    pub fn p2(&self) -> Option<Revision> {
-        if self.p2 == NULL_REVISION {
-            None
-        } else {
-            Some(self.p2)
-        }
-    }
-
-    pub fn is_censored(&self) -> bool {
-        (self.flags & REVISION_FLAG_CENSORED) != 0
-    }
-
-    pub fn has_length_affecting_flag_processor(&self) -> bool {
-        // Relevant Python code: revlog.size()
-        // note: ELLIPSIS is known to not change the content
-        (self.flags & (REVIDX_KNOWN_FLAGS ^ REVISION_FLAG_ELLIPSIS)) != 0
-    }
-
-    /// The data for this entry, after resolving deltas if any.
-    pub fn rawdata(&self) -> Result<Cow<'a, [u8]>, HgError> {
-        let mut entry = self.clone();
-        let mut delta_chain = vec![];
-
-        // The meaning of `base_rev_or_base_of_delta_chain` depends on
-        // generaldelta. See the doc on `ENTRY_DELTA_BASE` in
-        // `mercurial/revlogutils/constants.py` and the code in
-        // [_chaininfo] and in [index_deltachain].
-        let uses_generaldelta = self.revlog.index.uses_generaldelta();
-        while let Some(base_rev) = entry.base_rev_or_base_of_delta_chain {
-            let base_rev = if uses_generaldelta {
-                base_rev
-            } else {
-                entry.rev - 1
-            };
-            delta_chain.push(entry);
-            entry = self.revlog.get_entry_internal(base_rev)?;
-        }
-
-        let data = if delta_chain.is_empty() {
-            entry.data_chunk()?
-        } else {
-            Revlog::build_data_from_deltas(entry, &delta_chain)?.into()
-        };
-
-        Ok(data)
-    }
-
-    fn check_data(
-        &self,
-        data: Cow<'a, [u8]>,
-    ) -> Result<Cow<'a, [u8]>, HgError> {
-        if self.revlog.check_hash(
-            self.p1,
-            self.p2,
-            self.hash.as_bytes(),
-            &data,
-        ) {
-            Ok(data)
-        } else {
-            if (self.flags & REVISION_FLAG_ELLIPSIS) != 0 {
-                return Err(HgError::unsupported(
-                    "ellipsis revisions are not supported by rhg",
-                ));
-            }
-            Err(corrupted(format!(
-                "hash check failed for revision {}",
-                self.rev
-            )))
-        }
-    }
-
-    pub fn data(&self) -> Result<Cow<'a, [u8]>, HgError> {
-        let data = self.rawdata()?;
-        if self.is_censored() {
-            return Err(HgError::CensoredNodeError);
-        }
-        self.check_data(data)
-    }
-
-    /// Extract the data contained in the entry.
-    /// This may be a delta. (See `is_delta`.)
-    fn data_chunk(&self) -> Result<Cow<'a, [u8]>, HgError> {
-        if self.bytes.is_empty() {
-            return Ok(Cow::Borrowed(&[]));
-        }
-        match self.bytes[0] {
-            // Revision data is the entirety of the entry, including this
-            // header.
-            b'\0' => Ok(Cow::Borrowed(self.bytes)),
-            // Raw revision data follows.
-            b'u' => Ok(Cow::Borrowed(&self.bytes[1..])),
-            // zlib (RFC 1950) data.
-            b'x' => Ok(Cow::Owned(self.uncompressed_zlib_data()?)),
-            // zstd data.
-            b'\x28' => Ok(Cow::Owned(self.uncompressed_zstd_data()?)),
-            // A proper new format should have had a repo/store requirement.
-            format_type => Err(corrupted(format!(
-                "unknown compression header '{}'",
-                format_type
-            ))),
-        }
-    }
-
-    fn uncompressed_zlib_data(&self) -> Result<Vec<u8>, HgError> {
-        let mut decoder = ZlibDecoder::new(self.bytes);
-        if self.is_delta() {
-            let mut buf = Vec::with_capacity(self.compressed_len as usize);
-            decoder
-                .read_to_end(&mut buf)
-                .map_err(|e| corrupted(e.to_string()))?;
-            Ok(buf)
-        } else {
-            let cap = self.uncompressed_len.max(0) as usize;
-            let mut buf = vec![0; cap];
-            decoder
-                .read_exact(&mut buf)
-                .map_err(|e| corrupted(e.to_string()))?;
-            Ok(buf)
-        }
-    }
-
-    fn uncompressed_zstd_data(&self) -> Result<Vec<u8>, HgError> {
-        if self.is_delta() {
-            let mut buf = Vec::with_capacity(self.compressed_len as usize);
-            zstd::stream::copy_decode(self.bytes, &mut buf)
-                .map_err(|e| corrupted(e.to_string()))?;
-            Ok(buf)
-        } else {
-            let cap = self.uncompressed_len.max(0) as usize;
-            let mut buf = vec![0; cap];
-            let len = zstd::bulk::decompress_to_buffer(self.bytes, &mut buf)
-                .map_err(|e| corrupted(e.to_string()))?;
-            if len != self.uncompressed_len as usize {
-                Err(corrupted("uncompressed length does not match"))
-            } else {
-                Ok(buf)
-            }
-        }
-    }
-
-    /// Tell if the entry is a snapshot or a delta
-    /// (influences on decompression).
-    fn is_delta(&self) -> bool {
-        self.base_rev_or_base_of_delta_chain.is_some()
-    }
-}
-
-/// Calculate the hash of a revision given its data and its parents.
-fn hash(
-    data: &[u8],
-    p1_hash: &[u8],
-    p2_hash: &[u8],
-) -> [u8; NODE_BYTES_LENGTH] {
-    let mut hasher = Sha1::new();
-    let (a, b) = (p1_hash, p2_hash);
-    if a > b {
-        hasher.update(b);
-        hasher.update(a);
-    } else {
-        hasher.update(a);
-        hasher.update(b);
-    }
-    hasher.update(data);
-    *hasher.finalize().as_ref()
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::index::{IndexEntryBuilder, INDEX_ENTRY_SIZE};
-    use itertools::Itertools;
-
-    #[test]
-    fn test_empty() {
-        let temp = tempfile::tempdir().unwrap();
-        let vfs = Vfs { base: temp.path() };
-        std::fs::write(temp.path().join("foo.i"), b"").unwrap();
-        let revlog = Revlog::open(&vfs, "foo.i", None, false).unwrap();
-        assert!(revlog.is_empty());
-        assert_eq!(revlog.len(), 0);
-        assert!(revlog.get_entry(0).is_err());
-        assert!(!revlog.has_rev(0));
-    }
-
-    #[test]
-    fn test_inline() {
-        let temp = tempfile::tempdir().unwrap();
-        let vfs = Vfs { base: temp.path() };
-        let node0 = Node::from_hex("2ed2a3912a0b24502043eae84ee4b279c18b90dd")
-            .unwrap();
-        let node1 = Node::from_hex("b004912a8510032a0350a74daa2803dadfb00e12")
-            .unwrap();
-        let node2 = Node::from_hex("dd6ad206e907be60927b5a3117b97dffb2590582")
-            .unwrap();
-        let entry0_bytes = IndexEntryBuilder::new()
-            .is_first(true)
-            .with_version(1)
-            .with_inline(true)
-            .with_offset(INDEX_ENTRY_SIZE)
-            .with_node(node0)
-            .build();
-        let entry1_bytes = IndexEntryBuilder::new()
-            .with_offset(INDEX_ENTRY_SIZE)
-            .with_node(node1)
-            .build();
-        let entry2_bytes = IndexEntryBuilder::new()
-            .with_offset(INDEX_ENTRY_SIZE)
-            .with_p1(0)
-            .with_p2(1)
-            .with_node(node2)
-            .build();
-        let contents = vec![entry0_bytes, entry1_bytes, entry2_bytes]
-            .into_iter()
-            .flatten()
-            .collect_vec();
-        std::fs::write(temp.path().join("foo.i"), contents).unwrap();
-        let revlog = Revlog::open(&vfs, "foo.i", None, false).unwrap();
-
-        let entry0 = revlog.get_entry(0).ok().unwrap();
-        assert_eq!(entry0.revision(), 0);
-        assert_eq!(*entry0.node(), node0);
-        assert!(!entry0.has_p1());
-        assert_eq!(entry0.p1(), None);
-        assert_eq!(entry0.p2(), None);
-        let p1_entry = entry0.p1_entry().unwrap();
-        assert!(p1_entry.is_none());
-        let p2_entry = entry0.p2_entry().unwrap();
-        assert!(p2_entry.is_none());
-
-        let entry1 = revlog.get_entry(1).ok().unwrap();
-        assert_eq!(entry1.revision(), 1);
-        assert_eq!(*entry1.node(), node1);
-        assert!(!entry1.has_p1());
-        assert_eq!(entry1.p1(), None);
-        assert_eq!(entry1.p2(), None);
-        let p1_entry = entry1.p1_entry().unwrap();
-        assert!(p1_entry.is_none());
-        let p2_entry = entry1.p2_entry().unwrap();
-        assert!(p2_entry.is_none());
-
-        let entry2 = revlog.get_entry(2).ok().unwrap();
-        assert_eq!(entry2.revision(), 2);
-        assert_eq!(*entry2.node(), node2);
-        assert!(entry2.has_p1());
-        assert_eq!(entry2.p1(), Some(0));
-        assert_eq!(entry2.p2(), Some(1));
-        let p1_entry = entry2.p1_entry().unwrap();
-        assert!(p1_entry.is_some());
-        assert_eq!(p1_entry.unwrap().revision(), 0);
-        let p2_entry = entry2.p2_entry().unwrap();
-        assert!(p2_entry.is_some());
-        assert_eq!(p2_entry.unwrap().revision(), 1);
-    }
-}
--- a/rust/hg-core/src/revset.rs	Tue Jan 10 10:57:15 2023 +0100
+++ b/rust/hg-core/src/revset.rs	Tue Jan 10 11:20:54 2023 +0100
@@ -4,9 +4,9 @@
 
 use crate::errors::HgError;
 use crate::repo::Repo;
-use crate::revlog::revlog::{Revlog, RevlogError};
 use crate::revlog::NodePrefix;
 use crate::revlog::{Revision, NULL_REVISION, WORKING_DIRECTORY_HEX};
+use crate::revlog::{Revlog, RevlogError};
 use crate::Node;
 
 /// Resolve a query string into a single revision.
--- a/rust/rhg/src/error.rs	Tue Jan 10 10:57:15 2023 +0100
+++ b/rust/rhg/src/error.rs	Tue Jan 10 11:20:54 2023 +0100
@@ -7,7 +7,7 @@
 use hg::errors::HgError;
 use hg::exit_codes;
 use hg::repo::RepoError;
-use hg::revlog::revlog::RevlogError;
+use hg::revlog::RevlogError;
 use hg::sparse::SparseConfigError;
 use hg::utils::files::get_bytes_from_path;
 use hg::{DirstateError, DirstateMapError, StatusError};