rust: add Vfs trait

This will allow for the use of multiple vfs like in the Python implementation,
as well as hiding the details of the upcoming Python vfs wrapper to hg-core.

rust/Cargo.lock

@@ -1,1774 +1,1820
 # This file is automatically @generated by Cargo.
 # It is not intended for manual editing.
 version = 3
 
 [[package]]
 name = "adler"
 version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe"
 
 [[package]]
 name = "ahash"
 version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bf6ccdb167abbf410dcb915cabd428929d7f6a04980b54a11f26a39f1c7f7107"
 dependencies = [
  "cfg-if",
  "once_cell",
  "version_check",
 ]
 
 [[package]]
 name = "aho-corasick"
 version = "0.7.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b4f55bd91a0978cbfd91c457a164bab8b4001c833b7f323132c0a4e1922dd44e"
 dependencies = [
  "memchr",
 ]
 
 [[package]]
 name = "android-tzdata"
 version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e999941b234f3131b00bc13c22d06e8c5ff726d1b6318ac7eb276997bbb4fef0"
 
 [[package]]
 name = "android_system_properties"
 version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"
 dependencies = [
  "libc",
 ]
 
 [[package]]
 name = "atty"
 version = "0.2.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
 dependencies = [
  "hermit-abi",
  "libc",
  "winapi",
 ]
 
 [[package]]
 name = "autocfg"
 version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
 
 [[package]]
 name = "bitflags"
 version = "1.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
 [[package]]
 name = "bitflags"
 version = "2.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de"
 
 [[package]]
 name = "bitmaps"
 version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "031043d04099746d8db04daf1fa424b2bc8bd69d92b25962dcde24da39ab64a2"
 dependencies = [
  "typenum",
 ]
 
 [[package]]
 name = "bitvec"
 version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1bc2832c24239b0141d5674bb9174f9d68a8b5b3f2753311927c172ca46f7e9c"
 dependencies = [
  "funty",
  "radium",
  "tap",
  "wyz",
 ]
 
 [[package]]
 name = "block-buffer"
 version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4152116fd6e9dadb291ae18fc1ec3575ed6d84c29642d97890f4b4a3417297e4"
 dependencies = [
  "generic-array",
 ]
 
 [[package]]
 name = "block-buffer"
 version = "0.10.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "69cce20737498f97b993470a6e536b8523f0af7892a4f928cceb1ac5e52ebe7e"
 dependencies = [
  "generic-array",
 ]
 
 [[package]]
 name = "bstr"
 version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6798148dccfbff0fae41c7574d2fa8f1ef3492fba0face179de5d8d447d67b05"
 dependencies = [
  "memchr",
  "regex-automata",
  "serde",
 ]
 
 [[package]]
 name = "bumpalo"
 version = "3.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "572f695136211188308f16ad2ca5c851a712c464060ae6974944458eb83880ba"
 
 [[package]]
 name = "byteorder"
 version = "1.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"
 
 [[package]]
 name = "bytes-cast"
 version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a20de93b91d7703ca0e39e12930e310acec5ff4d715f4166e0ab026babb352e8"
 dependencies = [
  "bytes-cast-derive",
 ]
 
 [[package]]
 name = "bytes-cast-derive"
 version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7470a6fcce58cde3d62cce758bf71007978b75247e6becd9255c9b884bcb4f71"
 dependencies = [
  "proc-macro2",
  "quote",
  "syn",
 ]
 
 [[package]]
 name = "cc"
 version = "1.0.76"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "76a284da2e6fe2092f2353e51713435363112dfd60030e22add80be333fb928f"
 dependencies = [
  "jobserver",
 ]
 
 [[package]]
 name = "cfg-if"
 version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
 [[package]]
 name = "chrono"
 version = "0.4.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5bc015644b92d5890fab7489e49d21f879d5c990186827d42ec511919404f38b"
 dependencies = [
  "android-tzdata",
  "iana-time-zone",
  "js-sys",
  "num-traits",
  "wasm-bindgen",
- "windows-targets 0.52.0",
+ "windows-targets 0.52.6",
 ]
 
 [[package]]
 name = "clap"
 version = "4.0.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "60494cedb60cb47462c0ff7be53de32c0e42a6fc2c772184554fa12bd9489c03"
 dependencies = [
  "atty",
  "bitflags 1.3.2",
  "clap_derive",
  "clap_lex",
  "once_cell",
  "strsim",
  "termcolor",
 ]
 
 [[package]]
 name = "clap_derive"
 version = "4.0.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0177313f9f02afc995627906bbd8967e2be069f5261954222dac78290c2b9014"
 dependencies = [
  "heck",
  "proc-macro-error",
  "proc-macro2",
  "quote",
  "syn",
 ]
 
 [[package]]
 name = "clap_lex"
 version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0d4198f73e42b4936b35b5bb248d81d2b595ecb170da0bac7655c54eedfa8da8"
 dependencies = [
  "os_str_bytes",
 ]
 
 [[package]]
 name = "codespan-reporting"
 version = "0.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3538270d33cc669650c4b093848450d380def10c331d38c768e34cac80576e6e"
 dependencies = [
  "termcolor",
  "unicode-width",
 ]
 
 [[package]]
 name = "convert_case"
 version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6245d59a3e82a7fc217c5828a6692dbc6dfb63a0c8c90495621f7b9d79704a0e"
 
 [[package]]
 name = "core-foundation-sys"
 version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5827cebf4670468b8772dd191856768aedcb1b0278a04f989f7766351917b9dc"
 
 [[package]]
 name = "cpufeatures"
 version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "28d997bd5e24a5928dd43e46dc529867e207907fe0b239c3477d924f7f2ca320"
 dependencies = [
  "libc",
 ]
 
 [[package]]
 name = "cpython"
 version = "0.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "43b398a2c65baaf5892f10bb69b52508bf7a993380cc4ecd3785aaebb5c79389"
 dependencies = [
  "libc",
  "num-traits",
  "paste",
  "python3-sys",
 ]
 
 [[package]]
 name = "crc32fast"
 version = "1.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b540bd8bc810d3885c6ea91e2018302f68baba2129ab3e88f32389ee9370880d"
 dependencies = [
  "cfg-if",
 ]
 
 [[package]]
 name = "crossbeam-channel"
 version = "0.5.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c2dd04ddaf88237dc3b8d8f9a3c1004b506b54b3313403944054d23c0870c521"
 dependencies = [
  "cfg-if",
  "crossbeam-utils",
 ]
 
 [[package]]
 name = "crossbeam-deque"
 version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "715e8152b692bba2d374b53d4875445368fdf21a94751410af607a5ac677d1fc"
 dependencies = [
  "cfg-if",
  "crossbeam-epoch",
  "crossbeam-utils",
 ]
 
 [[package]]
 name = "crossbeam-epoch"
 version = "0.9.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f916dfc5d356b0ed9dae65f1db9fc9770aa2851d2662b988ccf4fe3516e86348"
 dependencies = [
  "autocfg",
  "cfg-if",
  "crossbeam-utils",
  "memoffset",
  "scopeguard",
 ]
 
 [[package]]
 name = "crossbeam-utils"
 version = "0.8.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "edbafec5fa1f196ca66527c1b12c2ec4745ca14b50f1ad8f9f6f720b55d11fac"
 dependencies = [
  "cfg-if",
 ]
 
 [[package]]
 name = "crypto-common"
 version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
 dependencies = [
  "generic-array",
  "typenum",
 ]
 
 [[package]]
 name = "ctor"
 version = "0.1.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6d2301688392eb071b0bf1a37be05c469d3cc4dbbd95df672fe28ab021e6a096"
 dependencies = [
  "quote",
  "syn",
 ]
 
 [[package]]
 name = "cxx"
 version = "1.0.81"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "97abf9f0eca9e52b7f81b945524e76710e6cb2366aead23b7d4fbf72e281f888"
 dependencies = [
  "cc",
  "cxxbridge-flags",
  "cxxbridge-macro",
  "link-cplusplus",
 ]
 
 [[package]]
 name = "cxx-build"
 version = "1.0.81"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7cc32cc5fea1d894b77d269ddb9f192110069a8a9c1f1d441195fba90553dea3"
 dependencies = [
  "cc",
  "codespan-reporting",
  "once_cell",
  "proc-macro2",
  "quote",
  "scratch",
  "syn",
 ]
 
 [[package]]
 name = "cxxbridge-flags"
 version = "1.0.81"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8ca220e4794c934dc6b1207c3b42856ad4c302f2df1712e9f8d2eec5afaacf1f"
 
 [[package]]
 name = "cxxbridge-macro"
 version = "1.0.81"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b846f081361125bfc8dc9d3940c84e1fd83ba54bbca7b17cd29483c828be0704"
 dependencies = [
  "proc-macro2",
  "quote",
  "syn",
 ]
 
 [[package]]
 name = "derive_more"
 version = "0.99.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4fb810d30a7c1953f91334de7244731fc3f3c10d7fe163338a35b9f640960321"
 dependencies = [
  "convert_case",
  "proc-macro2",
  "quote",
  "rustc_version",
  "syn",
 ]
 
 [[package]]
 name = "diff"
 version = "0.1.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "56254986775e3233ffa9c4d7d3faaf6d36a2c09d30b20687e9f88bc8bafc16c8"
 
 [[package]]
 name = "digest"
 version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d3dd60d1080a57a05ab032377049e0591415d2b31afd7028356dbf3cc6dcb066"
 dependencies = [
  "generic-array",
 ]
 
 [[package]]
 name = "digest"
 version = "0.10.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "adfbc57365a37acbd2ebf2b64d7e69bb766e2fea813521ed536f5d0520dcf86c"
 dependencies = [
  "block-buffer 0.10.3",
  "crypto-common",
 ]
 
 [[package]]
 name = "dirs"
 version = "5.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "44c45a9d03d6676652bcb5e724c7e988de1acad23a711b5217ab9cbecbec2225"
 dependencies = [
  "dirs-sys",
 ]
 
 [[package]]
 name = "dirs-sys"
 version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "520f05a5cbd335fae5a99ff7a6ab8627577660ee5cfd6a94a6a929b52ff0321c"
 dependencies = [
  "libc",
  "option-ext",
  "redox_users",
- "windows-sys",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
+name = "dyn-clone"
+version = "1.0.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0d6ef0072f8a535281e4876be788938b528e9a1d43900b82c2569af7da799125"
+
+[[package]]
 name = "either"
 version = "1.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "90e5c1c8368803113bf0c9584fc495a58b86dc8a29edbf8fe877d21d9507e797"
 
 [[package]]
 name = "env_logger"
 version = "0.9.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a12e6657c4c97ebab115a42dcee77225f7f482cdd841cf7088c657a42e9e00e7"
 dependencies = [
  "atty",
  "humantime",
  "log",
  "regex",
  "termcolor",
 ]
 
 [[package]]
 name = "fastrand"
 version = "1.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a7a407cfaa3385c4ae6b23e84623d48c2798d06e3e6a1878f7f59f17b3f86499"
 dependencies = [
  "instant",
 ]
 
 [[package]]
+name = "filetime"
+version = "0.2.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "35c0522e981e68cbfa8c3f978441a5f34b30b96e146b33cd3359176b50fe8586"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "libredox",
+ "windows-sys 0.59.0",
+]
+
+[[package]]
 name = "flate2"
 version = "1.0.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f82b0f4c27ad9f8bfd1f3208d882da2b09c301bc1c828fd3a00d0216d2fbbff6"
 dependencies = [
  "crc32fast",
  "libz-sys",
  "miniz_oxide",
 ]
 
 [[package]]
 name = "format-bytes"
 version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "48942366ef93975da38e175ac9e10068c6fc08ca9e85930d4f098f4d5b14c2fd"
 dependencies = [
  "format-bytes-macros",
 ]
 
 [[package]]
 name = "format-bytes-macros"
 version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "203aadebefcc73d12038296c228eabf830f99cba991b0032adf20e9fa6ce7e4f"
 dependencies = [
  "proc-macro2",
  "quote",
  "syn",
 ]
 
 [[package]]
 name = "funty"
 version = "2.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
 
 [[package]]
 name = "generic-array"
 version = "0.14.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bff49e947297f3312447abdca79f45f4738097cc82b06e72054d2223f601f1b9"
 dependencies = [
  "typenum",
  "version_check",
 ]
 
 [[package]]
 name = "getrandom"
 version = "0.1.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8fc3cb4d91f53b50155bdcfd23f6a4c39ae1969c2ae85982b135750cccaf5fce"
 dependencies = [
  "cfg-if",
  "libc",
  "wasi 0.9.0+wasi-snapshot-preview1",
 ]
 
 [[package]]
 name = "getrandom"
 version = "0.2.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c05aeb6a22b8f62540c194aac980f2115af067bfe15a0734d7277a768d396b31"
 dependencies = [
  "cfg-if",
  "libc",
  "wasi 0.11.0+wasi-snapshot-preview1",
 ]
 
 [[package]]
 name = "hashbrown"
 version = "0.12.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
 
 [[package]]
 name = "hashbrown"
 version = "0.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "33ff8ae62cd3a9102e5637afc8452c55acf3844001bd5374e0b0bd7b6616c038"
 dependencies = [
  "ahash",
  "rayon",
 ]
 
 [[package]]
 name = "heck"
 version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2540771e65fc8cb83cd6e8a237f70c319bd5c29f78ed1084ba5d50eeac86f7f9"
 
 [[package]]
 name = "hermit-abi"
 version = "0.1.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"
 dependencies = [
  "libc",
 ]
 
 [[package]]
 name = "hex"
 version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
 
 [[package]]
 name = "hg-core"
 version = "0.1.0"
 dependencies = [
  "bitflags 1.3.2",
  "bitvec",
  "byteorder",
  "bytes-cast",
  "chrono",
  "clap",
  "crossbeam-channel",
  "derive_more",
+ "dyn-clone",
+ "filetime",
  "flate2",
  "format-bytes",
  "hashbrown 0.13.1",
  "home",
  "im-rc",
  "itertools",
  "lazy_static",
  "libc",
  "log",
  "logging_timer",
  "memmap2",
  "once_cell",
  "pretty_assertions",
  "rand 0.8.5",
  "rand_distr",
  "rand_pcg",
  "rayon",
  "regex",
  "same-file",
  "self_cell",
  "serde",
  "sha-1 0.10.0",
  "tempfile",
  "thread_local",
  "toml",
  "twox-hash",
  "zstd",
 ]
 
 [[package]]
 name = "hg-cpython"
 version = "0.1.0"
 dependencies = [
  "cpython",
  "crossbeam-channel",
  "env_logger",
  "hg-core",
  "libc",
  "log",
  "stable_deref_trait",
  "vcsgraph",
 ]
 
 [[package]]
 name = "home"
 version = "0.5.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "747309b4b440c06d57b0b25f2aee03ee9b5e5397d288c60e21fc709bb98a7408"
 dependencies = [
  "winapi",
 ]
 
 [[package]]
 name = "humantime"
 version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4"
 
 [[package]]
 name = "iana-time-zone"
 version = "0.1.53"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "64c122667b287044802d6ce17ee2ddf13207ed924c712de9a66a5814d5b64765"
 dependencies = [
  "android_system_properties",
  "core-foundation-sys",
  "iana-time-zone-haiku",
  "js-sys",
  "wasm-bindgen",
  "winapi",
 ]
 
 [[package]]
 name = "iana-time-zone-haiku"
 version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0703ae284fc167426161c2e3f1da3ea71d94b21bedbcc9494e92b28e334e3dca"
 dependencies = [
  "cxx",
  "cxx-build",
 ]
 
 [[package]]
 name = "im-rc"
 version = "15.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "af1955a75fa080c677d3972822ec4bad316169ab1cfc6c257a942c2265dbe5fe"
 dependencies = [
  "bitmaps",
  "rand_core 0.6.4",
  "rand_xoshiro",
  "sized-chunks",
  "typenum",
  "version_check",
 ]
 
 [[package]]
 name = "indexmap"
 version = "1.9.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1885e79c1fc4b10f0e172c475f458b7f7b93061064d98c3293e98c5ba0c8b399"
 dependencies = [
  "autocfg",
  "hashbrown 0.12.3",
 ]
 
 [[package]]
 name = "instant"
 version = "0.1.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7a5bbe824c507c5da5956355e86a746d82e0e1464f65d862cc5e71da70e94b2c"
 dependencies = [
  "cfg-if",
 ]
 
 [[package]]
 name = "itertools"
 version = "0.10.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473"
 dependencies = [
  "either",
 ]
 
 [[package]]
 name = "jobserver"
 version = "0.1.25"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "068b1ee6743e4d11fb9c6a1e6064b3693a1b600e7f5f5988047d98b3dc9fb90b"
 dependencies = [
  "libc",
 ]
 
 [[package]]
 name = "js-sys"
 version = "0.3.60"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "49409df3e3bf0856b916e2ceaca09ee28e6871cf7d9ce97a692cacfdb2a25a47"
 dependencies = [
  "wasm-bindgen",
 ]
 
 [[package]]
 name = "lazy_static"
 version = "1.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
 
 [[package]]
 name = "libc"
 version = "0.2.155"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "97b3888a4aecf77e811145cadf6eef5901f4782c53886191b2f693f24761847c"
 
 [[package]]
 name = "libm"
 version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "348108ab3fba42ec82ff6e9564fc4ca0247bdccdc68dd8af9764bbc79c3c8ffb"
 
 [[package]]
 name = "libredox"
 version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c0ff37bd590ca25063e35af745c343cb7a0271906fb7b37e4813e8f79f00268d"
 dependencies = [
  "bitflags 2.6.0",
  "libc",
+ "redox_syscall 0.5.3",
 ]
 
 [[package]]
 name = "libz-sys"
 version = "1.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9702761c3935f8cc2f101793272e202c72b99da8f4224a19ddcf1279a6450bbf"
 dependencies = [
  "cc",
  "pkg-config",
  "vcpkg",
 ]
 
 [[package]]
 name = "link-cplusplus"
 version = "1.0.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9272ab7b96c9046fbc5bc56c06c117cb639fe2d509df0c421cad82d2915cf369"
 dependencies = [
  "cc",
 ]
 
 [[package]]
 name = "log"
 version = "0.4.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "abb12e687cfb44aa40f41fc3978ef76448f9b6038cad6aef4259d3c095a2382e"
 dependencies = [
  "cfg-if",
 ]
 
 [[package]]
 name = "logging_timer"
 version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "64e96f261d684b7089aa576bb74e823241dccd994b27d30fabf1dcb3af284fe9"
 dependencies = [
  "log",
  "logging_timer_proc_macros",
 ]
 
 [[package]]
 name = "logging_timer_proc_macros"
 version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "10a9062912d7952c5588cc474795e0b9ee008e7e6781127945b85413d4b99d81"
 dependencies = [
  "log",
  "proc-macro2",
  "quote",
  "syn",
 ]
 
 [[package]]
 name = "memchr"
 version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"
 
 [[package]]
 name = "memmap2"
 version = "0.5.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4b182332558b18d807c4ce1ca8ca983b34c3ee32765e47b3f0f69b90355cc1dc"
 dependencies = [
  "libc",
  "stable_deref_trait",
 ]
 
 [[package]]
 name = "memoffset"
 version = "0.6.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5aa361d4faea93603064a027415f07bd8e1d5c88c9fbf68bf56a285428fd79ce"
 dependencies = [
  "autocfg",
 ]
 
 [[package]]
 name = "miniz_oxide"
 version = "0.5.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "96590ba8f175222643a85693f33d26e9c8a015f599c216509b1a6894af675d34"
 dependencies = [
  "adler",
 ]
 
 [[package]]
 name = "nom8"
 version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ae01545c9c7fc4486ab7debaf2aad7003ac19431791868fb2e8066df97fad2f8"
 dependencies = [
  "memchr",
 ]
 
 [[package]]
 name = "num-traits"
 version = "0.2.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "578ede34cf02f8924ab9447f50c28075b4d3e5b269972345e7e0372b38c6cdcd"
 dependencies = [
  "autocfg",
  "libm",
 ]
 
 [[package]]
 name = "num_cpus"
 version = "1.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f6058e64324c71e02bc2b150e4f3bc8286db6c83092132ffa3f6b1eab0f9def5"
 dependencies = [
  "hermit-abi",
  "libc",
 ]
 
 [[package]]
 name = "once_cell"
 version = "1.16.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "86f0b0d4bf799edbc74508c1e8bf170ff5f41238e5f8225603ca7caaae2b7860"
 
 [[package]]
 name = "opaque-debug"
 version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "624a8340c38c1b80fd549087862da4ba43e08858af025b236e509b6649fc13d5"
 
 [[package]]
 name = "option-ext"
 version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d"
 
 [[package]]
 name = "os_str_bytes"
 version = "6.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7b5bf27447411e9ee3ff51186bf7a08e16c341efdde93f4d823e8844429bed7e"
 dependencies = [
  "memchr",
 ]
 
 [[package]]
 name = "output_vt100"
 version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "628223faebab4e3e40667ee0b2336d34a5b960ff60ea743ddfdbcf7770bcfb66"
 dependencies = [
  "winapi",
 ]
 
 [[package]]
 name = "paste"
 version = "1.0.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b1de2e551fb905ac83f73f7aedf2f0cb4a0da7e35efa24a202a936269f1f18e1"
 
 [[package]]
 name = "pkg-config"
 version = "0.3.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6ac9a59f73473f1b8d852421e59e64809f025994837ef743615c6d0c5b305160"
 
 [[package]]
 name = "ppv-lite86"
 version = "0.2.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"
 
 [[package]]
 name = "pretty_assertions"
 version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a25e9bcb20aa780fd0bb16b72403a9064d6b3f22f026946029acb941a50af755"
 dependencies = [
  "ctor",
  "diff",
  "output_vt100",
  "yansi",
 ]
 
 [[package]]
 name = "proc-macro-error"
 version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c"
 dependencies = [
  "proc-macro-error-attr",
  "proc-macro2",
  "quote",
  "syn",
  "version_check",
 ]
 
 [[package]]
 name = "proc-macro-error-attr"
 version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869"
 dependencies = [
  "proc-macro2",
  "quote",
  "version_check",
 ]
 
 [[package]]
 name = "proc-macro2"
 version = "1.0.47"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5ea3d908b0e36316caf9e9e2c4625cdde190a7e6f440d794667ed17a1855e725"
 dependencies = [
  "unicode-ident",
 ]
 
 [[package]]
 name = "python3-sys"
 version = "0.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0f53ef6740367a09718d2cd21ba15b0d7972342a38e554736bcee7773e45c9f5"
 dependencies = [
  "libc",
  "regex",
 ]
 
 [[package]]
 name = "quote"
 version = "1.0.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bbe448f377a7d6961e30f5955f9b8d106c3f5e449d493ee1b125c1d43c2b5179"
 dependencies = [
  "proc-macro2",
 ]
 
 [[package]]
 name = "radium"
 version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09"
 
 [[package]]
 name = "rand"
 version = "0.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6a6b1679d49b24bbfe0c803429aa1874472f50d9b363131f0e89fc356b544d03"
 dependencies = [
  "getrandom 0.1.16",
  "libc",
  "rand_chacha 0.2.2",
  "rand_core 0.5.1",
  "rand_hc",
 ]
 
 [[package]]
 name = "rand"
 version = "0.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
 dependencies = [
  "libc",
  "rand_chacha 0.3.1",
  "rand_core 0.6.4",
 ]
 
 [[package]]
 name = "rand_chacha"
 version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f4c8ed856279c9737206bf725bf36935d8666ead7aa69b52be55af369d193402"
 dependencies = [
  "ppv-lite86",
  "rand_core 0.5.1",
 ]
 
 [[package]]
 name = "rand_chacha"
 version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
 dependencies = [
  "ppv-lite86",
  "rand_core 0.6.4",
 ]
 
 [[package]]
 name = "rand_core"
 version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "90bde5296fc891b0cef12a6d03ddccc162ce7b2aff54160af9338f8d40df6d19"
 dependencies = [
  "getrandom 0.1.16",
 ]
 
 [[package]]
 name = "rand_core"
 version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
 dependencies = [
  "getrandom 0.2.8",
 ]
 
 [[package]]
 name = "rand_distr"
 version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "32cb0b9bc82b0a0876c2dd994a7e7a2683d3e7390ca40e6886785ef0c7e3ee31"
 dependencies = [
  "num-traits",
  "rand 0.8.5",
 ]
 
 [[package]]
 name = "rand_hc"
 version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ca3129af7b92a17112d59ad498c6f81eaf463253766b90396d39ea7a39d6613c"
 dependencies = [
  "rand_core 0.5.1",
 ]
 
 [[package]]
 name = "rand_pcg"
 version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "59cad018caf63deb318e5a4586d99a24424a364f40f1e5778c29aca23f4fc73e"
 dependencies = [
  "rand_core 0.6.4",
 ]
 
 [[package]]
 name = "rand_xoshiro"
 version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6f97cdb2a36ed4183de61b2f824cc45c9f1037f28afe0a322e9fff4c108b5aaa"
 dependencies = [
  "rand_core 0.6.4",
 ]
 
 [[package]]
 name = "rayon"
 version = "1.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1d2df5196e37bcc87abebc0053e20787d73847bb33134a69841207dd0a47f03b"
 dependencies = [
  "either",
  "rayon-core",
 ]
 
 [[package]]
 name = "rayon-core"
 version = "1.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4b8f95bd6966f5c87776639160a66bd8ab9895d9d4ab01ddba9fc60661aebe8d"
 dependencies = [
  "crossbeam-channel",
  "crossbeam-deque",
  "crossbeam-utils",
  "num_cpus",
 ]
 
 [[package]]
 name = "redox_syscall"
 version = "0.2.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fb5a58c1855b4b6819d59012155603f0b22ad30cad752600aadfcb695265519a"
 dependencies = [
  "bitflags 1.3.2",
 ]
 
 [[package]]
+name = "redox_syscall"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2a908a6e00f1fdd0dfd9c0eb08ce85126f6d8bbda50017e74bc4a4b7d4a926a4"
+dependencies = [
+ "bitflags 2.6.0",
+]
+
+[[package]]
 name = "redox_users"
 version = "0.4.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bd283d9651eeda4b2a83a43c1c91b266c40fd76ecd39a50a8c630ae69dc72891"
 dependencies = [
  "getrandom 0.2.8",
  "libredox",
  "thiserror",
 ]
 
 [[package]]
 name = "regex"
 version = "1.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e076559ef8e241f2ae3479e36f97bd5741c0330689e217ad51ce2c76808b868a"
 dependencies = [
  "aho-corasick",
  "memchr",
  "regex-syntax",
 ]
 
 [[package]]
 name = "regex-automata"
 version = "0.3.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "59b23e92ee4318893fa3fe3e6fb365258efbfe6ac6ab30f090cdcbb7aa37efa9"
 
 [[package]]
 name = "regex-syntax"
 version = "0.6.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "456c603be3e8d448b072f410900c09faf164fbce2d480456f50eea6e25f9c848"
 
 [[package]]
 name = "remove_dir_all"
 version = "0.5.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3acd125665422973a33ac9d3dd2df85edad0f4ae9b00dafb1a05e43a9f5ef8e7"
 dependencies = [
  "winapi",
 ]
 
 [[package]]
 name = "rhg"
 version = "0.1.0"
 dependencies = [
  "atty",
  "chrono",
  "clap",
  "derive_more",
  "env_logger",
  "format-bytes",
  "hg-core",
  "home",
  "lazy_static",
  "libc",
  "log",
  "logging_timer",
  "rayon",
  "regex",
  "shellexpand",
  "which",
  "whoami",
 ]
 
 [[package]]
 name = "rustc_version"
 version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bfa0f585226d2e68097d4f95d113b15b83a82e819ab25717ec0590d9584ef366"
 dependencies = [
  "semver",
 ]
 
 [[package]]
 name = "same-file"
 version = "1.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
 dependencies = [
  "winapi-util",
 ]
 
 [[package]]
 name = "scopeguard"
 version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
 
 [[package]]
 name = "scratch"
 version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9c8132065adcfd6e02db789d9285a0deb2f3fcb04002865ab67d5fb103533898"
 
 [[package]]
 name = "self_cell"
 version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4a3926e239738d36060909ffe6f511502f92149a45a1fade7fe031cb2d33e88b"
 
 [[package]]
 name = "semver"
 version = "1.0.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e25dfac463d778e353db5be2449d1cce89bd6fd23c9f1ea21310ce6e5a1b29c4"
 
 [[package]]
 name = "serde"
 version = "1.0.152"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bb7d1f0d3021d347a83e556fc4683dea2ea09d87bccdf88ff5c12545d89d5efb"
 dependencies = [
  "serde_derive",
 ]
 
 [[package]]
 name = "serde_derive"
 version = "1.0.152"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "af487d118eecd09402d70a5d72551860e788df87b464af30e5ea6a38c75c541e"
 dependencies = [
  "proc-macro2",
  "quote",
  "syn",
 ]
 
 [[package]]
 name = "serde_spanned"
 version = "0.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0efd8caf556a6cebd3b285caf480045fcc1ac04f6bd786b09a6f11af30c4fcf4"
 dependencies = [
  "serde",
 ]
 
 [[package]]
 name = "sha-1"
 version = "0.9.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "99cd6713db3cf16b6c84e06321e049a9b9f699826e16096d23bbcc44d15d51a6"
 dependencies = [
  "block-buffer 0.9.0",
  "cfg-if",
  "cpufeatures",
  "digest 0.9.0",
  "opaque-debug",
 ]
 
 [[package]]
 name = "sha-1"
 version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "028f48d513f9678cda28f6e4064755b3fbb2af6acd672f2c209b62323f7aea0f"
 dependencies = [
  "cfg-if",
  "cpufeatures",
  "digest 0.10.5",
 ]
 
 [[package]]
 name = "shellexpand"
 version = "3.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "da03fa3b94cc19e3ebfc88c4229c49d8f08cdbd1228870a45f0ffdf84988e14b"
 dependencies = [
  "bstr",
  "dirs",
  "os_str_bytes",
 ]
 
 [[package]]
 name = "sized-chunks"
 version = "0.6.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "16d69225bde7a69b235da73377861095455d298f2b970996eec25ddbb42b3d1e"
 dependencies = [
  "bitmaps",
  "typenum",
 ]
 
 [[package]]
 name = "stable_deref_trait"
 version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3"
 
 [[package]]
 name = "static_assertions"
 version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
 
 [[package]]
 name = "strsim"
 version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"
 
 [[package]]
 name = "syn"
 version = "1.0.109"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"
 dependencies = [
  "proc-macro2",
  "quote",
  "unicode-ident",
 ]
 
 [[package]]
 name = "tap"
 version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
 
 [[package]]
 name = "tempfile"
 version = "3.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5cdb1ef4eaeeaddc8fbd371e5017057064af0911902ef36b39801f67cc6d79e4"
 dependencies = [
  "cfg-if",
  "fastrand",
  "libc",
- "redox_syscall",
+ "redox_syscall 0.2.16",
  "remove_dir_all",
  "winapi",
 ]
 
 [[package]]
 name = "termcolor"
 version = "1.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bab24d30b911b2376f3a13cc2cd443142f0c81dda04c118693e35b3835757755"
 dependencies = [
  "winapi-util",
 ]
 
 [[package]]
 name = "thiserror"
 version = "1.0.39"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a5ab016db510546d856297882807df8da66a16fb8c4101cb8b30054b0d5b2d9c"
 dependencies = [
  "thiserror-impl",
 ]
 
 [[package]]
 name = "thiserror-impl"
 version = "1.0.39"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5420d42e90af0c38c3290abcca25b9b3bdf379fc9f55c528f53a269d9c9a267e"
 dependencies = [
  "proc-macro2",
  "quote",
  "syn",
 ]
 
 [[package]]
 name = "thread_local"
 version = "1.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5516c27b78311c50bf42c071425c560ac799b11c30b31f87e3081965fe5e0180"
 dependencies = [
  "once_cell",
 ]
 
 [[package]]
 name = "toml"
 version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4fb9d890e4dc9298b70f740f615f2e05b9db37dce531f6b24fb77ac993f9f217"
 dependencies = [
  "serde",
  "serde_spanned",
  "toml_datetime",
  "toml_edit",
 ]
 
 [[package]]
 name = "toml_datetime"
 version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4553f467ac8e3d374bc9a177a26801e5d0f9b211aa1673fb137a403afd1c9cf5"
 dependencies = [
  "serde",
 ]
 
 [[package]]
 name = "toml_edit"
 version = "0.18.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "56c59d8dd7d0dcbc6428bf7aa2f0e823e26e43b3c9aca15bbc9475d23e5fa12b"
 dependencies = [
  "indexmap",
  "nom8",
  "serde",
  "serde_spanned",
  "toml_datetime",
 ]
 
 [[package]]
 name = "twox-hash"
 version = "1.6.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "97fee6b57c6a41524a810daee9286c02d7752c4253064d0b05472833a438f675"
 dependencies = [
  "cfg-if",
  "rand 0.8.5",
  "static_assertions",
 ]
 
 [[package]]
 name = "typenum"
 version = "1.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dcf81ac59edc17cc8697ff311e8f5ef2d99fcbd9817b34cec66f90b6c3dfd987"
 
 [[package]]
 name = "unicode-ident"
 version = "1.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6ceab39d59e4c9499d4e5a8ee0e2735b891bb7308ac83dfb4e80cad195c9f6f3"
 
 [[package]]
 name = "unicode-width"
 version = "0.1.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c0edd1e5b14653f783770bce4a4dabb4a5108a5370a5f5d8cfe8710c361f6c8b"
 
 [[package]]
 name = "vcpkg"
 version = "0.2.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
 
 [[package]]
 name = "vcsgraph"
 version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4cb68c231e2575f7503a7c19213875f9d4ec2e84e963a56ce3de4b6bee351ef7"
 dependencies = [
  "hex",
  "rand 0.7.3",
  "sha-1 0.9.8",
 ]
 
 [[package]]
 name = "version_check"
 version = "0.9.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
 
 [[package]]
 name = "wasi"
 version = "0.9.0+wasi-snapshot-preview1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cccddf32554fecc6acb585f82a32a72e28b48f8c4c1883ddfeeeaa96f7d8e519"
 
 [[package]]
 name = "wasi"
 version = "0.11.0+wasi-snapshot-preview1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
 
 [[package]]
 name = "wasm-bindgen"
 version = "0.2.83"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "eaf9f5aceeec8be17c128b2e93e031fb8a4d469bb9c4ae2d7dc1888b26887268"
 dependencies = [
  "cfg-if",
  "wasm-bindgen-macro",
 ]
 
 [[package]]
 name = "wasm-bindgen-backend"
 version = "0.2.83"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4c8ffb332579b0557b52d268b91feab8df3615f265d5270fec2a8c95b17c1142"
 dependencies = [
  "bumpalo",
  "log",
  "once_cell",
  "proc-macro2",
  "quote",
  "syn",
  "wasm-bindgen-shared",
 ]
 
 [[package]]
 name = "wasm-bindgen-macro"
 version = "0.2.83"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "052be0f94026e6cbc75cdefc9bae13fd6052cdcaf532fa6c45e7ae33a1e6c810"
 dependencies = [
  "quote",
  "wasm-bindgen-macro-support",
 ]
 
 [[package]]
 name = "wasm-bindgen-macro-support"
 version = "0.2.83"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "07bc0c051dc5f23e307b13285f9d75df86bfdf816c5721e573dec1f9b8aa193c"
 dependencies = [
  "proc-macro2",
  "quote",
  "syn",
  "wasm-bindgen-backend",
  "wasm-bindgen-shared",
 ]
 
 [[package]]
 name = "wasm-bindgen-shared"
 version = "0.2.83"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1c38c045535d93ec4f0b4defec448e4291638ee608530863b1e2ba115d4fff7f"
 
 [[package]]
 name = "web-sys"
 version = "0.3.60"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bcda906d8be16e728fd5adc5b729afad4e444e106ab28cd1c7256e54fa61510f"
 dependencies = [
  "js-sys",
  "wasm-bindgen",
 ]
 
 [[package]]
 name = "which"
 version = "4.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1c831fbbee9e129a8cf93e7747a82da9d95ba8e16621cae60ec2cdc849bacb7b"
 dependencies = [
  "either",
  "libc",
  "once_cell",
 ]
 
 [[package]]
 name = "whoami"
 version = "1.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2c70234412ca409cc04e864e89523cb0fc37f5e1344ebed5a3ebf4192b6b9f68"
 dependencies = [
  "wasm-bindgen",
  "web-sys",
 ]
 
 [[package]]
 name = "winapi"
 version = "0.3.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
 dependencies = [
  "winapi-i686-pc-windows-gnu",
  "winapi-x86_64-pc-windows-gnu",
 ]
 
 [[package]]
 name = "winapi-i686-pc-windows-gnu"
 version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
 
 [[package]]
 name = "winapi-util"
 version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178"
 dependencies = [
  "winapi",
 ]
 
 [[package]]
 name = "winapi-x86_64-pc-windows-gnu"
 version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 
 [[package]]
 name = "windows-sys"
 version = "0.48.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9"
 dependencies = [
  "windows-targets 0.48.5",
 ]
 
 [[package]]
+name = "windows-sys"
+version = "0.59.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
+dependencies = [
+ "windows-targets 0.52.6",
+]
+
+[[package]]
 name = "windows-targets"
 version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c"
 dependencies = [
  "windows_aarch64_gnullvm 0.48.5",
  "windows_aarch64_msvc 0.48.5",
  "windows_i686_gnu 0.48.5",
  "windows_i686_msvc 0.48.5",
  "windows_x86_64_gnu 0.48.5",
  "windows_x86_64_gnullvm 0.48.5",
  "windows_x86_64_msvc 0.48.5",
 ]
 
 [[package]]
 name = "windows-targets"
-version = "0.52.0"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a18201040b24831fbb9e4eb208f8892e1f50a37feb53cc7ff887feb8f50e7cd"
+checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
 dependencies = [
- "windows_aarch64_gnullvm 0.52.0",
- "windows_aarch64_msvc 0.52.0",
- "windows_i686_gnu 0.52.0",
- "windows_i686_msvc 0.52.0",
- "windows_x86_64_gnu 0.52.0",
- "windows_x86_64_gnullvm 0.52.0",
- "windows_x86_64_msvc 0.52.0",
+ "windows_aarch64_gnullvm 0.52.6",
+ "windows_aarch64_msvc 0.52.6",
+ "windows_i686_gnu 0.52.6",
+ "windows_i686_gnullvm",
+ "windows_i686_msvc 0.52.6",
+ "windows_x86_64_gnu 0.52.6",
+ "windows_x86_64_gnullvm 0.52.6",
+ "windows_x86_64_msvc 0.52.6",
 ]
 
 [[package]]
 name = "windows_aarch64_gnullvm"
 version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8"
 
 [[package]]
 name = "windows_aarch64_gnullvm"
-version = "0.52.0"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cb7764e35d4db8a7921e09562a0304bf2f93e0a51bfccee0bd0bb0b666b015ea"
+checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
 
 [[package]]
 name = "windows_aarch64_msvc"
 version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"
 
 [[package]]
 name = "windows_aarch64_msvc"
-version = "0.52.0"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bbaa0368d4f1d2aaefc55b6fcfee13f41544ddf36801e793edbbfd7d7df075ef"
+checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
 
 [[package]]
 name = "windows_i686_gnu"
 version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e"
 
 [[package]]
 name = "windows_i686_gnu"
-version = "0.52.0"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a28637cb1fa3560a16915793afb20081aba2c92ee8af57b4d5f28e4b3e7df313"
+checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
 
 [[package]]
 name = "windows_i686_msvc"
 version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"
 
 [[package]]
 name = "windows_i686_msvc"
-version = "0.52.0"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ffe5e8e31046ce6230cc7215707b816e339ff4d4d67c65dffa206fd0f7aa7b9a"
+checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
 
 [[package]]
 name = "windows_x86_64_gnu"
 version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e"
 
 [[package]]
 name = "windows_x86_64_gnu"
-version = "0.52.0"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3d6fa32db2bc4a2f5abeacf2b69f7992cd09dca97498da74a151a3132c26befd"
+checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
 
 [[package]]
 name = "windows_x86_64_gnullvm"
 version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc"
 
 [[package]]
 name = "windows_x86_64_gnullvm"
-version = "0.52.0"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1a657e1e9d3f514745a572a6846d3c7aa7dbe1658c056ed9c3344c4109a6949e"
+checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
 
 [[package]]
 name = "windows_x86_64_msvc"
 version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
 
 [[package]]
 name = "windows_x86_64_msvc"
-version = "0.52.0"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dff9641d1cd4be8d1a070daf9e3773c5f67e78b4d9d42263020c057706765c04"
+checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
 
 [[package]]
 name = "wyz"
 version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "05f360fc0b24296329c78fda852a1e9ae82de9cf7b27dae4b7f62f118f77b9ed"
 dependencies = [
  "tap",
 ]
 
 [[package]]
 name = "yansi"
 version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "09041cd90cf85f7f8b2df60c646f853b7f535ce68f85244eb6731cf89fa498ec"
 
 [[package]]
 name = "zstd"
 version = "0.12.3+zstd.1.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "76eea132fb024e0e13fd9c2f5d5d595d8a967aa72382ac2f9d39fcc95afd0806"
 dependencies = [
  "zstd-safe",
 ]
 
 [[package]]
 name = "zstd-safe"
 version = "6.0.4+zstd.1.5.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7afb4b54b8910cf5447638cb54bf4e8a65cbedd783af98b98c62ffe91f185543"
 dependencies = [
  "libc",
  "zstd-sys",
 ]
 
 [[package]]
 name = "zstd-sys"
 version = "2.0.7+zstd.1.5.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "94509c3ba2fe55294d752b79842c530ccfab760192521df74a081a78d2b3c7f5"
 dependencies = [
  "cc",
  "libc",
  "pkg-config",
 ]

rust/hg-core/Cargo.toml

@@ -1,54 +1,56
 [package]
 name = "hg-core"
 version = "0.1.0"
 authors = ["Georges Racinet <[e-mail]>"]
 description = "Mercurial pure Rust core library, with no assumption on Python bindings (FFI)"
 edition = "2021"
 
 [lib]
 name = "hg"
 
 [dependencies]
 bitflags = "1.3.2"
 bytes-cast = "0.3.0"
 byteorder = "1.4.3"
 derive_more = "0.99.17"
 hashbrown = { version = "0.13.1", features = ["rayon"] }
 home = "0.5.4"
 im-rc = "15.1.0"
 itertools = "0.10.5"
 lazy_static = "1.4.0"
 libc = "0.2.137"
 logging_timer = "1.1.0"
 rand = "0.8.5"
 rand_pcg = "0.3.1"
 rand_distr = "0.4.3"
 rayon = "1.7.0"
 regex = "1.7.0"
 self_cell = "1.0"
 serde = { version = "1.0", features = ["derive"] }
 sha-1 = "0.10.0"
 twox-hash = "1.6.3"
 same-file = "1.0.6"
 tempfile = "3.3.0"
 toml = "0.6"
 thread_local = "1.1.4"
 crossbeam-channel = "0.5.6"
 log = "0.4.17"
 memmap2 = { version = "0.5.8", features = ["stable_deref_trait"] }
 zstd = "0.12"
 format-bytes = "0.3.0"
 once_cell = "1.16.0"
 bitvec = "1.0.1"
 chrono = "0.4.34"
+dyn-clone = "1.0.16"
+filetime = "0.2.23"
 
 # We don't use the `miniz-oxide` backend to not change rhg benchmarks and until
 # we have a clearer view of which backend is the fastest.
 [dependencies.flate2]
 version = "1.0.24"
 features = ["zlib"]
 default-features = false
 
 [dev-dependencies]
 clap = { version = "~4.0", features = ["derive"] }
 pretty_assertions = "1.1.0"

rust/hg-core/src/lock.rs

@@ -1,188 +1,188
 //! Filesystem-based locks for local repositories
 
 use crate::errors::HgError;
 use crate::errors::HgResultExt;
-use crate::vfs::Vfs;
+use crate::vfs::VfsImpl;
 use std::io;
 use std::io::ErrorKind;
 
 #[derive(derive_more::From)]
 pub enum LockError {
     AlreadyHeld,
     #[from]
     Other(HgError),
 }
 
 /// Try to call `f` with the lock acquired, without waiting.
 ///
 /// If the lock is aready held, `f` is not called and `LockError::AlreadyHeld`
 /// is returned. `LockError::Io` is returned for any unexpected I/O error
 /// accessing the lock file, including for removing it after `f` was called.
 /// The return value of `f` is dropped in that case. If all is successful, the
 /// return value of `f` is forwarded.
 pub fn try_with_lock_no_wait<R>(
-    hg_vfs: Vfs,
+    hg_vfs: &VfsImpl,
     lock_filename: &str,
     f: impl FnOnce() -> R,
 ) -> Result<R, LockError> {
     let our_lock_data = &*OUR_LOCK_DATA;
     for _retry in 0..5 {
         match make_lock(hg_vfs, lock_filename, our_lock_data) {
             Ok(()) => {
                 let result = f();
                 unlock(hg_vfs, lock_filename)?;
                 return Ok(result);
             }
             Err(HgError::IoError { error, .. })
                 if error.kind() == ErrorKind::AlreadyExists =>
             {
                 let lock_data = read_lock(hg_vfs, lock_filename)?;
                 if lock_data.is_none() {
                     // Lock was apparently just released, retry acquiring it
                     continue;
                 }
                 if !lock_should_be_broken(&lock_data) {
                     return Err(LockError::AlreadyHeld);
                 }
                 // The lock file is left over from a process not running
                 // anymore. Break it, but with another lock to
                 // avoid a race.
                 break_lock(hg_vfs, lock_filename)?;
 
                 // Retry acquiring
             }
             Err(error) => Err(error)?,
         }
     }
     Err(LockError::AlreadyHeld)
 }
 
-fn break_lock(hg_vfs: Vfs, lock_filename: &str) -> Result<(), LockError> {
+fn break_lock(hg_vfs: &VfsImpl, lock_filename: &str) -> Result<(), LockError> {
     try_with_lock_no_wait(hg_vfs, &format!("{}.break", lock_filename), || {
         // Check again in case some other process broke and
         // acquired the lock in the meantime
         let lock_data = read_lock(hg_vfs, lock_filename)?;
         if !lock_should_be_broken(&lock_data) {
             return Err(LockError::AlreadyHeld);
         }
         Ok(hg_vfs.remove_file(lock_filename)?)
     })?
 }
 
 #[cfg(unix)]
 fn make_lock(
-    hg_vfs: Vfs,
+    hg_vfs: &VfsImpl,
     lock_filename: &str,
     data: &str,
 ) -> Result<(), HgError> {
     // Use a symbolic link because creating it is atomic.
     // The link’s "target" contains data not representing any path.
     let fake_symlink_target = data;
     hg_vfs.create_symlink(lock_filename, fake_symlink_target)
 }
 
 fn read_lock(
-    hg_vfs: Vfs,
+    hg_vfs: &VfsImpl,
     lock_filename: &str,
 ) -> Result<Option<String>, HgError> {
     let link_target =
         hg_vfs.read_link(lock_filename).io_not_found_as_none()?;
     if let Some(target) = link_target {
         let data = target
             .into_os_string()
             .into_string()
             .map_err(|_| HgError::corrupted("non-UTF-8 lock data"))?;
         Ok(Some(data))
     } else {
         Ok(None)
     }
 }
 
-fn unlock(hg_vfs: Vfs, lock_filename: &str) -> Result<(), HgError> {
+fn unlock(hg_vfs: &VfsImpl, lock_filename: &str) -> Result<(), HgError> {
     hg_vfs.remove_file(lock_filename)
 }
 
 /// Return whether the process that is/was holding the lock is known not to be
 /// running anymore.
 fn lock_should_be_broken(data: &Option<String>) -> bool {
     (|| -> Option<bool> {
         let (prefix, pid) = data.as_ref()?.split_once(':')?;
         if prefix != *LOCK_PREFIX {
             return Some(false);
         }
         let process_is_running;
 
         #[cfg(unix)]
         {
             let pid: libc::pid_t = pid.parse().ok()?;
             unsafe {
                 let signal = 0; // Test if we could send a signal, without sending
                 let result = libc::kill(pid, signal);
                 if result == 0 {
                     process_is_running = true
                 } else {
                     let errno =
                         io::Error::last_os_error().raw_os_error().unwrap();
                     process_is_running = errno != libc::ESRCH
                 }
             }
         }
 
         Some(!process_is_running)
     })()
     .unwrap_or(false)
 }
 
 lazy_static::lazy_static! {
     /// A string which is used to differentiate pid namespaces
     ///
     /// It's useful to detect "dead" processes and remove stale locks with
     /// confidence. Typically it's just hostname. On modern linux, we include an
     /// extra Linux-specific pid namespace identifier.
     static ref LOCK_PREFIX: String = {
         // Note: this must match the behavior of `_getlockprefix` in `mercurial/lock.py`
 
         /// Same as https://github.com/python/cpython/blob/v3.10.0/Modules/socketmodule.c#L5414
         const BUFFER_SIZE: usize = 1024;
         // This cast is *needed* for platforms with signed chars
         #[allow(clippy::unnecessary_cast)]
         let mut buffer = [0 as libc::c_char; BUFFER_SIZE];
         let hostname_bytes = unsafe {
             let result = libc::gethostname(buffer.as_mut_ptr(), BUFFER_SIZE);
             if result != 0 {
                 panic!("gethostname: {}", io::Error::last_os_error())
             }
             std::ffi::CStr::from_ptr(buffer.as_mut_ptr()).to_bytes()
         };
         let hostname =
             std::str::from_utf8(hostname_bytes).expect("non-UTF-8 hostname");
 
         #[cfg(target_os = "linux")]
         {
             use std::os::linux::fs::MetadataExt;
             match std::fs::metadata("/proc/self/ns/pid") {
                 Ok(meta) => {
                     return format!("{}/{:x}", hostname, meta.st_ino())
                 }
                 Err(error) => {
                     // TODO: match on `error.kind()` when `NotADirectory`
                     // is available on all supported Rust versions:
                     // https://github.com/rust-lang/rust/issues/86442
                     use libc::{
                         ENOENT, // ErrorKind::NotFound
                         ENOTDIR, // ErrorKind::NotADirectory
                         EACCES, // ErrorKind::PermissionDenied
                     };
                     match error.raw_os_error() {
                         Some(ENOENT) | Some(ENOTDIR) | Some(EACCES) => {}
                         _ => panic!("stat /proc/self/ns/pid: {}", error),
                     }
                 }
             }
         }
 
         hostname.to_owned()
     };
 
     static ref OUR_LOCK_DATA: String = format!("{}:{}", &*LOCK_PREFIX, std::process::id());
 }

rust/hg-core/src/logging.rs

@@ -1,101 +1,105
 use crate::errors::{HgError, HgResultExt, IoErrorContext, IoResultExt};
-use crate::vfs::Vfs;
+use crate::vfs::VfsImpl;
 use std::io::Write;
 
 /// An utility to append to a log file with the given name, and optionally
 /// rotate it after it reaches a certain maximum size.
 ///
 /// Rotation works by renaming "example.log" to "example.log.1", after renaming
 /// "example.log.1" to "example.log.2" etc up to the given maximum number of
 /// files.
 pub struct LogFile<'a> {
-    vfs: Vfs<'a>,
+    vfs: VfsImpl,
     name: &'a str,
     max_size: Option<u64>,
     max_files: u32,
 }
 
 impl<'a> LogFile<'a> {
-    pub fn new(vfs: Vfs<'a>, name: &'a str) -> Self {
+    pub fn new(vfs: VfsImpl, name: &'a str) -> Self {
         Self {
             vfs,
             name,
             max_size: None,
             max_files: 0,
         }
     }
 
     /// Rotate before writing to a log file that was already larger than the
     /// given size, in bytes. `None` disables rotation.
     pub fn max_size(mut self, value: Option<u64>) -> Self {
         self.max_size = value;
         self
     }
 
     /// Keep this many rotated files `{name}.1` up to `{name}.{max}`, in
     /// addition to the original `{name}` file.
     pub fn max_files(mut self, value: u32) -> Self {
         self.max_files = value;
         self
     }
 
     /// Append the given `bytes` as-is to the log file, after rotating if
     /// needed.
     ///
     /// No trailing newline is added. Make sure to include one in `bytes` if
     /// desired.
     pub fn write(&self, bytes: &[u8]) -> Result<(), HgError> {
         let path = self.vfs.join(self.name);
         let context = || IoErrorContext::WritingFile(path.clone());
         let open = || {
             std::fs::OpenOptions::new()
                 .create(true)
                 .append(true)
                 .open(&path)
                 .with_context(context)
         };
         let mut file = open()?;
         if let Some(max_size) = self.max_size {
             if file.metadata().with_context(context)?.len() >= max_size {
                 // For example with `max_files == 5`, the first iteration of
                 // this loop has `i == 4` and renames `{name}.4` to `{name}.5`.
                 // The last iteration renames `{name}.1` to
                 // `{name}.2`
                 for i in (1..self.max_files).rev() {
                     self.vfs
                         .rename(
                             format!("{}.{}", self.name, i),
                             format!("{}.{}", self.name, i + 1),
                         )
                         .io_not_found_as_none()?;
                 }
                 // Then rename `{name}` to `{name}.1`. This is the
                 // previously-opened `file`.
                 self.vfs
                     .rename(self.name, format!("{}.1", self.name))
                     .io_not_found_as_none()?;
                 // Finally, create a new `{name}` file and replace our `file`
                 // handle.
                 file = open()?;
             }
         }
         file.write_all(bytes).with_context(context)?;
         file.sync_all().with_context(context)
     }
 }
 
 #[test]
 fn test_rotation() {
     let temp = tempfile::tempdir().unwrap();
-    let vfs = Vfs { base: temp.path() };
-    let logger = LogFile::new(vfs, "log").max_size(Some(3)).max_files(2);
+    let vfs = VfsImpl {
+        base: temp.path().to_owned(),
+    };
+    let logger = LogFile::new(vfs.clone(), "log")
+        .max_size(Some(3))
+        .max_files(2);
     logger.write(b"one\n").unwrap();
     logger.write(b"two\n").unwrap();
     logger.write(b"3\n").unwrap();
     logger.write(b"four\n").unwrap();
     logger.write(b"five\n").unwrap();
     assert_eq!(vfs.read("log").unwrap(), b"five\n");
     assert_eq!(vfs.read("log.1").unwrap(), b"3\nfour\n");
     assert_eq!(vfs.read("log.2").unwrap(), b"two\n");
     assert!(vfs.read("log.3").io_not_found_as_none().unwrap().is_none());
 }

rust/hg-core/src/repo.rs

@@ -1,842 +1,851
 use crate::changelog::Changelog;
 use crate::config::{Config, ConfigError, ConfigParseError};
 use crate::dirstate::DirstateParents;
 use crate::dirstate_tree::dirstate_map::DirstateMapWriteMode;
 use crate::dirstate_tree::on_disk::Docket as DirstateDocket;
 use crate::dirstate_tree::owning::OwningDirstateMap;
 use crate::errors::HgResultExt;
 use crate::errors::{HgError, IoResultExt};
 use crate::lock::{try_with_lock_no_wait, LockError};
 use crate::manifest::{Manifest, Manifestlog};
 use crate::requirements::{
     CHANGELOGV2_REQUIREMENT, GENERALDELTA_REQUIREMENT, NODEMAP_REQUIREMENT,
     REVLOGV1_REQUIREMENT, REVLOGV2_REQUIREMENT,
 };
 use crate::revlog::filelog::Filelog;
 use crate::revlog::RevlogError;
 use crate::utils::debug::debug_wait_for_file_or_print;
 use crate::utils::files::get_path_from_bytes;
 use crate::utils::hg_path::HgPath;
 use crate::utils::SliceExt;
-use crate::vfs::{is_dir, is_file, Vfs};
+use crate::vfs::{is_dir, is_file, VfsImpl};
 use crate::{
     requirements, NodePrefix, RevlogDataConfig, RevlogDeltaConfig,
     RevlogFeatureConfig, RevlogType, RevlogVersionOptions, UncheckedRevision,
 };
 use crate::{DirstateError, RevlogOpenOptions};
 use std::cell::{Ref, RefCell, RefMut};
 use std::collections::HashSet;
 use std::io::Seek;
 use std::io::SeekFrom;
 use std::io::Write as IoWrite;
 use std::path::{Path, PathBuf};
 
 const V2_MAX_READ_ATTEMPTS: usize = 5;
 
 type DirstateMapIdentity = (Option<u64>, Option<Vec<u8>>, usize);
 
 /// A repository on disk
 pub struct Repo {
     working_directory: PathBuf,
     dot_hg: PathBuf,
     store: PathBuf,
     requirements: HashSet<String>,
     config: Config,
     dirstate_parents: LazyCell<DirstateParents>,
     dirstate_map: LazyCell<OwningDirstateMap>,
     changelog: LazyCell<Changelog>,
     manifestlog: LazyCell<Manifestlog>,
 }
 
 #[derive(Debug, derive_more::From)]
 pub enum RepoError {
     NotFound {
         at: PathBuf,
     },
     #[from]
     ConfigParseError(ConfigParseError),
     #[from]
     Other(HgError),
 }
 
 impl From<ConfigError> for RepoError {
     fn from(error: ConfigError) -> Self {
         match error {
             ConfigError::Parse(error) => error.into(),
             ConfigError::Other(error) => error.into(),
         }
     }
 }
 
 impl Repo {
     /// tries to find nearest repository root in current working directory or
     /// its ancestors
     pub fn find_repo_root() -> Result<PathBuf, RepoError> {
         let current_directory = crate::utils::current_dir()?;
         // ancestors() is inclusive: it first yields `current_directory`
         // as-is.
         for ancestor in current_directory.ancestors() {
             if is_dir(ancestor.join(".hg"))? {
                 return Ok(ancestor.to_path_buf());
             }
         }
         Err(RepoError::NotFound {
             at: current_directory,
         })
     }
 
     /// Find a repository, either at the given path (which must contain a `.hg`
     /// sub-directory) or by searching the current directory and its
     /// ancestors.
     ///
     /// A method with two very different "modes" like this usually a code smell
     /// to make two methods instead, but in this case an `Option` is what rhg
     /// sub-commands get from Clap for the `-R` / `--repository` CLI argument.
     /// Having two methods would just move that `if` to almost all callers.
     pub fn find(
         config: &Config,
         explicit_path: Option<PathBuf>,
     ) -> Result<Self, RepoError> {
         if let Some(root) = explicit_path {
             if is_dir(root.join(".hg"))? {
                 Self::new_at_path(root, config)
             } else if is_file(&root)? {
                 Err(HgError::unsupported("bundle repository").into())
             } else {
                 Err(RepoError::NotFound { at: root })
             }
         } else {
             let root = Self::find_repo_root()?;
             Self::new_at_path(root, config)
         }
     }
 
     /// To be called after checking that `.hg` is a sub-directory
     fn new_at_path(
         working_directory: PathBuf,
         config: &Config,
     ) -> Result<Self, RepoError> {
         let dot_hg = working_directory.join(".hg");
 
         let mut repo_config_files =
             vec![dot_hg.join("hgrc"), dot_hg.join("hgrc-not-shared")];
 
-        let hg_vfs = Vfs { base: &dot_hg };
-        let mut reqs = requirements::load_if_exists(hg_vfs)?;
+        let hg_vfs = VfsImpl {
+            base: dot_hg.to_owned(),
+        };
+        let mut reqs = requirements::load_if_exists(&hg_vfs)?;
         let relative =
             reqs.contains(requirements::RELATIVE_SHARED_REQUIREMENT);
         let shared =
             reqs.contains(requirements::SHARED_REQUIREMENT) || relative;
 
         // From `mercurial/localrepo.py`:
         //
         // if .hg/requires contains the sharesafe requirement, it means
         // there exists a `.hg/store/requires` too and we should read it
         // NOTE: presence of SHARESAFE_REQUIREMENT imply that store requirement
         // is present. We never write SHARESAFE_REQUIREMENT for a repo if store
         // is not present, refer checkrequirementscompat() for that
         //
         // However, if SHARESAFE_REQUIREMENT is not present, it means that the
         // repository was shared the old way. We check the share source
         // .hg/requires for SHARESAFE_REQUIREMENT to detect whether the
         // current repository needs to be reshared
         let share_safe = reqs.contains(requirements::SHARESAFE_REQUIREMENT);
 
         let store_path;
         if !shared {
             store_path = dot_hg.join("store");
         } else {
             let bytes = hg_vfs.read("sharedpath")?;
             let mut shared_path =
                 get_path_from_bytes(bytes.trim_end_matches(|b| b == b'\n'))
                     .to_owned();
             if relative {
                 shared_path = dot_hg.join(shared_path)
             }
             if !is_dir(&shared_path)? {
                 return Err(HgError::corrupted(format!(
                     ".hg/sharedpath points to nonexistent directory {}",
                     shared_path.display()
                 ))
                 .into());
             }
 
             store_path = shared_path.join("store");
 
-            let source_is_share_safe =
-                requirements::load(Vfs { base: &shared_path })?
-                    .contains(requirements::SHARESAFE_REQUIREMENT);
+            let source_is_share_safe = requirements::load(VfsImpl {
+                base: shared_path.to_owned(),
+            })?
+            .contains(requirements::SHARESAFE_REQUIREMENT);
 
             if share_safe != source_is_share_safe {
                 return Err(HgError::unsupported("share-safe mismatch").into());
             }
 
             if share_safe {
                 repo_config_files.insert(0, shared_path.join("hgrc"))
             }
         }
         if share_safe {
-            reqs.extend(requirements::load(Vfs { base: &store_path })?);
+            reqs.extend(requirements::load(VfsImpl {
+                base: store_path.to_owned(),
+            })?);
         }
 
         let repo_config = if std::env::var_os("HGRCSKIPREPO").is_none() {
             config.combine_with_repo(&repo_config_files)?
         } else {
             config.clone()
         };
 
         let repo = Self {
             requirements: reqs,
             working_directory,
             store: store_path,
             dot_hg,
             config: repo_config,
             dirstate_parents: LazyCell::new(),
             dirstate_map: LazyCell::new(),
             changelog: LazyCell::new(),
             manifestlog: LazyCell::new(),
         };
 
         requirements::check(&repo)?;
 
         Ok(repo)
     }
 
     pub fn working_directory_path(&self) -> &Path {
         &self.working_directory
     }
 
     pub fn requirements(&self) -> &HashSet<String> {
         &self.requirements
     }
 
     pub fn config(&self) -> &Config {
         &self.config
     }
 
     /// For accessing repository files (in `.hg`), except for the store
     /// (`.hg/store`).
-    pub fn hg_vfs(&self) -> Vfs<'_> {
-        Vfs { base: &self.dot_hg }
+    pub fn hg_vfs(&self) -> VfsImpl {
+        VfsImpl {
+            base: self.dot_hg.to_owned(),
+        }
     }
 
     /// For accessing repository store files (in `.hg/store`)
-    pub fn store_vfs(&self) -> Vfs<'_> {
-        Vfs { base: &self.store }
+    pub fn store_vfs(&self) -> VfsImpl {
+        VfsImpl {
+            base: self.store.to_owned(),
+        }
     }
 
     /// For accessing the working copy
-    pub fn working_directory_vfs(&self) -> Vfs<'_> {
-        Vfs {
-            base: &self.working_directory,
+    pub fn working_directory_vfs(&self) -> VfsImpl {
+        VfsImpl {
+            base: self.working_directory.to_owned(),
         }
     }
 
     pub fn try_with_wlock_no_wait<R>(
         &self,
         f: impl FnOnce() -> R,
     ) -> Result<R, LockError> {
-        try_with_lock_no_wait(self.hg_vfs(), "wlock", f)
+        try_with_lock_no_wait(&self.hg_vfs(), "wlock", f)
     }
 
     /// Whether this repo should use dirstate-v2.
     /// The presence of `dirstate-v2` in the requirements does not mean that
     /// the on-disk dirstate is necessarily in version 2. In most cases,
     /// a dirstate-v2 file will indeed be found, but in rare cases (like the
     /// upgrade mechanism being cut short), the on-disk version will be a
     /// v1 file.
     /// Semantically, having a requirement only means that a client cannot
     /// properly understand or properly update the repo if it lacks the support
     /// for the required feature, but not that that feature is actually used
     /// in all occasions.
     pub fn use_dirstate_v2(&self) -> bool {
         self.requirements
             .contains(requirements::DIRSTATE_V2_REQUIREMENT)
     }
 
     pub fn has_sparse(&self) -> bool {
         self.requirements.contains(requirements::SPARSE_REQUIREMENT)
     }
 
     pub fn has_narrow(&self) -> bool {
         self.requirements.contains(requirements::NARROW_REQUIREMENT)
     }
 
     pub fn has_nodemap(&self) -> bool {
         self.requirements
             .contains(requirements::NODEMAP_REQUIREMENT)
     }
 
     fn dirstate_file_contents(&self) -> Result<Vec<u8>, HgError> {
         Ok(self
             .hg_vfs()
             .read("dirstate")
             .io_not_found_as_none()?
             .unwrap_or_default())
     }
 
     fn dirstate_identity(&self) -> Result<Option<u64>, HgError> {
         use std::os::unix::fs::MetadataExt;
         Ok(self
             .hg_vfs()
             .symlink_metadata("dirstate")
             .io_not_found_as_none()?
             .map(|meta| meta.ino()))
     }
 
     pub fn dirstate_parents(&self) -> Result<DirstateParents, HgError> {
         Ok(*self
             .dirstate_parents
             .get_or_init(|| self.read_dirstate_parents())?)
     }
 
     fn read_dirstate_parents(&self) -> Result<DirstateParents, HgError> {
         let dirstate = self.dirstate_file_contents()?;
         let parents = if dirstate.is_empty() {
             DirstateParents::NULL
         } else if self.use_dirstate_v2() {
             let docket_res =
                 crate::dirstate_tree::on_disk::read_docket(&dirstate);
             match docket_res {
                 Ok(docket) => docket.parents(),
                 Err(_) => {
                     log::info!(
                         "Parsing dirstate docket failed, \
                         falling back to dirstate-v1"
                     );
                     *crate::dirstate::parsers::parse_dirstate_parents(
                         &dirstate,
                     )?
                 }
             }
         } else {
             *crate::dirstate::parsers::parse_dirstate_parents(&dirstate)?
         };
         self.dirstate_parents.set(parents);
         Ok(parents)
     }
 
     /// Returns the information read from the dirstate docket necessary to
     /// check if the data file has been updated/deleted by another process
     /// since we last read the dirstate.
     /// Namely, the inode, data file uuid and the data size.
     fn get_dirstate_data_file_integrity(
         &self,
     ) -> Result<DirstateMapIdentity, HgError> {
         assert!(
             self.use_dirstate_v2(),
             "accessing dirstate data file ID without dirstate-v2"
         );
         // Get the identity before the contents since we could have a race
         // between the two. Having an identity that is too old is fine, but
         // one that is younger than the content change is bad.
         let identity = self.dirstate_identity()?;
         let dirstate = self.dirstate_file_contents()?;
         if dirstate.is_empty() {
             self.dirstate_parents.set(DirstateParents::NULL);
             Ok((identity, None, 0))
         } else {
             let docket_res =
                 crate::dirstate_tree::on_disk::read_docket(&dirstate);
             match docket_res {
                 Ok(docket) => {
                     self.dirstate_parents.set(docket.parents());
                     Ok((
                         identity,
                         Some(docket.uuid.to_owned()),
                         docket.data_size(),
                     ))
                 }
                 Err(_) => {
                     log::info!(
                         "Parsing dirstate docket failed, \
                         falling back to dirstate-v1"
                     );
                     let parents =
                         *crate::dirstate::parsers::parse_dirstate_parents(
                             &dirstate,
                         )?;
                     self.dirstate_parents.set(parents);
                     Ok((identity, None, 0))
                 }
             }
         }
     }
 
     fn new_dirstate_map(&self) -> Result<OwningDirstateMap, DirstateError> {
         if self.use_dirstate_v2() {
             // The v2 dirstate is split into a docket and a data file.
             // Since we don't always take the `wlock` to read it
             // (like in `hg status`), it is susceptible to races.
             // A simple retry method should be enough since full rewrites
             // only happen when too much garbage data is present and
             // this race is unlikely.
             let mut tries = 0;
 
             while tries < V2_MAX_READ_ATTEMPTS {
                 tries += 1;
                 match self.read_docket_and_data_file() {
                     Ok(m) => {
                         return Ok(m);
                     }
                     Err(e) => match e {
                         DirstateError::Common(HgError::RaceDetected(
                             context,
                         )) => {
                             log::info!(
                                 "dirstate read race detected {} (retry {}/{})",
                                 context,
                                 tries,
                                 V2_MAX_READ_ATTEMPTS,
                             );
                             continue;
                         }
                         _ => {
                             log::info!(
                                 "Reading dirstate v2 failed, \
                                 falling back to v1"
                             );
                             return self.new_dirstate_map_v1();
                         }
                     },
                 }
             }
             let error = HgError::abort(
                 format!("dirstate read race happened {tries} times in a row"),
                 255,
                 None,
             );
             Err(DirstateError::Common(error))
         } else {
             self.new_dirstate_map_v1()
         }
     }
 
     fn new_dirstate_map_v1(&self) -> Result<OwningDirstateMap, DirstateError> {
         debug_wait_for_file_or_print(self.config(), "dirstate.pre-read-file");
         let identity = self.dirstate_identity()?;
         let dirstate_file_contents = self.dirstate_file_contents()?;
         if dirstate_file_contents.is_empty() {
             self.dirstate_parents.set(DirstateParents::NULL);
             Ok(OwningDirstateMap::new_empty(Vec::new()))
         } else {
             let (map, parents) =
                 OwningDirstateMap::new_v1(dirstate_file_contents, identity)?;
             self.dirstate_parents.set(parents);
             Ok(map)
         }
     }
 
     fn read_docket_and_data_file(
         &self,
     ) -> Result<OwningDirstateMap, DirstateError> {
         debug_wait_for_file_or_print(self.config(), "dirstate.pre-read-file");
         let dirstate_file_contents = self.dirstate_file_contents()?;
         let identity = self.dirstate_identity()?;
         if dirstate_file_contents.is_empty() {
             self.dirstate_parents.set(DirstateParents::NULL);
             return Ok(OwningDirstateMap::new_empty(Vec::new()));
         }
         let docket = crate::dirstate_tree::on_disk::read_docket(
             &dirstate_file_contents,
         )?;
         debug_wait_for_file_or_print(
             self.config(),
             "dirstate.post-docket-read-file",
         );
         self.dirstate_parents.set(docket.parents());
         let uuid = docket.uuid.to_owned();
         let data_size = docket.data_size();
 
         let context = "between reading dirstate docket and data file";
         let race_error = HgError::RaceDetected(context.into());
         let metadata = docket.tree_metadata();
 
         let mut map = if crate::vfs::is_on_nfs_mount(docket.data_filename()) {
             // Don't mmap on NFS to prevent `SIGBUS` error on deletion
             let contents = self.hg_vfs().read(docket.data_filename());
             let contents = match contents {
                 Ok(c) => c,
                 Err(HgError::IoError { error, context }) => {
                     match error.raw_os_error().expect("real os error") {
                         // 2 = ENOENT, No such file or directory
                         // 116 = ESTALE, Stale NFS file handle
                         //
                         // TODO match on `error.kind()` when
                         // `ErrorKind::StaleNetworkFileHandle` is stable.
                         2 | 116 => {
                             // Race where the data file was deleted right after
                             // we read the docket, try again
                             return Err(race_error.into());
                         }
                         _ => {
                             return Err(
                                 HgError::IoError { error, context }.into()
                             )
                         }
                     }
                 }
                 Err(e) => return Err(e.into()),
             };
             OwningDirstateMap::new_v2(
                 contents, data_size, metadata, uuid, identity,
             )
         } else {
             match self
                 .hg_vfs()
                 .mmap_open(docket.data_filename())
                 .io_not_found_as_none()
             {
                 Ok(Some(data_mmap)) => OwningDirstateMap::new_v2(
                     data_mmap, data_size, metadata, uuid, identity,
                 ),
                 Ok(None) => {
                     // Race where the data file was deleted right after we
                     // read the docket, try again
                     return Err(race_error.into());
                 }
                 Err(e) => return Err(e.into()),
             }
         }?;
 
         let write_mode_config = self
             .config()
             .get_str(b"devel", b"dirstate.v2.data_update_mode")
             .unwrap_or(Some("auto"))
             .unwrap_or("auto"); // don't bother for devel options
         let write_mode = match write_mode_config {
             "auto" => DirstateMapWriteMode::Auto,
             "force-new" => DirstateMapWriteMode::ForceNewDataFile,
             "force-append" => DirstateMapWriteMode::ForceAppend,
             _ => DirstateMapWriteMode::Auto,
         };
 
         map.with_dmap_mut(|m| m.set_write_mode(write_mode));
 
         Ok(map)
     }
 
     pub fn dirstate_map(
         &self,
     ) -> Result<Ref<OwningDirstateMap>, DirstateError> {
         self.dirstate_map.get_or_init(|| self.new_dirstate_map())
     }
 
     pub fn dirstate_map_mut(
         &self,
     ) -> Result<RefMut<OwningDirstateMap>, DirstateError> {
         self.dirstate_map
             .get_mut_or_init(|| self.new_dirstate_map())
     }
 
     fn new_changelog(&self) -> Result<Changelog, HgError> {
         Changelog::open(
             &self.store_vfs(),
             self.default_revlog_options(RevlogType::Changelog)?,
         )
     }
 
     pub fn changelog(&self) -> Result<Ref<Changelog>, HgError> {
         self.changelog.get_or_init(|| self.new_changelog())
     }
 
     pub fn changelog_mut(&self) -> Result<RefMut<Changelog>, HgError> {
         self.changelog.get_mut_or_init(|| self.new_changelog())
     }
 
     fn new_manifestlog(&self) -> Result<Manifestlog, HgError> {
         Manifestlog::open(
             &self.store_vfs(),
             self.default_revlog_options(RevlogType::Manifestlog)?,
         )
     }
 
     pub fn manifestlog(&self) -> Result<Ref<Manifestlog>, HgError> {
         self.manifestlog.get_or_init(|| self.new_manifestlog())
     }
 
     pub fn manifestlog_mut(&self) -> Result<RefMut<Manifestlog>, HgError> {
         self.manifestlog.get_mut_or_init(|| self.new_manifestlog())
     }
 
     /// Returns the manifest of the *changeset* with the given node ID
     pub fn manifest_for_node(
         &self,
         node: impl Into<NodePrefix>,
     ) -> Result<Manifest, RevlogError> {
         self.manifestlog()?.data_for_node(
             self.changelog()?
                 .data_for_node(node.into())?
                 .manifest_node()?
                 .into(),
         )
     }
 
     /// Returns the manifest of the *changeset* with the given revision number
     pub fn manifest_for_rev(
         &self,
         revision: UncheckedRevision,
     ) -> Result<Manifest, RevlogError> {
         self.manifestlog()?.data_for_node(
             self.changelog()?
                 .data_for_rev(revision)?
                 .manifest_node()?
                 .into(),
         )
     }
 
     pub fn has_subrepos(&self) -> Result<bool, DirstateError> {
         if let Some(entry) = self.dirstate_map()?.get(HgPath::new(".hgsub"))? {
             Ok(entry.tracked())
         } else {
             Ok(false)
         }
     }
 
     pub fn filelog(&self, path: &HgPath) -> Result<Filelog, HgError> {
         Filelog::open(
             self,
             path,
             self.default_revlog_options(RevlogType::Filelog)?,
         )
     }
     /// Write to disk any updates that were made through `dirstate_map_mut`.
     ///
     /// The "wlock" must be held while calling this.
     /// See for example `try_with_wlock_no_wait`.
     ///
     /// TODO: have a `WritableRepo` type only accessible while holding the
     /// lock?
     pub fn write_dirstate(&self) -> Result<(), DirstateError> {
         let map = self.dirstate_map()?;
         // TODO: Maintain a `DirstateMap::dirty` flag, and return early here if
         // it’s unset
         let parents = self.dirstate_parents()?;
         let (packed_dirstate, old_uuid_to_remove) = if self.use_dirstate_v2() {
             let (identity, uuid, data_size) =
                 self.get_dirstate_data_file_integrity()?;
             let identity_changed = identity != map.old_identity();
             let uuid_changed = uuid.as_deref() != map.old_uuid();
             let data_length_changed = data_size != map.old_data_size();
 
             if identity_changed || uuid_changed || data_length_changed {
                 // If any of identity, uuid or length have changed since
                 // last disk read, don't write.
                 // This is fine because either we're in a command that doesn't
                 // write anything too important (like `hg status`), or we're in
                 // `hg add` and we're supposed to have taken the lock before
                 // reading anyway.
                 //
                 // TODO complain loudly if we've changed anything important
                 // without taking the lock.
                 // (see `hg help config.format.use-dirstate-tracked-hint`)
                 log::debug!(
                     "dirstate has changed since last read, not updating."
                 );
                 return Ok(());
             }
 
             let uuid_opt = map.old_uuid();
             let write_mode = if uuid_opt.is_some() {
                 DirstateMapWriteMode::Auto
             } else {
                 DirstateMapWriteMode::ForceNewDataFile
             };
             let (data, tree_metadata, append, old_data_size) =
                 map.pack_v2(write_mode)?;
 
             // Reuse the uuid, or generate a new one, keeping the old for
             // deletion.
             let (uuid, old_uuid) = match uuid_opt {
                 Some(uuid) => {
                     let as_str = std::str::from_utf8(uuid)
                         .map_err(|_| {
                             HgError::corrupted(
                                 "non-UTF-8 dirstate data file ID",
                             )
                         })?
                         .to_owned();
                     if append {
                         (as_str, None)
                     } else {
                         (DirstateDocket::new_uid(), Some(as_str))
                     }
                 }
                 None => (DirstateDocket::new_uid(), None),
             };
 
             let data_filename = format!("dirstate.{}", uuid);
             let data_filename = self.hg_vfs().join(data_filename);
             let mut options = std::fs::OpenOptions::new();
             options.write(true);
 
             // Why are we not using the O_APPEND flag when appending?
             //
             // - O_APPEND makes it trickier to deal with garbage at the end of
             //   the file, left by a previous uncommitted transaction. By
             //   starting the write at [old_data_size] we make sure we erase
             //   all such garbage.
             //
             // - O_APPEND requires to special-case 0-byte writes, whereas we
             //   don't need that.
             //
             // - Some OSes have bugs in implementation O_APPEND:
             //   revlog.py talks about a Solaris bug, but we also saw some ZFS
             //   bug: https://github.com/openzfs/zfs/pull/3124,
             //   https://github.com/openzfs/zfs/issues/13370
             //
             if !append {
                 log::trace!("creating a new dirstate data file");
                 options.create_new(true);
             } else {
                 log::trace!("appending to the dirstate data file");
             }
 
             let data_size = (|| {
                 // TODO: loop and try another random ID if !append and this
                 // returns `ErrorKind::AlreadyExists`? Collision chance of two
                 // random IDs is one in 2**32
                 let mut file = options.open(&data_filename)?;
                 if append {
                     file.seek(SeekFrom::Start(old_data_size as u64))?;
                 }
                 file.write_all(&data)?;
                 file.flush()?;
                 file.stream_position()
             })()
             .when_writing_file(&data_filename)?;
 
             let packed_dirstate = DirstateDocket::serialize(
                 parents,
                 tree_metadata,
                 data_size,
                 uuid.as_bytes(),
             )
             .map_err(|_: std::num::TryFromIntError| {
                 HgError::corrupted("overflow in dirstate docket serialization")
             })?;
 
             (packed_dirstate, old_uuid)
         } else {
             let identity = self.dirstate_identity()?;
             if identity != map.old_identity() {
                 // If identity changed since last disk read, don't write.
                 // This is fine because either we're in a command that doesn't
                 // write anything too important (like `hg status`), or we're in
                 // `hg add` and we're supposed to have taken the lock before
                 // reading anyway.
                 //
                 // TODO complain loudly if we've changed anything important
                 // without taking the lock.
                 // (see `hg help config.format.use-dirstate-tracked-hint`)
                 log::debug!(
                     "dirstate has changed since last read, not updating."
                 );
                 return Ok(());
             }
             (map.pack_v1(parents)?, None)
         };
 
         let vfs = self.hg_vfs();
         vfs.atomic_write("dirstate", &packed_dirstate)?;
         if let Some(uuid) = old_uuid_to_remove {
             // Remove the old data file after the new docket pointing to the
             // new data file was written.
             vfs.remove_file(format!("dirstate.{}", uuid))?;
         }
         Ok(())
     }
 
     pub fn default_revlog_options(
         &self,
         revlog_type: RevlogType,
     ) -> Result<RevlogOpenOptions, HgError> {
         let requirements = self.requirements();
         let is_changelog = revlog_type == RevlogType::Changelog;
         let version = if is_changelog
             && requirements.contains(CHANGELOGV2_REQUIREMENT)
         {
             let compute_rank = self
                 .config()
                 .get_bool(b"experimental", b"changelog-v2.compute-rank")?;
             RevlogVersionOptions::ChangelogV2 { compute_rank }
         } else if requirements.contains(REVLOGV2_REQUIREMENT) {
             RevlogVersionOptions::V2
         } else if requirements.contains(REVLOGV1_REQUIREMENT) {
             RevlogVersionOptions::V1 {
                 general_delta: requirements.contains(GENERALDELTA_REQUIREMENT),
                 inline: !is_changelog,
             }
         } else {
             RevlogVersionOptions::V0
         };
         Ok(RevlogOpenOptions {
             version,
             // We don't need to dance around the slow path like in the Python
             // implementation since we know we have access to the fast code.
             use_nodemap: requirements.contains(NODEMAP_REQUIREMENT),
             delta_config: RevlogDeltaConfig::new(
                 self.config(),
                 self.requirements(),
                 revlog_type,
             )?,
             data_config: RevlogDataConfig::new(
                 self.config(),
                 self.requirements(),
             )?,
             feature_config: RevlogFeatureConfig::new(
                 self.config(),
                 requirements,
             )?,
         })
     }
 }
 
 /// Lazily-initialized component of `Repo` with interior mutability
 ///
 /// This differs from `OnceCell` in that the value can still be "deinitialized"
 /// later by setting its inner `Option` to `None`. It also takes the
 /// initialization function as an argument when the value is requested, not
 /// when the instance is created.
 struct LazyCell<T> {
     value: RefCell<Option<T>>,
 }
 
 impl<T> LazyCell<T> {
     fn new() -> Self {
         Self {
             value: RefCell::new(None),
         }
     }
 
     fn set(&self, value: T) {
         *self.value.borrow_mut() = Some(value)
     }
 
     fn get_or_init<E>(
         &self,
         init: impl Fn() -> Result<T, E>,
     ) -> Result<Ref<T>, E> {
         let mut borrowed = self.value.borrow();
         if borrowed.is_none() {
             drop(borrowed);
             // Only use `borrow_mut` if it is really needed to avoid panic in
             // case there is another outstanding borrow but mutation is not
             // needed.
             *self.value.borrow_mut() = Some(init()?);
             borrowed = self.value.borrow()
         }
         Ok(Ref::map(borrowed, |option| option.as_ref().unwrap()))
     }
 
     fn get_mut_or_init<E>(
         &self,
         init: impl Fn() -> Result<T, E>,
     ) -> Result<RefMut<T>, E> {
         let mut borrowed = self.value.borrow_mut();
         if borrowed.is_none() {
             *borrowed = Some(init()?);
         }
         Ok(RefMut::map(borrowed, |option| option.as_mut().unwrap()))
     }
 }

rust/hg-core/src/requirements.rs

@@ -1,183 +1,185
 use crate::errors::{HgError, HgResultExt};
 use crate::repo::Repo;
 use crate::utils::join_display;
-use crate::vfs::Vfs;
+use crate::vfs::VfsImpl;
 use std::collections::HashSet;
 
 fn parse(bytes: &[u8]) -> Result<HashSet<String>, HgError> {
     // The Python code reading this file uses `str.splitlines`
     // which looks for a number of line separators (even including a couple of
     // non-ASCII ones), but Python code writing it always uses `\n`.
     let lines = bytes.split(|&byte| byte == b'\n');
 
     lines
         .filter(|line| !line.is_empty())
         .map(|line| {
             // Python uses Unicode `str.isalnum` but feature names are all
             // ASCII
             if line[0].is_ascii_alphanumeric() && line.is_ascii() {
                 Ok(String::from_utf8(line.into()).unwrap())
             } else {
                 Err(HgError::corrupted("parse error in 'requires' file"))
             }
         })
         .collect()
 }
 
-pub(crate) fn load(hg_vfs: Vfs) -> Result<HashSet<String>, HgError> {
+pub(crate) fn load(hg_vfs: VfsImpl) -> Result<HashSet<String>, HgError> {
     parse(&hg_vfs.read("requires")?)
 }
 
-pub(crate) fn load_if_exists(hg_vfs: Vfs) -> Result<HashSet<String>, HgError> {
+pub(crate) fn load_if_exists(
+    hg_vfs: &VfsImpl,
+) -> Result<HashSet<String>, HgError> {
     if let Some(bytes) = hg_vfs.read("requires").io_not_found_as_none()? {
         parse(&bytes)
     } else {
         // Treat a missing file the same as an empty file.
         // From `mercurial/localrepo.py`:
         // > requires file contains a newline-delimited list of
         // > features/capabilities the opener (us) must have in order to use
         // > the repository. This file was introduced in Mercurial 0.9.2,
         // > which means very old repositories may not have one. We assume
         // > a missing file translates to no requirements.
         Ok(HashSet::new())
     }
 }
 
 pub(crate) fn check(repo: &Repo) -> Result<(), HgError> {
     let unknown: Vec<_> = repo
         .requirements()
         .iter()
         .map(String::as_str)
         // .filter(|feature| !ALL_SUPPORTED.contains(feature.as_str()))
         .filter(|feature| {
             !REQUIRED.contains(feature) && !SUPPORTED.contains(feature)
         })
         .collect();
     if !unknown.is_empty() {
         return Err(HgError::unsupported(format!(
             "repository requires feature unknown to this Mercurial: {}",
             join_display(&unknown, ", ")
         )));
     }
     let missing: Vec<_> = REQUIRED
         .iter()
         .filter(|&&feature| !repo.requirements().contains(feature))
         .collect();
     if !missing.is_empty() {
         return Err(HgError::unsupported(format!(
             "repository is missing feature required by this Mercurial: {}",
             join_display(&missing, ", ")
         )));
     }
     Ok(())
 }
 
 /// rhg does not support repositories that are *missing* any of these features
 const REQUIRED: &[&str] = &["revlogv1", "store", "fncache", "dotencode"];
 
 /// rhg supports repository with or without these
 const SUPPORTED: &[&str] = &[
     GENERALDELTA_REQUIREMENT,
     SHARED_REQUIREMENT,
     SHARESAFE_REQUIREMENT,
     SPARSEREVLOG_REQUIREMENT,
     RELATIVE_SHARED_REQUIREMENT,
     REVLOG_COMPRESSION_ZSTD,
     DIRSTATE_V2_REQUIREMENT,
     DIRSTATE_TRACKED_HINT_V1,
     // As of this writing everything rhg does is read-only.
     // When it starts writing to the repository, it’ll need to either keep the
     // persistent nodemap up to date or remove this entry:
     NODEMAP_REQUIREMENT,
     // Not all commands support `sparse` and `narrow`. The commands that do
     // not should opt out by checking `has_sparse` and `has_narrow`.
     SPARSE_REQUIREMENT,
     NARROW_REQUIREMENT,
     // rhg doesn't care about bookmarks at all yet
     BOOKMARKS_IN_STORE_REQUIREMENT,
 ];
 
 // Copied from mercurial/requirements.py:
 
 pub const DIRSTATE_V2_REQUIREMENT: &str = "dirstate-v2";
 pub const GENERALDELTA_REQUIREMENT: &str = "generaldelta";
 
 /// A repository that uses the tracked hint dirstate file
 #[allow(unused)]
 pub const DIRSTATE_TRACKED_HINT_V1: &str = "dirstate-tracked-key-v1";
 
 /// When narrowing is finalized and no longer subject to format changes,
 /// we should move this to just "narrow" or similar.
 #[allow(unused)]
 pub const NARROW_REQUIREMENT: &str = "narrowhg-experimental";
 
 /// Bookmarks must be stored in the `store` part of the repository and will be
 /// share accross shares
 #[allow(unused)]
 pub const BOOKMARKS_IN_STORE_REQUIREMENT: &str = "bookmarksinstore";
 
 /// Enables sparse working directory usage
 #[allow(unused)]
 pub const SPARSE_REQUIREMENT: &str = "exp-sparse";
 
 /// Enables the internal phase which is used to hide changesets instead
 /// of stripping them
 #[allow(unused)]
 pub const INTERNAL_PHASE_REQUIREMENT: &str = "internal-phase";
 
 /// Stores manifest in Tree structure
 #[allow(unused)]
 pub const TREEMANIFEST_REQUIREMENT: &str = "treemanifest";
 
 /// Whether to use the "RevlogNG" or V1 of the revlog format
 #[allow(unused)]
 pub const REVLOGV1_REQUIREMENT: &str = "revlogv1";
 
 /// Increment the sub-version when the revlog v2 format changes to lock out old
 /// clients.
 #[allow(unused)]
 pub const REVLOGV2_REQUIREMENT: &str = "exp-revlogv2.1";
 
 /// Increment the sub-version when the revlog v2 format changes to lock out old
 /// clients.
 #[allow(unused)]
 pub const CHANGELOGV2_REQUIREMENT: &str = "exp-changelog-v2";
 
 /// A repository with the sparserevlog feature will have delta chains that
 /// can spread over a larger span. Sparse reading cuts these large spans into
 /// pieces, so that each piece isn't too big.
 /// Without the sparserevlog capability, reading from the repository could use
 /// huge amounts of memory, because the whole span would be read at once,
 /// including all the intermediate revisions that aren't pertinent for the
 /// chain. This is why once a repository has enabled sparse-read, it becomes
 /// required.
 #[allow(unused)]
 pub const SPARSEREVLOG_REQUIREMENT: &str = "sparserevlog";
 
 /// A repository with the the copies-sidedata-changeset requirement will store
 /// copies related information in changeset's sidedata.
 #[allow(unused)]
 pub const COPIESSDC_REQUIREMENT: &str = "exp-copies-sidedata-changeset";
 
 /// The repository use persistent nodemap for the changelog and the manifest.
 #[allow(unused)]
 pub const NODEMAP_REQUIREMENT: &str = "persistent-nodemap";
 
 /// Denotes that the current repository is a share
 #[allow(unused)]
 pub const SHARED_REQUIREMENT: &str = "shared";
 
 /// Denotes that current repository is a share and the shared source path is
 /// relative to the current repository root path
 #[allow(unused)]
 pub const RELATIVE_SHARED_REQUIREMENT: &str = "relshared";
 
 /// A repository with share implemented safely. The repository has different
 /// store and working copy requirements i.e. both `.hg/requires` and
 /// `.hg/store/requires` are present.
 #[allow(unused)]
 pub const SHARESAFE_REQUIREMENT: &str = "share-safe";
 
 /// A repository that use zstd compression inside its revlog
 #[allow(unused)]
 pub const REVLOG_COMPRESSION_ZSTD: &str = "revlog-compression-zstd";

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

@@ -1,762 +1,764
 use std::ascii::escape_default;
 use std::borrow::Cow;
 use std::collections::BTreeMap;
 use std::fmt::{Debug, Formatter};
 use std::{iter, str};
 
 use chrono::{DateTime, FixedOffset, NaiveDateTime};
 use itertools::{Either, Itertools};
 
 use crate::errors::HgError;
 use crate::revlog::Index;
 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 crate::vfs::VfsImpl;
 use crate::{Graph, GraphError, RevlogOpenOptions, UncheckedRevision};
 
 /// A specialized `Revlog` to work with changelog data format.
 pub struct Changelog {
     /// The generic `revlog` format.
     pub(crate) revlog: Revlog,
 }
 
 impl Changelog {
     /// Open the `changelog` of a repository given by its root.
     pub fn open(
-        store_vfs: &Vfs,
+        store_vfs: &VfsImpl,
         options: RevlogOpenOptions,
     ) -> Result<Self, HgError> {
         let revlog = Revlog::open(store_vfs, "00changelog.i", None, options)?;
         Ok(Self { revlog })
     }
 
     /// Return the `ChangelogRevisionData` for the given node ID.
     pub fn data_for_node(
         &self,
         node: NodePrefix,
     ) -> Result<ChangelogRevisionData, RevlogError> {
         let rev = self.revlog.rev_from_node(node)?;
         self.entry_for_checked_rev(rev)?.data()
     }
 
     /// Return the [`ChangelogEntry`] for the given revision number.
     pub fn entry_for_rev(
         &self,
         rev: UncheckedRevision,
     ) -> Result<ChangelogEntry, RevlogError> {
         let revlog_entry = self.revlog.get_entry(rev)?;
         Ok(ChangelogEntry { revlog_entry })
     }
 
     /// Same as [`Self::entry_for_rev`] for checked revisions.
     fn entry_for_checked_rev(
         &self,
         rev: Revision,
     ) -> Result<ChangelogEntry, RevlogError> {
         let revlog_entry = self.revlog.get_entry_for_checked_rev(rev)?;
         Ok(ChangelogEntry { revlog_entry })
     }
 
     /// Return the [`ChangelogRevisionData`] for the given revision number.
     ///
     /// This is a useful shortcut in case the caller does not need the
     /// generic revlog information (parents, hashes etc). Otherwise
     /// consider taking a [`ChangelogEntry`] with
     /// [entry_for_rev](`Self::entry_for_rev`) and doing everything from there.
     pub fn data_for_rev(
         &self,
         rev: UncheckedRevision,
     ) -> Result<ChangelogRevisionData, RevlogError> {
         self.entry_for_rev(rev)?.data()
     }
 
     pub fn node_from_rev(&self, rev: UncheckedRevision) -> Option<&Node> {
         self.revlog.node_from_rev(rev)
     }
 
     pub fn rev_from_node(
         &self,
         node: NodePrefix,
     ) -> Result<Revision, RevlogError> {
         self.revlog.rev_from_node(node)
     }
 
     pub fn get_index(&self) -> &Index {
         &self.revlog.index
     }
 }
 
 impl Graph for Changelog {
     fn parents(&self, rev: Revision) -> Result<[Revision; 2], GraphError> {
         self.revlog.parents(rev)
     }
 }
 
 /// A specialized `RevlogEntry` for `changelog` data format
 ///
 /// This is a `RevlogEntry` with the added semantics that the associated
 /// data should meet the requirements for `changelog`, materialized by
 /// the fact that `data()` constructs a `ChangelogRevisionData`.
 /// In case that promise would be broken, the `data` method returns an error.
 #[derive(Clone)]
 pub struct ChangelogEntry<'changelog> {
     /// Same data, as a generic `RevlogEntry`.
     pub(crate) revlog_entry: RevlogEntry<'changelog>,
 }
 
 impl<'changelog> ChangelogEntry<'changelog> {
     pub fn data<'a>(
         &'a self,
     ) -> Result<ChangelogRevisionData<'changelog>, RevlogError> {
         let bytes = self.revlog_entry.data()?;
         if bytes.is_empty() {
             Ok(ChangelogRevisionData::null())
         } else {
             Ok(ChangelogRevisionData::new(bytes).map_err(|err| {
                 RevlogError::Other(HgError::CorruptedRepository(format!(
                     "Invalid changelog data for revision {}: {:?}",
                     self.revlog_entry.revision(),
                     err
                 )))
             })?)
         }
     }
 
     /// Obtain a reference to the underlying `RevlogEntry`.
     ///
     /// This allows the caller to access the information that is common
     /// to all revlog entries: revision number, node id, parent revisions etc.
     pub fn as_revlog_entry(&self) -> &RevlogEntry {
         &self.revlog_entry
     }
 
     pub fn p1_entry(&self) -> Result<Option<ChangelogEntry>, RevlogError> {
         Ok(self
             .revlog_entry
             .p1_entry()?
             .map(|revlog_entry| Self { revlog_entry }))
     }
 
     pub fn p2_entry(&self) -> Result<Option<ChangelogEntry>, RevlogError> {
         Ok(self
             .revlog_entry
             .p2_entry()?
             .map(|revlog_entry| Self { revlog_entry }))
     }
 }
 
 /// `Changelog` entry which knows how to interpret the `changelog` data bytes.
 #[derive(PartialEq)]
 pub struct ChangelogRevisionData<'changelog> {
     /// The data bytes of the `changelog` entry.
     bytes: Cow<'changelog, [u8]>,
     /// The end offset for the hex manifest (not including the newline)
     manifest_end: usize,
     /// The end offset for the user+email (not including the newline)
     user_end: usize,
     /// The end offset for the timestamp+timezone+extras (not including the
     /// newline)
     timestamp_end: usize,
     /// The end offset for the file list (not including the newline)
     files_end: usize,
 }
 
 impl<'changelog> ChangelogRevisionData<'changelog> {
     fn new(bytes: Cow<'changelog, [u8]>) -> Result<Self, HgError> {
         let mut line_iter = bytes.split(|b| b == &b'\n');
         let manifest_end = line_iter
             .next()
             .expect("Empty iterator from split()?")
             .len();
         let user_slice = line_iter.next().ok_or_else(|| {
             HgError::corrupted("Changeset data truncated after manifest line")
         })?;
         let user_end = manifest_end + 1 + user_slice.len();
         let timestamp_slice = line_iter.next().ok_or_else(|| {
             HgError::corrupted("Changeset data truncated after user line")
         })?;
         let timestamp_end = user_end + 1 + timestamp_slice.len();
         let mut files_end = timestamp_end + 1;
         loop {
             let line = line_iter.next().ok_or_else(|| {
                 HgError::corrupted("Changeset data truncated in files list")
             })?;
             if line.is_empty() {
                 if files_end == bytes.len() {
                     // The list of files ended with a single newline (there
                     // should be two)
                     return Err(HgError::corrupted(
                         "Changeset data truncated after files list",
                     ));
                 }
                 files_end -= 1;
                 break;
             }
             files_end += line.len() + 1;
         }
 
         Ok(Self {
             bytes,
             manifest_end,
             user_end,
             timestamp_end,
             files_end,
         })
     }
 
     fn null() -> Self {
         Self::new(Cow::Borrowed(
             b"0000000000000000000000000000000000000000\n\n0 0\n\n",
         ))
         .unwrap()
     }
 
     /// Return an iterator over the lines of the entry.
     pub fn lines(&self) -> impl Iterator<Item = &[u8]> {
         self.bytes.split(|b| b == &b'\n')
     }
 
     /// Return the node id of the `manifest` referenced by this `changelog`
     /// entry.
     pub fn manifest_node(&self) -> Result<Node, HgError> {
         let manifest_node_hex = &self.bytes[..self.manifest_end];
         Node::from_hex_for_repo(manifest_node_hex)
     }
 
     /// The full user string (usually a name followed by an email enclosed in
     /// angle brackets)
     pub fn user(&self) -> &[u8] {
         &self.bytes[self.manifest_end + 1..self.user_end]
     }
 
     /// The full timestamp line (timestamp in seconds, offset in seconds, and
     /// possibly extras)
     // TODO: We should expose this in a more useful way
     pub fn timestamp_line(&self) -> &[u8] {
         &self.bytes[self.user_end + 1..self.timestamp_end]
     }
 
     /// Parsed timestamp.
     pub fn timestamp(&self) -> Result<DateTime<FixedOffset>, HgError> {
         parse_timestamp(self.timestamp_line())
     }
 
     /// Optional commit extras.
     pub fn extra(&self) -> Result<BTreeMap<String, Vec<u8>>, HgError> {
         parse_timestamp_line_extra(self.timestamp_line())
     }
 
     /// The files changed in this revision.
     pub fn files(&self) -> impl Iterator<Item = &HgPath> {
         if self.timestamp_end == self.files_end {
             Either::Left(iter::empty())
         } else {
             Either::Right(
                 self.bytes[self.timestamp_end + 1..self.files_end]
                     .split(|b| b == &b'\n')
                     .map(HgPath::new),
             )
         }
     }
 
     /// The change description.
     pub fn description(&self) -> &[u8] {
         &self.bytes[self.files_end + 2..]
     }
 }
 
 impl Debug for ChangelogRevisionData<'_> {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("ChangelogRevisionData")
             .field("bytes", &debug_bytes(&self.bytes))
             .field("manifest", &debug_bytes(&self.bytes[..self.manifest_end]))
             .field(
                 "user",
                 &debug_bytes(
                     &self.bytes[self.manifest_end + 1..self.user_end],
                 ),
             )
             .field(
                 "timestamp",
                 &debug_bytes(
                     &self.bytes[self.user_end + 1..self.timestamp_end],
                 ),
             )
             .field(
                 "files",
                 &debug_bytes(
                     &self.bytes[self.timestamp_end + 1..self.files_end],
                 ),
             )
             .field(
                 "description",
                 &debug_bytes(&self.bytes[self.files_end + 2..]),
             )
             .finish()
     }
 }
 
 fn debug_bytes(bytes: &[u8]) -> String {
     String::from_utf8_lossy(
         &bytes.iter().flat_map(|b| escape_default(*b)).collect_vec(),
     )
     .to_string()
 }
 
 /// Parse the raw bytes of the timestamp line from a changelog entry.
 ///
 /// According to the documentation in `hg help dates` and the
 /// implementation in `changelog.py`, the format of the timestamp line
 /// is `time tz extra\n` where:
 ///
 /// - `time` is an ASCII-encoded signed int or float denoting a UTC timestamp
 ///   as seconds since the UNIX epoch.
 ///
 /// - `tz` is the timezone offset as an ASCII-encoded signed integer denoting
 ///   seconds WEST of UTC (so negative for timezones east of UTC, which is the
 ///   opposite of the sign in ISO 8601 timestamps).
 ///
 /// - `extra` is an optional set of NUL-delimited key-value pairs, with the key
 ///   and value in each pair separated by an ASCII colon. Keys are limited to
 ///   ASCII letters, digits, hyphens, and underscores, whereas values can be
 ///   arbitrary bytes.
 fn parse_timestamp(
     timestamp_line: &[u8],
 ) -> Result<DateTime<FixedOffset>, HgError> {
     let mut parts = timestamp_line.splitn(3, |c| *c == b' ');
 
     let timestamp_bytes = parts
         .next()
         .ok_or_else(|| HgError::corrupted("missing timestamp"))?;
     let timestamp_str = str::from_utf8(timestamp_bytes).map_err(|e| {
         HgError::corrupted(format!("timestamp is not valid UTF-8: {e}"))
     })?;
     let timestamp_utc = timestamp_str
         .parse()
         .map_err(|e| {
             HgError::corrupted(format!("failed to parse timestamp: {e}"))
         })
         .and_then(|secs| {
             NaiveDateTime::from_timestamp_opt(secs, 0).ok_or_else(|| {
                 HgError::corrupted(format!(
                     "integer timestamp out of valid range: {secs}"
                 ))
             })
         })
         // Attempt to parse the timestamp as a float if we can't parse
         // it as an int. It doesn't seem like float timestamps are actually
         // used in practice, but the Python code supports them.
         .or_else(|_| parse_float_timestamp(timestamp_str))?;
 
     let timezone_bytes = parts
         .next()
         .ok_or_else(|| HgError::corrupted("missing timezone"))?;
     let timezone_secs: i32 = str::from_utf8(timezone_bytes)
         .map_err(|e| {
             HgError::corrupted(format!("timezone is not valid UTF-8: {e}"))
         })?
         .parse()
         .map_err(|e| {
             HgError::corrupted(format!("timezone is not an integer: {e}"))
         })?;
     let timezone = FixedOffset::west_opt(timezone_secs)
         .ok_or_else(|| HgError::corrupted("timezone offset out of bounds"))?;
 
     Ok(DateTime::from_naive_utc_and_offset(timestamp_utc, timezone))
 }
 
 /// Attempt to parse the given string as floating-point timestamp, and
 /// convert the result into a `chrono::NaiveDateTime`.
 fn parse_float_timestamp(
     timestamp_str: &str,
 ) -> Result<NaiveDateTime, HgError> {
     let timestamp = timestamp_str.parse::<f64>().map_err(|e| {
         HgError::corrupted(format!("failed to parse timestamp: {e}"))
     })?;
 
     // To construct a `NaiveDateTime` we'll need to convert the float
     // into signed integer seconds and unsigned integer nanoseconds.
     let mut secs = timestamp.trunc() as i64;
     let mut subsecs = timestamp.fract();
 
     // If the timestamp is negative, we need to express the fractional
     // component as positive nanoseconds since the previous second.
     if timestamp < 0.0 {
         secs -= 1;
         subsecs += 1.0;
     }
 
     // This cast should be safe because the fractional component is
     // by definition less than 1.0, so this value should not exceed
     // 1 billion, which is representable as an f64 without loss of
     // precision and should fit into a u32 without overflowing.
     //
     // (Any loss of precision in the fractional component will have
     // already happened at the time of initial parsing; in general,
     // f64s are insufficiently precise to provide nanosecond-level
     // precision with present-day timestamps.)
     let nsecs = (subsecs * 1_000_000_000.0) as u32;
 
     NaiveDateTime::from_timestamp_opt(secs, nsecs).ok_or_else(|| {
         HgError::corrupted(format!(
             "float timestamp out of valid range: {timestamp}"
         ))
     })
 }
 
 /// Decode changeset extra fields.
 ///
 /// Extras are null-delimited key-value pairs where the key consists of ASCII
 /// alphanumeric characters plus hyphens and underscores, and the value can
 /// contain arbitrary bytes.
 fn decode_extra(extra: &[u8]) -> Result<BTreeMap<String, Vec<u8>>, HgError> {
     extra
         .split(|c| *c == b'\0')
         .map(|pair| {
             let pair = unescape_extra(pair);
             let mut iter = pair.splitn(2, |c| *c == b':');
 
             let key_bytes =
                 iter.next().filter(|k| !k.is_empty()).ok_or_else(|| {
                     HgError::corrupted("empty key in changeset extras")
                 })?;
 
             let key = str::from_utf8(key_bytes)
                 .ok()
                 .filter(|k| {
                     k.chars().all(|c| {
                         c.is_ascii_alphanumeric() || c == '_' || c == '-'
                     })
                 })
                 .ok_or_else(|| {
                     let key = String::from_utf8_lossy(key_bytes);
                     HgError::corrupted(format!(
                         "invalid key in changeset extras: {key}",
                     ))
                 })?
                 .to_string();
 
             let value = iter.next().map(Into::into).ok_or_else(|| {
                 HgError::corrupted(format!(
                     "missing value for changeset extra: {key}"
                 ))
             })?;
 
             Ok((key, value))
         })
         .collect()
 }
 
 /// Parse the extra fields from a changeset's timestamp line.
 fn parse_timestamp_line_extra(
     timestamp_line: &[u8],
 ) -> Result<BTreeMap<String, Vec<u8>>, HgError> {
     Ok(timestamp_line
         .splitn(3, |c| *c == b' ')
         .nth(2)
         .map(decode_extra)
         .transpose()?
         .unwrap_or_default())
 }
 
 /// Decode Mercurial's escaping for changelog extras.
 ///
 /// The `_string_escape` function in `changelog.py` only escapes 4 characters
 /// (null, backslash, newline, and carriage return) so we only decode those.
 ///
 /// The Python code also includes a workaround for decoding escaped nuls
 /// that are followed by an ASCII octal digit, since Python's built-in
 /// `string_escape` codec will interpret that as an escaped octal byte value.
 /// That workaround is omitted here since we don't support decoding octal.
 fn unescape_extra(bytes: &[u8]) -> Vec<u8> {
     let mut output = Vec::with_capacity(bytes.len());
     let mut input = bytes.iter().copied();
 
     while let Some(c) = input.next() {
         if c != b'\\' {
             output.push(c);
             continue;
         }
 
         match input.next() {
             Some(b'0') => output.push(b'\0'),
             Some(b'\\') => output.push(b'\\'),
             Some(b'n') => output.push(b'\n'),
             Some(b'r') => output.push(b'\r'),
             // The following cases should never occur in theory because any
             // backslashes in the original input should have been escaped
             // with another backslash, so it should not be possible to
             // observe an escape sequence other than the 4 above.
             Some(c) => output.extend_from_slice(&[b'\\', c]),
             None => output.push(b'\\'),
         }
     }
 
     output
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::vfs::Vfs;
+    use crate::vfs::VfsImpl;
     use crate::{
         RevlogDataConfig, RevlogDeltaConfig, RevlogFeatureConfig,
         NULL_REVISION,
     };
     use pretty_assertions::assert_eq;
 
     #[test]
     fn test_create_changelogrevisiondata_invalid() {
         // Completely empty
         assert!(ChangelogRevisionData::new(Cow::Borrowed(b"abcd")).is_err());
         // No newline after manifest
         assert!(ChangelogRevisionData::new(Cow::Borrowed(b"abcd")).is_err());
         // No newline after user
         assert!(ChangelogRevisionData::new(Cow::Borrowed(b"abcd\n")).is_err());
         // No newline after timestamp
         assert!(
             ChangelogRevisionData::new(Cow::Borrowed(b"abcd\n\n0 0")).is_err()
         );
         // Missing newline after files
         assert!(ChangelogRevisionData::new(Cow::Borrowed(
             b"abcd\n\n0 0\nfile1\nfile2"
         ))
         .is_err(),);
         // Only one newline after files
         assert!(ChangelogRevisionData::new(Cow::Borrowed(
             b"abcd\n\n0 0\nfile1\nfile2\n"
         ))
         .is_err(),);
     }
 
     #[test]
     fn test_create_changelogrevisiondata() {
         let data = ChangelogRevisionData::new(Cow::Borrowed(
             b"0123456789abcdef0123456789abcdef01234567
 Some One <[e-mail]>
 0 0
 file1
 file2
 
 some
 commit
 message",
         ))
         .unwrap();
         assert_eq!(
             data.manifest_node().unwrap(),
             Node::from_hex("0123456789abcdef0123456789abcdef01234567")
                 .unwrap()
         );
         assert_eq!(data.user(), b"Some One <[e-mail]>");
         assert_eq!(data.timestamp_line(), b"0 0");
         assert_eq!(
             data.files().collect_vec(),
             vec![HgPath::new("file1"), HgPath::new("file2")]
         );
         assert_eq!(data.description(), b"some\ncommit\nmessage");
     }
 
     #[test]
     fn test_data_from_rev_null() -> Result<(), RevlogError> {
         // an empty revlog will be enough for this case
         let temp = tempfile::tempdir().unwrap();
-        let vfs = Vfs { base: temp.path() };
+        let vfs = VfsImpl {
+            base: temp.path().to_owned(),
+        };
         std::fs::write(temp.path().join("foo.i"), b"").unwrap();
         std::fs::write(temp.path().join("foo.d"), b"").unwrap();
         let revlog = Revlog::open(
             &vfs,
             "foo.i",
             None,
             RevlogOpenOptions::new(
                 false,
                 RevlogDataConfig::default(),
                 RevlogDeltaConfig::default(),
                 RevlogFeatureConfig::default(),
             ),
         )
         .unwrap();
 
         let changelog = Changelog { revlog };
         assert_eq!(
             changelog.data_for_rev(NULL_REVISION.into())?,
             ChangelogRevisionData::null()
         );
         // same with the intermediate entry object
         assert_eq!(
             changelog.entry_for_rev(NULL_REVISION.into())?.data()?,
             ChangelogRevisionData::null()
         );
         Ok(())
     }
 
     #[test]
     fn test_empty_files_list() {
         assert!(ChangelogRevisionData::null()
             .files()
             .collect_vec()
             .is_empty());
     }
 
     #[test]
     fn test_unescape_basic() {
         // '\0', '\\', '\n', and '\r' are correctly unescaped.
         let expected = b"AAA\0BBB\\CCC\nDDD\rEEE";
         let escaped = br"AAA\0BBB\\CCC\nDDD\rEEE";
         let unescaped = unescape_extra(escaped);
         assert_eq!(&expected[..], &unescaped[..]);
     }
 
     #[test]
     fn test_unescape_unsupported_sequence() {
         // Other escape sequences are left unaltered.
         for c in 0u8..255 {
             match c {
                 b'0' | b'\\' | b'n' | b'r' => continue,
                 c => {
                     let expected = &[b'\\', c][..];
                     let unescaped = unescape_extra(expected);
                     assert_eq!(expected, &unescaped[..]);
                 }
             }
         }
     }
 
     #[test]
     fn test_unescape_trailing_backslash() {
         // Trailing backslashes are OK.
         let expected = br"hi\";
         let unescaped = unescape_extra(expected);
         assert_eq!(&expected[..], &unescaped[..]);
     }
 
     #[test]
     fn test_unescape_nul_followed_by_octal() {
         // Escaped NUL chars followed by octal digits are decoded correctly.
         let expected = b"\x0012";
         let escaped = br"\012";
         let unescaped = unescape_extra(escaped);
         assert_eq!(&expected[..], &unescaped[..]);
     }
 
     #[test]
     fn test_parse_float_timestamp() {
         let test_cases = [
             // Zero should map to the UNIX epoch.
             ("0.0", "1970-01-01 00:00:00"),
             // Negative zero should be the same as positive zero.
             ("-0.0", "1970-01-01 00:00:00"),
             // Values without fractional components should work like integers.
             // (Assuming the timestamp is within the limits of f64 precision.)
             ("1115154970.0", "2005-05-03 21:16:10"),
             // We expect some loss of precision in the fractional component
             // when parsing arbitrary floating-point values.
             ("1115154970.123456789", "2005-05-03 21:16:10.123456716"),
             // But representable f64 values should parse losslessly.
             ("1115154970.123456716", "2005-05-03 21:16:10.123456716"),
             // Negative fractional components are subtracted from the epoch.
             ("-1.333", "1969-12-31 23:59:58.667"),
         ];
 
         for (input, expected) in test_cases {
             let res = parse_float_timestamp(input).unwrap().to_string();
             assert_eq!(res, expected);
         }
     }
 
     fn escape_extra(bytes: &[u8]) -> Vec<u8> {
         let mut output = Vec::with_capacity(bytes.len());
 
         for c in bytes.iter().copied() {
             output.extend_from_slice(match c {
                 b'\0' => &b"\\0"[..],
                 b'\\' => &b"\\\\"[..],
                 b'\n' => &b"\\n"[..],
                 b'\r' => &b"\\r"[..],
                 _ => {
                     output.push(c);
                     continue;
                 }
             });
         }
 
         output
     }
 
     fn encode_extra<K, V>(pairs: impl IntoIterator<Item = (K, V)>) -> Vec<u8>
     where
         K: AsRef<[u8]>,
         V: AsRef<[u8]>,
     {
         let extras = pairs.into_iter().map(|(k, v)| {
             escape_extra(&[k.as_ref(), b":", v.as_ref()].concat())
         });
         // Use fully-qualified syntax to avoid a future naming conflict with
         // the standard library: https://github.com/rust-lang/rust/issues/79524
         Itertools::intersperse(extras, b"\0".to_vec()).concat()
     }
 
     #[test]
     fn test_decode_extra() {
         let extra = [
             ("branch".into(), b"default".to_vec()),
             ("key-with-hyphens".into(), b"value1".to_vec()),
             ("key_with_underscores".into(), b"value2".to_vec()),
             ("empty-value".into(), b"".to_vec()),
             ("binary-value".into(), (0u8..=255).collect::<Vec<_>>()),
         ]
         .into_iter()
         .collect::<BTreeMap<String, Vec<u8>>>();
 
         let encoded = encode_extra(&extra);
         let decoded = decode_extra(&encoded).unwrap();
 
         assert_eq!(extra, decoded);
     }
 
     #[test]
     fn test_corrupt_extra() {
         let test_cases = [
             (&b""[..], "empty input"),
             (&b"\0"[..], "unexpected null byte"),
             (&b":empty-key"[..], "empty key"),
             (&b"\0leading-null:"[..], "leading null"),
             (&b"trailing-null:\0"[..], "trailing null"),
             (&b"missing-value"[..], "missing value"),
             (&b"$!@# non-alphanum-key:"[..], "non-alphanumeric key"),
             (&b"\xF0\x9F\xA6\x80 non-ascii-key:"[..], "non-ASCII key"),
         ];
 
         for (extra, msg) in test_cases {
             assert!(
                 decode_extra(extra).is_err(),
                 "corrupt extra should have failed to parse: {}",
                 msg
             );
         }
     }
 
     #[test]
     fn test_parse_timestamp_line() {
         let extra = [
             ("branch".into(), b"default".to_vec()),
             ("key-with-hyphens".into(), b"value1".to_vec()),
             ("key_with_underscores".into(), b"value2".to_vec()),
             ("empty-value".into(), b"".to_vec()),
             ("binary-value".into(), (0u8..=255).collect::<Vec<_>>()),
         ]
         .into_iter()
         .collect::<BTreeMap<String, Vec<u8>>>();
 
         let mut line: Vec<u8> = b"1115154970 28800 ".to_vec();
         line.extend_from_slice(&encode_extra(&extra));
 
         let timestamp = parse_timestamp(&line).unwrap();
         assert_eq!(&timestamp.to_rfc3339(), "2005-05-03T13:16:10-08:00");
 
         let parsed_extra = parse_timestamp_line_extra(&line).unwrap();
         assert_eq!(extra, parsed_extra);
     }
 }

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

@@ -1,245 +1,245
 use crate::errors::HgError;
 use crate::exit_codes;
 use crate::repo::Repo;
 use crate::revlog::path_encode::path_encode;
 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;
 use crate::Graph;
 use crate::GraphError;
 use crate::RevlogOpenOptions;
 use crate::UncheckedRevision;
 use std::path::PathBuf;
 
 /// A specialized `Revlog` to work with file data logs.
 pub struct Filelog {
     /// The generic `revlog` format.
     revlog: Revlog,
 }
 
 impl Graph for Filelog {
     fn parents(&self, rev: Revision) -> Result<[Revision; 2], GraphError> {
         self.revlog.parents(rev)
     }
 }
 
 impl Filelog {
     pub fn open_vfs(
-        store_vfs: &crate::vfs::Vfs<'_>,
+        store_vfs: &crate::vfs::VfsImpl,
         file_path: &HgPath,
         options: RevlogOpenOptions,
     ) -> Result<Self, HgError> {
         let index_path = store_path(file_path, b".i");
         let data_path = store_path(file_path, b".d");
         let revlog =
             Revlog::open(store_vfs, index_path, Some(&data_path), options)?;
         Ok(Self { revlog })
     }
 
     pub fn open(
         repo: &Repo,
         file_path: &HgPath,
         options: RevlogOpenOptions,
     ) -> Result<Self, HgError> {
         Self::open_vfs(&repo.store_vfs(), file_path, options)
     }
 
     /// The given node ID is that of the file as found in a filelog, not of a
     /// changeset.
     pub fn data_for_node(
         &self,
         file_node: impl Into<NodePrefix>,
     ) -> Result<FilelogRevisionData, RevlogError> {
         let file_rev = self.revlog.rev_from_node(file_node.into())?;
         self.data_for_rev(file_rev.into())
     }
 
     /// The given revision is that of the file as found in a filelog, not of a
     /// changeset.
     pub fn data_for_rev(
         &self,
         file_rev: UncheckedRevision,
     ) -> Result<FilelogRevisionData, RevlogError> {
         let data: Vec<u8> = self.revlog.get_rev_data(file_rev)?.into_owned();
         Ok(FilelogRevisionData(data))
     }
 
     /// The given node ID is that of the file as found in a filelog, not of a
     /// changeset.
     pub fn entry_for_node(
         &self,
         file_node: impl Into<NodePrefix>,
     ) -> Result<FilelogEntry, RevlogError> {
         let file_rev = self.revlog.rev_from_node(file_node.into())?;
         self.entry_for_checked_rev(file_rev)
     }
 
     /// The given revision is that of the file as found in a filelog, not of a
     /// changeset.
     pub fn entry_for_rev(
         &self,
         file_rev: UncheckedRevision,
     ) -> Result<FilelogEntry, RevlogError> {
         Ok(FilelogEntry(self.revlog.get_entry(file_rev)?))
     }
 
     fn entry_for_checked_rev(
         &self,
         file_rev: Revision,
     ) -> Result<FilelogEntry, RevlogError> {
         Ok(FilelogEntry(
             self.revlog.get_entry_for_checked_rev(file_rev)?,
         ))
     }
 }
 
 fn store_path(hg_path: &HgPath, suffix: &[u8]) -> PathBuf {
     let encoded_bytes =
         path_encode(&[b"data/", hg_path.as_bytes(), suffix].concat());
     get_path_from_bytes(&encoded_bytes).into()
 }
 
 pub struct FilelogEntry<'a>(RevlogEntry<'a>);
 
 impl FilelogEntry<'_> {
     /// `self.data()` can be expensive, with decompression and delta
     /// resolution.
     ///
     /// *Without* paying this cost, based on revlog index information
     /// including `RevlogEntry::uncompressed_len`:
     ///
     /// * Returns `true` if the length that `self.data().file_data().len()`
     ///   would return is definitely **not equal** to `other_len`.
     /// * Returns `false` if available information is inconclusive.
     pub fn file_data_len_not_equal_to(&self, other_len: u64) -> bool {
         // Relevant code that implement this behavior in Python code:
         // basefilectx.cmp, filelog.size, storageutil.filerevisioncopied,
         // revlog.size, revlog.rawsize
 
         // Let’s call `file_data_len` what would be returned by
         // `self.data().file_data().len()`.
 
         if self.0.is_censored() {
             let file_data_len = 0;
             return other_len != file_data_len;
         }
 
         if self.0.has_length_affecting_flag_processor() {
             // We can’t conclude anything about `file_data_len`.
             return false;
         }
 
         // Revlog revisions (usually) have metadata for the size of
         // their data after decompression and delta resolution
         // as would be returned by `Revlog::get_rev_data`.
         //
         // For filelogs this is the file’s contents preceded by an optional
         // metadata block.
         let uncompressed_len = if let Some(l) = self.0.uncompressed_len() {
             l as u64
         } else {
             // The field was set to -1, the actual uncompressed len is unknown.
             // We need to decompress to say more.
             return false;
         };
         // `uncompressed_len = file_data_len + optional_metadata_len`,
         // so `file_data_len <= uncompressed_len`.
         if uncompressed_len < other_len {
             // Transitively, `file_data_len < other_len`.
             // So `other_len != file_data_len` definitely.
             return true;
         }
 
         if uncompressed_len == other_len + 4 {
             // It’s possible that `file_data_len == other_len` with an empty
             // metadata block (2 start marker bytes + 2 end marker bytes).
             // This happens when there wouldn’t otherwise be metadata, but
             // the first 2 bytes of file data happen to match a start marker
             // and would be ambiguous.
             return false;
         }
 
         if !self.0.has_p1() {
             // There may or may not be copy metadata, so we can’t deduce more
             // about `file_data_len` without computing file data.
             return false;
         }
 
         // Filelog ancestry is not meaningful in the way changelog ancestry is.
         // It only provides hints to delta generation.
         // p1 and p2 are set to null when making a copy or rename since
         // contents are likely unrelatedto what might have previously existed
         // at the destination path.
         //
         // Conversely, since here p1 is non-null, there is no copy metadata.
         // Note that this reasoning may be invalidated in the presence of
         // merges made by some previous versions of Mercurial that
         // swapped p1 and p2. See <https://bz.mercurial-scm.org/show_bug.cgi?id=6528>
         // and `tests/test-issue6528.t`.
         //
         // Since copy metadata is currently the only kind of metadata
         // kept in revlog data of filelogs,
         // this `FilelogEntry` does not have such metadata:
         let file_data_len = uncompressed_len;
 
         file_data_len != other_len
     }
 
     pub fn data(&self) -> Result<FilelogRevisionData, HgError> {
         let data = self.0.data();
         match data {
             Ok(data) => Ok(FilelogRevisionData(data.into_owned())),
             // Errors other than `HgError` should not happen at this point
             Err(e) => match e {
                 RevlogError::Other(hg_error) => Err(hg_error),
                 revlog_error => Err(HgError::abort(
                     revlog_error.to_string(),
                     exit_codes::ABORT,
                     None,
                 )),
             },
         }
     }
 }
 
 /// The data for one revision in a filelog, uncompressed and delta-resolved.
 pub struct FilelogRevisionData(Vec<u8>);
 
 impl FilelogRevisionData {
     /// Split into metadata and data
     pub fn split(&self) -> Result<(Option<&[u8]>, &[u8]), HgError> {
         const DELIMITER: &[u8; 2] = &[b'\x01', b'\n'];
 
         if let Some(rest) = self.0.drop_prefix(DELIMITER) {
             if let Some((metadata, data)) = rest.split_2_by_slice(DELIMITER) {
                 Ok((Some(metadata), data))
             } else {
                 Err(HgError::corrupted(
                     "Missing metadata end delimiter in filelog entry",
                 ))
             }
         } else {
             Ok((None, &self.0))
         }
     }
 
     /// Returns the file contents at this revision, stripped of any metadata
     pub fn file_data(&self) -> Result<&[u8], HgError> {
         let (_metadata, data) = self.split()?;
         Ok(data)
     }
 
     /// Consume the entry, and convert it into data, discarding any metadata,
     /// if present.
     pub fn into_file_data(self) -> Result<Vec<u8>, HgError> {
         if let (Some(_metadata), data) = self.split()? {
             Ok(data.to_owned())
         } else {
             Ok(self.0)
         }
     }
 }

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

@@ -1,213 +1,213
 use crate::errors::HgError;
 use crate::revlog::{Node, NodePrefix};
 use crate::revlog::{Revlog, RevlogError};
 use crate::utils::hg_path::HgPath;
 use crate::utils::SliceExt;
-use crate::vfs::Vfs;
+use crate::vfs::VfsImpl;
 use crate::{
     Graph, GraphError, Revision, RevlogOpenOptions, UncheckedRevision,
 };
 
 /// A specialized `Revlog` to work with `manifest` data format.
 pub struct Manifestlog {
     /// The generic `revlog` format.
     pub(crate) revlog: Revlog,
 }
 
 impl Graph for Manifestlog {
     fn parents(&self, rev: Revision) -> Result<[Revision; 2], GraphError> {
         self.revlog.parents(rev)
     }
 }
 
 impl Manifestlog {
     /// Open the `manifest` of a repository given by its root.
     pub fn open(
-        store_vfs: &Vfs,
+        store_vfs: &VfsImpl,
         options: RevlogOpenOptions,
     ) -> Result<Self, HgError> {
         let revlog = Revlog::open(store_vfs, "00manifest.i", None, options)?;
         Ok(Self { revlog })
     }
 
     /// Return the `Manifest` for the given node ID.
     ///
     /// Note: this is a node ID in the manifestlog, typically found through
     /// `ChangelogEntry::manifest_node`. It is *not* the node ID of any
     /// changeset.
     ///
     /// See also `Repo::manifest_for_node`
     pub fn data_for_node(
         &self,
         node: NodePrefix,
     ) -> Result<Manifest, RevlogError> {
         let rev = self.revlog.rev_from_node(node)?;
         self.data_for_checked_rev(rev)
     }
 
     /// Return the `Manifest` of a given revision number.
     ///
     /// Note: this is a revision number in the manifestlog, *not* of any
     /// changeset.
     ///
     /// See also `Repo::manifest_for_rev`
     pub fn data_for_rev(
         &self,
         rev: UncheckedRevision,
     ) -> Result<Manifest, RevlogError> {
         let bytes = self.revlog.get_rev_data(rev)?.into_owned();
         Ok(Manifest { bytes })
     }
 
     pub fn data_for_checked_rev(
         &self,
         rev: Revision,
     ) -> Result<Manifest, RevlogError> {
         let bytes =
             self.revlog.get_rev_data_for_checked_rev(rev)?.into_owned();
         Ok(Manifest { bytes })
     }
 }
 
 /// `Manifestlog` entry which knows how to interpret the `manifest` data bytes.
 #[derive(Debug)]
 pub struct Manifest {
     /// Format for a manifest: flat sequence of variable-size entries,
     /// sorted by path, each as:
     ///
     /// ```text
     /// <path> \0 <hex_node_id> <flags> \n
     /// ```
     ///
     /// The last entry is also terminated by a newline character.
     /// Flags is one of `b""` (the empty string), `b"x"`, `b"l"`, or `b"t"`.
     bytes: Vec<u8>,
 }
 
 impl Manifest {
     pub fn iter(
         &self,
     ) -> impl Iterator<Item = Result<ManifestEntry, HgError>> {
         self.bytes
             .split(|b| b == &b'\n')
             .filter(|line| !line.is_empty())
             .map(ManifestEntry::from_raw)
     }
 
     /// If the given path is in this manifest, return its filelog node ID
     pub fn find_by_path(
         &self,
         path: &HgPath,
     ) -> Result<Option<ManifestEntry>, HgError> {
         use std::cmp::Ordering::*;
         let path = path.as_bytes();
         // Both boundaries of this `&[u8]` slice are always at the boundary of
         // an entry
         let mut bytes = &*self.bytes;
 
         // Binary search algorithm derived from `[T]::binary_search_by`
         // <https://github.com/rust-lang/rust/blob/1.57.0/library/core/src/slice/mod.rs#L2221>
         // except we don’t have a slice of entries. Instead we jump to the
         // middle of the byte slice and look around for entry delimiters
         // (newlines).
         while let Some(entry_range) = Self::find_entry_near_middle_of(bytes)? {
             let (entry_path, rest) =
                 ManifestEntry::split_path(&bytes[entry_range.clone()])?;
             let cmp = entry_path.cmp(path);
             if cmp == Less {
                 let after_newline = entry_range.end + 1;
                 bytes = &bytes[after_newline..];
             } else if cmp == Greater {
                 bytes = &bytes[..entry_range.start];
             } else {
                 return Ok(Some(ManifestEntry::from_path_and_rest(
                     entry_path, rest,
                 )));
             }
         }
         Ok(None)
     }
 
     /// If there is at least one, return the byte range of an entry *excluding*
     /// the final newline.
     fn find_entry_near_middle_of(
         bytes: &[u8],
     ) -> Result<Option<std::ops::Range<usize>>, HgError> {
         let len = bytes.len();
         if len > 0 {
             let middle = bytes.len() / 2;
             // Integer division rounds down, so `middle < len`.
             let (before, after) = bytes.split_at(middle);
             let is_newline = |&byte: &u8| byte == b'\n';
             let entry_start = match before.iter().rposition(is_newline) {
                 Some(i) => i + 1,
                 None => 0, // We choose the first entry in `bytes`
             };
             let entry_end = match after.iter().position(is_newline) {
                 Some(i) => {
                     // No `+ 1` here to exclude this newline from the range
                     middle + i
                 }
                 None => {
                     // In a well-formed manifest:
                     //
                     // * Since `len > 0`, `bytes` contains at least one entry
                     // * Every entry ends with a newline
                     // * Since `middle < len`, `after` contains at least the
                     //   newline at the end of the last entry of `bytes`.
                     //
                     // We didn’t find a newline, so this manifest is not
                     // well-formed.
                     return Err(HgError::corrupted(
                         "manifest entry without \\n delimiter",
                     ));
                 }
             };
             Ok(Some(entry_start..entry_end))
         } else {
             // len == 0
             Ok(None)
         }
     }
 }
 
 /// `Manifestlog` entry which knows how to interpret the `manifest` data bytes.
 #[derive(Debug)]
 pub struct ManifestEntry<'manifest> {
     pub path: &'manifest HgPath,
     pub hex_node_id: &'manifest [u8],
 
     /// `Some` values are b'x', b'l', or 't'
     pub flags: Option<u8>,
 }
 
 impl<'a> ManifestEntry<'a> {
     fn split_path(bytes: &[u8]) -> Result<(&[u8], &[u8]), HgError> {
         bytes.split_2(b'\0').ok_or_else(|| {
             HgError::corrupted("manifest entry without \\0 delimiter")
         })
     }
 
     fn from_path_and_rest(path: &'a [u8], rest: &'a [u8]) -> Self {
         let (hex_node_id, flags) = match rest.split_last() {
             Some((&b'x', rest)) => (rest, Some(b'x')),
             Some((&b'l', rest)) => (rest, Some(b'l')),
             Some((&b't', rest)) => (rest, Some(b't')),
             _ => (rest, None),
         };
         Self {
             path: HgPath::new(path),
             hex_node_id,
             flags,
         }
     }
 
     fn from_raw(bytes: &'a [u8]) -> Result<Self, HgError> {
         let (path, rest) = Self::split_path(bytes)?;
         Ok(Self::from_path_and_rest(path, rest))
     }
 
     pub fn node_id(&self) -> Result<Node, HgError> {
         Node::from_hex_for_repo(self.hex_node_id)
     }
 }

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

@@ -1,1458 +1,1466
 // Copyright 2018-2023 Georges Racinet <[e-mail]>
 //           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::collections::HashSet;
 use std::io::Read;
 use std::ops::Deref;
 use std::path::Path;
 
 use flate2::read::ZlibDecoder;
 use sha1::{Digest, Sha1};
 use std::cell::RefCell;
 use zstd;
 
 use self::node::{NODE_BYTES_LENGTH, NULL_NODE};
 use self::nodemap_docket::NodeMapDocket;
 use super::index::Index;
 use super::index::INDEX_ENTRY_SIZE;
 use super::nodemap::{NodeMap, NodeMapError};
 use crate::config::{Config, ResourceProfileValue};
 use crate::errors::HgError;
 use crate::exit_codes;
 use crate::requirements::{
     GENERALDELTA_REQUIREMENT, NARROW_REQUIREMENT, SPARSEREVLOG_REQUIREMENT,
 };
-use crate::vfs::Vfs;
+use crate::vfs::VfsImpl;
 
 /// As noted in revlog.c, revision numbers are actually encoded in
 /// 4 bytes, and are liberally converted to ints, whence the i32
 pub type BaseRevision = i32;
 
 /// Mercurial revision numbers
 /// In contrast to the more general [`UncheckedRevision`], these are "checked"
 /// in the sense that they should only be used for revisions that are
 /// valid for a given index (i.e. in bounds).
 #[derive(
     Debug,
     derive_more::Display,
     Clone,
     Copy,
     Hash,
     PartialEq,
     Eq,
     PartialOrd,
     Ord,
 )]
 pub struct Revision(pub BaseRevision);
 
 impl format_bytes::DisplayBytes for Revision {
     fn display_bytes(
         &self,
         output: &mut dyn std::io::Write,
     ) -> std::io::Result<()> {
         self.0.display_bytes(output)
     }
 }
 
 /// Unchecked Mercurial revision numbers.
 ///
 /// Values of this type have no guarantee of being a valid revision number
 /// in any context. Use method `check_revision` to get a valid revision within
 /// the appropriate index object.
 #[derive(
     Debug,
     derive_more::Display,
     Clone,
     Copy,
     Hash,
     PartialEq,
     Eq,
     PartialOrd,
     Ord,
 )]
 pub struct UncheckedRevision(pub BaseRevision);
 
 impl format_bytes::DisplayBytes for UncheckedRevision {
     fn display_bytes(
         &self,
         output: &mut dyn std::io::Write,
     ) -> std::io::Result<()> {
         self.0.display_bytes(output)
     }
 }
 
 impl From<Revision> for UncheckedRevision {
     fn from(value: Revision) -> Self {
         Self(value.0)
     }
 }
 
 impl From<BaseRevision> for UncheckedRevision {
     fn from(value: BaseRevision) -> Self {
         Self(value)
     }
 }
 
 /// 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 = 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: UncheckedRevision =
     UncheckedRevision(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),
 }
 
 impl<T: Graph> Graph for &T {
     fn parents(&self, rev: Revision) -> Result<[Revision; 2], GraphError> {
         (*self).parents(rev)
     }
 }
 
 /// 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` for `NULL_REVISION`
     fn node(&self, rev: Revision) -> Option<&Node>;
 
     /// Return a [`Revision`] if `rev` is a valid revision number for this
     /// index.
     ///
     /// [`NULL_REVISION`] is considered to be valid.
     #[inline(always)]
     fn check_revision(&self, rev: UncheckedRevision) -> Option<Revision> {
         let rev = rev.0;
 
         if rev == NULL_REVISION.0 || (rev >= 0 && (rev as usize) < self.len())
         {
             Some(Revision(rev))
         } else {
             None
         }
     }
 }
 
 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, derive_more::Display)]
 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))
     }
 }
 
 #[derive(derive_more::Display, Debug, Copy, Clone, PartialEq, Eq)]
 pub enum RevlogType {
     Changelog,
     Manifestlog,
     Filelog,
 }
 
 impl TryFrom<usize> for RevlogType {
     type Error = HgError;
 
     fn try_from(value: usize) -> Result<Self, Self::Error> {
         match value {
             1001 => Ok(Self::Changelog),
             1002 => Ok(Self::Manifestlog),
             1003 => Ok(Self::Filelog),
             t => Err(HgError::abort(
                 format!("Unknown revlog type {}", t),
                 exit_codes::ABORT,
                 None,
             )),
         }
     }
 }
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub enum CompressionEngine {
     Zlib {
         /// Between 0 and 9 included
         level: u32,
     },
     Zstd {
         /// Between 0 and 22 included
         level: u32,
         /// Never used in practice for now
         threads: u32,
     },
     /// No compression is performed
     None,
 }
 impl CompressionEngine {
     pub fn set_level(&mut self, new_level: usize) -> Result<(), HgError> {
         match self {
             CompressionEngine::Zlib { level } => {
                 if new_level > 9 {
                     return Err(HgError::abort(
                         format!(
                             "invalid compression zlib compression level {}",
                             new_level
                         ),
                         exit_codes::ABORT,
                         None,
                     ));
                 }
                 *level = new_level as u32;
             }
             CompressionEngine::Zstd { level, .. } => {
                 if new_level > 22 {
                     return Err(HgError::abort(
                         format!(
                             "invalid compression zstd compression level {}",
                             new_level
                         ),
                         exit_codes::ABORT,
                         None,
                     ));
                 }
                 *level = new_level as u32;
             }
             CompressionEngine::None => {}
         }
         Ok(())
     }
 
     pub fn zstd(
         zstd_level: Option<u32>,
     ) -> Result<CompressionEngine, HgError> {
         let mut engine = CompressionEngine::Zstd {
             level: 3,
             threads: 0,
         };
         if let Some(level) = zstd_level {
             engine.set_level(level as usize)?;
         }
         Ok(engine)
     }
 }
 
 impl Default for CompressionEngine {
     fn default() -> Self {
         Self::Zlib { level: 6 }
     }
 }
 
 #[derive(Debug, Clone, Copy, PartialEq)]
 /// Holds configuration values about how the revlog data is read
 pub struct RevlogDataConfig {
     /// Should we try to open the "pending" version of the revlog
     pub try_pending: bool,
     /// Should we try to open the "split" version of the revlog
     pub try_split: bool,
     /// When True, `indexfile` should be opened with `checkambig=True` at
     /// writing time, to avoid file stat ambiguity
     pub check_ambig: bool,
     /// If true, use mmap instead of reading to deal with large indexes
     pub mmap_large_index: bool,
     /// How much data is considered large
     pub mmap_index_threshold: Option<u64>,
     /// How much data to read and cache into the raw revlog data cache
     pub chunk_cache_size: u64,
     /// The size of the uncompressed cache compared to the largest revision
     /// seen
     pub uncompressed_cache_factor: Option<f64>,
     /// The number of chunks cached
     pub uncompressed_cache_count: Option<u64>,
     /// Allow sparse reading of the revlog data
     pub with_sparse_read: bool,
     /// Minimal density of a sparse read chunk
     pub sr_density_threshold: f64,
     /// Minimal size of the data we skip when performing sparse reads
     pub sr_min_gap_size: u64,
     /// Whether deltas are encoded against arbitrary bases
     pub general_delta: bool,
 }
 
 impl RevlogDataConfig {
     pub fn new(
         config: &Config,
         requirements: &HashSet<String>,
     ) -> Result<Self, HgError> {
         let mut data_config = Self::default();
         if let Some(chunk_cache_size) =
             config.get_byte_size(b"format", b"chunkcachesize")?
         {
             data_config.chunk_cache_size = chunk_cache_size;
         }
 
         let memory_profile = config.get_resource_profile(Some("memory"));
         if memory_profile.value >= ResourceProfileValue::Medium {
             data_config.uncompressed_cache_count = Some(10_000);
             data_config.uncompressed_cache_factor = Some(4.0);
             if memory_profile.value >= ResourceProfileValue::High {
                 data_config.uncompressed_cache_factor = Some(10.0)
             }
         }
 
         if let Some(mmap_index_threshold) = config
             .get_byte_size(b"storage", b"revlog.mmap.index:size-threshold")?
         {
             data_config.mmap_index_threshold = Some(mmap_index_threshold);
         }
 
         let with_sparse_read =
             config.get_bool(b"experimental", b"sparse-read")?;
         if let Some(sr_density_threshold) = config
             .get_f64(b"experimental", b"sparse-read.density-threshold")?
         {
             data_config.sr_density_threshold = sr_density_threshold;
         }
         data_config.with_sparse_read = with_sparse_read;
         if let Some(sr_min_gap_size) = config
             .get_byte_size(b"experimental", b"sparse-read.min-gap-size")?
         {
             data_config.sr_min_gap_size = sr_min_gap_size;
         }
 
         data_config.with_sparse_read =
             requirements.contains(SPARSEREVLOG_REQUIREMENT);
 
         Ok(data_config)
     }
 }
 
 impl Default for RevlogDataConfig {
     fn default() -> Self {
         Self {
             chunk_cache_size: 65536,
             sr_density_threshold: 0.50,
             sr_min_gap_size: 262144,
             try_pending: Default::default(),
             try_split: Default::default(),
             check_ambig: Default::default(),
             mmap_large_index: Default::default(),
             mmap_index_threshold: Default::default(),
             uncompressed_cache_factor: Default::default(),
             uncompressed_cache_count: Default::default(),
             with_sparse_read: Default::default(),
             general_delta: Default::default(),
         }
     }
 }
 
 #[derive(Debug, Clone, Copy, PartialEq)]
 /// Holds configuration values about how new deltas are computed.
 ///
 /// Some attributes are duplicated from [`RevlogDataConfig`] to help having
 /// each object self contained.
 pub struct RevlogDeltaConfig {
     /// Whether deltas can be encoded against arbitrary bases
     pub general_delta: bool,
     /// Allow sparse writing of the revlog data
     pub sparse_revlog: bool,
     /// Maximum length of a delta chain
     pub max_chain_len: Option<u64>,
     /// Maximum distance between a delta chain's start and end
     pub max_deltachain_span: Option<u64>,
     /// If `upper_bound_comp` is not None, this is the expected maximal
     /// gain from compression for the data content
     pub upper_bound_comp: Option<f64>,
     /// Should we try a delta against both parents
     pub delta_both_parents: bool,
     /// Test delta base candidate groups by chunks of this maximal size
     pub candidate_group_chunk_size: u64,
     /// Should we display debug information about delta computation
     pub debug_delta: bool,
     /// Trust incoming deltas by default
     pub lazy_delta: bool,
     /// Trust the base of incoming deltas by default
     pub lazy_delta_base: bool,
 }
 impl RevlogDeltaConfig {
     pub fn new(
         config: &Config,
         requirements: &HashSet<String>,
         revlog_type: RevlogType,
     ) -> Result<Self, HgError> {
         let mut delta_config = Self {
             delta_both_parents: config
                 .get_option_no_default(
                     b"storage",
                     b"revlog.optimize-delta-parent-choice",
                 )?
                 .unwrap_or(true),
             candidate_group_chunk_size: config
                 .get_u64(
                     b"storage",
                     b"revlog.delta-parent-search.candidate-group-chunk-size",
                 )?
                 .unwrap_or_default(),
             ..Default::default()
         };
 
         delta_config.debug_delta =
             config.get_bool(b"debug", b"revlog.debug-delta")?;
 
         delta_config.general_delta =
             requirements.contains(GENERALDELTA_REQUIREMENT);
 
         let lazy_delta =
             config.get_bool(b"storage", b"revlog.reuse-external-delta")?;
 
         if revlog_type == RevlogType::Manifestlog {
             // upper bound of what we expect from compression
             // (real life value seems to be 3)
             delta_config.upper_bound_comp = Some(3.0)
         }
 
         let mut lazy_delta_base = false;
         if lazy_delta {
             lazy_delta_base = match config.get_option_no_default(
                 b"storage",
                 b"revlog.reuse-external-delta-parent",
             )? {
                 Some(base) => base,
                 None => config.get_bool(b"format", b"generaldelta")?,
             };
         }
         delta_config.lazy_delta = lazy_delta;
         delta_config.lazy_delta_base = lazy_delta_base;
 
         delta_config.max_deltachain_span =
             match config.get_i64(b"experimental", b"maxdeltachainspan")? {
                 Some(span) => {
                     if span < 0 {
                         None
                     } else {
                         Some(span as u64)
                     }
                 }
                 None => None,
             };
 
         delta_config.sparse_revlog =
             requirements.contains(SPARSEREVLOG_REQUIREMENT);
 
         delta_config.max_chain_len =
             config.get_byte_size_no_default(b"format", b"maxchainlen")?;
 
         Ok(delta_config)
     }
 }
 
 impl Default for RevlogDeltaConfig {
     fn default() -> Self {
         Self {
             delta_both_parents: true,
             lazy_delta: true,
             general_delta: Default::default(),
             sparse_revlog: Default::default(),
             max_chain_len: Default::default(),
             max_deltachain_span: Default::default(),
             upper_bound_comp: Default::default(),
             candidate_group_chunk_size: Default::default(),
             debug_delta: Default::default(),
             lazy_delta_base: Default::default(),
         }
     }
 }
 
 #[derive(Debug, Default, Clone, Copy, PartialEq)]
 /// Holds configuration values about the available revlog features
 pub struct RevlogFeatureConfig {
     /// The compression engine and its options
     pub compression_engine: CompressionEngine,
     /// Can we use censor on this revlog
     pub censorable: bool,
     /// Does this revlog use the "side data" feature
     pub has_side_data: bool,
     /// Might remove this configuration once the rank computation has no
     /// impact
     pub compute_rank: bool,
     /// Parent order is supposed to be semantically irrelevant, so we
     /// normally re-sort parents to ensure that the first parent is non-null,
     /// if there is a non-null parent at all.
     /// filelog abuses the parent order as a flag to mark some instances of
     /// meta-encoded files, so allow it to disable this behavior.
     pub canonical_parent_order: bool,
     /// Can ellipsis commit be used
     pub enable_ellipsis: bool,
 }
 impl RevlogFeatureConfig {
     pub fn new(
         config: &Config,
         requirements: &HashSet<String>,
     ) -> Result<Self, HgError> {
         let mut feature_config = Self::default();
 
         let zlib_level = config.get_u32(b"storage", b"revlog.zlib.level")?;
         let zstd_level = config.get_u32(b"storage", b"revlog.zstd.level")?;
 
         feature_config.compression_engine = CompressionEngine::default();
 
         for requirement in requirements {
             if requirement.starts_with("revlog-compression-")
                 || requirement.starts_with("exp-compression-")
             {
                 let split = &mut requirement.splitn(3, '-');
                 split.next();
                 split.next();
                 feature_config.compression_engine = match split.next().unwrap()
                 {
                     "zstd" => CompressionEngine::zstd(zstd_level)?,
                     e => {
                         return Err(HgError::UnsupportedFeature(format!(
                             "Unsupported compression engine '{e}'"
                         )))
                     }
                 };
             }
         }
         if let Some(level) = zlib_level {
             if matches!(
                 feature_config.compression_engine,
                 CompressionEngine::Zlib { .. }
             ) {
                 feature_config
                     .compression_engine
                     .set_level(level as usize)?;
             }
         }
 
         feature_config.enable_ellipsis =
             requirements.contains(NARROW_REQUIREMENT);
 
         Ok(feature_config)
     }
 }
 
 /// 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 Graph for Revlog {
     fn parents(&self, rev: Revision) -> Result<[Revision; 2], GraphError> {
         self.index.parents(rev)
     }
 }
 
 #[derive(Debug, Copy, Clone, PartialEq)]
 pub enum RevlogVersionOptions {
     V0,
     V1 { general_delta: bool, inline: bool },
     V2,
     ChangelogV2 { compute_rank: bool },
 }
 
 /// Options to govern how a revlog should be opened, usually from the
 /// repository configuration or requirements.
 #[derive(Debug, Copy, Clone)]
 pub struct RevlogOpenOptions {
     /// The revlog version, along with any option specific to this version
     pub version: RevlogVersionOptions,
     /// Whether the revlog uses a persistent nodemap.
     pub use_nodemap: bool,
     pub delta_config: RevlogDeltaConfig,
     pub data_config: RevlogDataConfig,
     pub feature_config: RevlogFeatureConfig,
 }
 
 #[cfg(test)]
 impl Default for RevlogOpenOptions {
     fn default() -> Self {
         Self {
             version: RevlogVersionOptions::V1 {
                 general_delta: true,
                 inline: false,
             },
             use_nodemap: true,
             data_config: Default::default(),
             delta_config: Default::default(),
             feature_config: Default::default(),
         }
     }
 }
 
 impl RevlogOpenOptions {
     pub fn new(
         inline: bool,
         data_config: RevlogDataConfig,
         delta_config: RevlogDeltaConfig,
         feature_config: RevlogFeatureConfig,
     ) -> Self {
         Self {
             version: RevlogVersionOptions::V1 {
                 general_delta: data_config.general_delta,
                 inline,
             },
             use_nodemap: false,
             data_config,
             delta_config,
             feature_config,
         }
     }
 
     pub fn index_header(&self) -> index::IndexHeader {
         index::IndexHeader {
             header_bytes: match self.version {
                 RevlogVersionOptions::V0 => [0, 0, 0, 0],
                 RevlogVersionOptions::V1 {
                     general_delta,
                     inline,
                 } => [
                     0,
                     if general_delta && inline {
                         3
                     } else if general_delta {
                         2
                     } else {
                         u8::from(inline)
                     },
                     0,
                     1,
                 ],
                 RevlogVersionOptions::V2 => 0xDEADu32.to_be_bytes(),
                 RevlogVersionOptions::ChangelogV2 { compute_rank: _ } => {
                     0xD34Du32.to_be_bytes()
                 }
             },
         }
     }
 }
 
 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,
+        // Todo use the `Vfs` trait here once we create a function for mmap
+        store_vfs: &VfsImpl,
         index_path: impl AsRef<Path>,
         data_path: Option<&Path>,
         options: RevlogOpenOptions,
     ) -> Result<Self, HgError> {
         Self::open_gen(store_vfs, index_path, data_path, options, None)
     }
 
     fn open_gen(
-        store_vfs: &Vfs,
+        // Todo use the `Vfs` trait here once we create a function for mmap
+        store_vfs: &VfsImpl,
         index_path: impl AsRef<Path>,
         data_path: Option<&Path>,
         options: RevlogOpenOptions,
         nodemap_for_test: Option<nodemap::NodeTree>,
     ) -> Result<Self, HgError> {
         let index_path = index_path.as_ref();
         let index = {
             match store_vfs.mmap_open_opt(index_path)? {
                 None => Index::new(
                     Box::<Vec<_>>::default(),
                     options.index_header(),
                 ),
                 Some(index_mmap) => {
                     let index = Index::new(
                         Box::new(index_mmap),
                         options.index_header(),
                     )?;
                     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 if index.is_empty() {
                 // No need to even try to open the data file then.
                 Some(Box::new(&[][..]))
             } 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() || !options.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,
                     )
                 },
             )
         };
 
         let nodemap = nodemap_for_test.or(nodemap);
 
         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: UncheckedRevision) -> Option<&Node> {
         if rev == NULL_REVISION.into() {
             return Some(&NULL_NODE);
         }
         let rev = self.index.check_revision(rev)?;
         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 let Some(nodemap) = &self.nodemap {
             nodemap
                 .find_bin(&self.index, node)?
                 .ok_or(RevlogError::InvalidRevision)
         } else {
             self.rev_from_node_no_persistent_nodemap(node)
         }
     }
 
     /// Same as `rev_from_node`, without using a persistent nodemap
     ///
     /// This is used as fallback when a persistent nodemap is not present.
     /// This happens when the persistent-nodemap experimental feature is not
     /// enabled, or for small revlogs.
     fn rev_from_node_no_persistent_nodemap(
         &self,
         node: NodePrefix,
     ) -> Result<Revision, RevlogError> {
         // Linear scan of the revlog
         // TODO: consider building a non-persistent nodemap in memory to
         // optimize these cases.
         let mut found_by_prefix = None;
         for rev in (-1..self.len() as BaseRevision).rev() {
             let rev = Revision(rev as BaseRevision);
             let candidate_node = if rev == Revision(-1) {
                 NULL_NODE
             } else {
                 let index_entry =
                     self.index.get_entry(rev).ok_or_else(|| {
                         HgError::corrupted(
                             "revlog references a revision not in the index",
                         )
                     })?;
                 *index_entry.hash()
             };
             if node == candidate_node {
                 return Ok(rev);
             }
             if node.is_prefix_of(&candidate_node) {
                 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: UncheckedRevision) -> bool {
         self.index.check_revision(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: UncheckedRevision,
     ) -> Result<Cow<[u8]>, RevlogError> {
         if rev == NULL_REVISION.into() {
             return Ok(Cow::Borrowed(&[]));
         };
         self.get_entry(rev)?.data()
     }
 
     /// [`Self::get_rev_data`] for checked revisions.
     pub fn get_rev_data_for_checked_rev(
         &self,
         rev: Revision,
     ) -> Result<Cow<[u8]>, RevlogError> {
         if rev == NULL_REVISION {
             return Ok(Cow::Borrowed(&[]));
         };
         self.get_entry_for_checked_rev(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,
         }
     }
 
     fn get_entry_for_checked_rev(
         &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 offset = index_entry.offset();
         let start = if self.index.is_inline() {
             offset + ((rev.0 as usize + 1) * INDEX_ENTRY_SIZE)
         } else {
             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 base_rev = self
             .index
             .check_revision(index_entry.base_revision_or_base_of_delta_chain())
             .ok_or_else(|| {
                 RevlogError::corrupted(format!(
                     "base revision for rev {} is invalid",
                     rev
                 ))
             })?;
         let p1 =
             self.index.check_revision(index_entry.p1()).ok_or_else(|| {
                 RevlogError::corrupted(format!(
                     "p1 for rev {} is invalid",
                     rev
                 ))
             })?;
         let p2 =
             self.index.check_revision(index_entry.p2()).ok_or_else(|| {
                 RevlogError::corrupted(format!(
                     "p2 for rev {} is invalid",
                     rev
                 ))
             })?;
         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 base_rev == rev {
                 None
             } else {
                 Some(base_rev)
             },
             p1,
             p2,
             flags: index_entry.flags(),
             hash: *index_entry.hash(),
         };
         Ok(entry)
     }
 
     /// Get an entry of the revlog.
     pub fn get_entry(
         &self,
         rev: UncheckedRevision,
     ) -> Result<RevlogEntry, RevlogError> {
         if rev == NULL_REVISION.into() {
             return Ok(self.make_null_entry());
         }
         let rev = self.index.check_revision(rev).ok_or_else(|| {
             RevlogError::corrupted(format!("rev {} is invalid", rev))
         })?;
         self.get_entry_for_checked_rev(rev)
     }
 }
 
 /// The revlog entry's bytes and the necessary informations to extract
 /// the entry's data.
 #[derive(Clone)]
 pub struct RevlogEntry<'revlog> {
     revlog: &'revlog Revlog,
     rev: Revision,
     bytes: &'revlog [u8],
     compressed_len: u32,
     uncompressed_len: i32,
     base_rev_or_base_of_delta_chain: Option<Revision>,
     p1: Revision,
     p2: Revision,
     flags: u16,
     hash: Node,
 }
 
 thread_local! {
   // seems fine to [unwrap] here: this can only fail due to memory allocation
   // failing, and it's normal for that to cause panic.
   static ZSTD_DECODER : RefCell<zstd::bulk::Decompressor<'static>> =
       RefCell::new(zstd::bulk::Decompressor::new().ok().unwrap());
 }
 
 fn zstd_decompress_to_buffer(
     bytes: &[u8],
     buf: &mut Vec<u8>,
 ) -> Result<usize, std::io::Error> {
     ZSTD_DECODER
         .with(|decoder| decoder.borrow_mut().decompress_to_buffer(bytes, buf))
 }
 
 impl<'revlog> RevlogEntry<'revlog> {
     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<'revlog>>, RevlogError> {
         if self.p1 == NULL_REVISION {
             Ok(None)
         } else {
             Ok(Some(self.revlog.get_entry_for_checked_rev(self.p1)?))
         }
     }
 
     pub fn p2_entry(
         &self,
     ) -> Result<Option<RevlogEntry<'revlog>>, RevlogError> {
         if self.p2 == NULL_REVISION {
             Ok(None)
         } else {
             Ok(Some(self.revlog.get_entry_for_checked_rev(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<'revlog, [u8]>, RevlogError> {
         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 {
             entry = if uses_generaldelta {
                 delta_chain.push(entry);
                 self.revlog.get_entry_for_checked_rev(base_rev)?
             } else {
                 let base_rev = UncheckedRevision(entry.rev.0 - 1);
                 delta_chain.push(entry);
                 self.revlog.get_entry(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<'revlog, [u8]>,
     ) -> Result<Cow<'revlog, [u8]>, RevlogError> {
         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",
                 )
                 .into());
             }
             Err(corrupted(format!(
                 "hash check failed for revision {}",
                 self.rev
             ))
             .into())
         }
     }
 
     pub fn data(&self) -> Result<Cow<'revlog, [u8]>, RevlogError> {
         let data = self.rawdata()?;
         if self.rev == NULL_REVISION {
             return Ok(data);
         }
         if self.is_censored() {
             return Err(HgError::CensoredNodeError.into());
         }
         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<'revlog, [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> {
         let cap = self.uncompressed_len.max(0) as usize;
         if self.is_delta() {
             // [cap] is usually an over-estimate of the space needed because
             // it's the length of delta-decoded data, but we're interested
             // in the size of the delta.
             // This means we have to [shrink_to_fit] to avoid holding on
             // to a large chunk of memory, but it also means we must have a
             // fallback branch, for the case when the delta is longer than
             // the original data (surprisingly, this does happen in practice)
             let mut buf = Vec::with_capacity(cap);
             match zstd_decompress_to_buffer(self.bytes, &mut buf) {
                 Ok(_) => buf.shrink_to_fit(),
                 Err(_) => {
                     buf.clear();
                     zstd::stream::copy_decode(self.bytes, &mut buf)
                         .map_err(|e| corrupted(e.to_string()))?;
                 }
             };
             Ok(buf)
         } else {
             let mut buf = Vec::with_capacity(cap);
             let len = zstd_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;
     use itertools::Itertools;
 
     #[test]
     fn test_empty() {
         let temp = tempfile::tempdir().unwrap();
-        let vfs = Vfs { base: temp.path() };
+        let vfs = VfsImpl {
+            base: temp.path().to_owned(),
+        };
         std::fs::write(temp.path().join("foo.i"), b"").unwrap();
         std::fs::write(temp.path().join("foo.d"), b"").unwrap();
         let revlog =
             Revlog::open(&vfs, "foo.i", None, RevlogOpenOptions::default())
                 .unwrap();
         assert!(revlog.is_empty());
         assert_eq!(revlog.len(), 0);
         assert!(revlog.get_entry(0.into()).is_err());
         assert!(!revlog.has_rev(0.into()));
         assert_eq!(
             revlog.rev_from_node(NULL_NODE.into()).unwrap(),
             NULL_REVISION
         );
         let null_entry = revlog.get_entry(NULL_REVISION.into()).ok().unwrap();
         assert_eq!(null_entry.revision(), NULL_REVISION);
         assert!(null_entry.data().unwrap().is_empty());
     }
 
     #[test]
     fn test_inline() {
         let temp = tempfile::tempdir().unwrap();
-        let vfs = Vfs { base: temp.path() };
+        let vfs = VfsImpl {
+            base: temp.path().to_owned(),
+        };
         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_node(node0)
             .build();
         let entry1_bytes = IndexEntryBuilder::new().with_node(node1).build();
         let entry2_bytes = IndexEntryBuilder::new()
             .with_p1(Revision(0))
             .with_p2(Revision(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, RevlogOpenOptions::default())
                 .unwrap();
 
         let entry0 = revlog.get_entry(0.into()).ok().unwrap();
         assert_eq!(entry0.revision(), 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.into()).ok().unwrap();
         assert_eq!(entry1.revision(), 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.into()).ok().unwrap();
         assert_eq!(entry2.revision(), Revision(2));
         assert_eq!(*entry2.node(), node2);
         assert!(entry2.has_p1());
         assert_eq!(entry2.p1(), Some(Revision(0)));
         assert_eq!(entry2.p2(), Some(Revision(1)));
         let p1_entry = entry2.p1_entry().unwrap();
         assert!(p1_entry.is_some());
         assert_eq!(p1_entry.unwrap().revision(), Revision(0));
         let p2_entry = entry2.p2_entry().unwrap();
         assert!(p2_entry.is_some());
         assert_eq!(p2_entry.unwrap().revision(), Revision(1));
     }
 
     #[test]
     fn test_nodemap() {
         let temp = tempfile::tempdir().unwrap();
-        let vfs = Vfs { base: temp.path() };
+        let vfs = VfsImpl {
+            base: temp.path().to_owned(),
+        };
 
         // building a revlog with a forced Node starting with zeros
         // This is a corruption, but it does not preclude using the nodemap
         // if we don't try and access the data
         let node0 = Node::from_hex("00d2a3912a0b24502043eae84ee4b279c18b90dd")
             .unwrap();
         let node1 = Node::from_hex("b004912a8510032a0350a74daa2803dadfb00e12")
             .unwrap();
         let entry0_bytes = IndexEntryBuilder::new()
             .is_first(true)
             .with_version(1)
             .with_inline(true)
             .with_node(node0)
             .build();
         let entry1_bytes = IndexEntryBuilder::new().with_node(node1).build();
         let contents = vec![entry0_bytes, entry1_bytes]
             .into_iter()
             .flatten()
             .collect_vec();
         std::fs::write(temp.path().join("foo.i"), contents).unwrap();
 
         let mut idx = nodemap::tests::TestNtIndex::new();
         idx.insert_node(Revision(0), node0).unwrap();
         idx.insert_node(Revision(1), node1).unwrap();
 
         let revlog = Revlog::open_gen(
             &vfs,
             "foo.i",
             None,
             RevlogOpenOptions::default(),
             Some(idx.nt),
         )
         .unwrap();
 
         // accessing the data shows the corruption
         revlog.get_entry(0.into()).unwrap().data().unwrap_err();
 
         assert_eq!(
             revlog.rev_from_node(NULL_NODE.into()).unwrap(),
             Revision(-1)
         );
         assert_eq!(revlog.rev_from_node(node0.into()).unwrap(), Revision(0));
         assert_eq!(revlog.rev_from_node(node1.into()).unwrap(), Revision(1));
         assert_eq!(
             revlog
                 .rev_from_node(NodePrefix::from_hex("000").unwrap())
                 .unwrap(),
             Revision(-1)
         );
         assert_eq!(
             revlog
                 .rev_from_node(NodePrefix::from_hex("b00").unwrap())
                 .unwrap(),
             Revision(1)
         );
         // RevlogError does not implement PartialEq
         // (ultimately because io::Error does not)
         match revlog
             .rev_from_node(NodePrefix::from_hex("00").unwrap())
             .expect_err("Expected to give AmbiguousPrefix error")
         {
             RevlogError::AmbiguousPrefix => (),
             e => {
                 panic!("Got another error than AmbiguousPrefix: {:?}", e);
             }
         };
     }
 }

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

@@ -1,108 +1,108
 use crate::errors::{HgError, HgResultExt};
 use bytes_cast::{unaligned, BytesCast};
 use memmap2::Mmap;
 use std::path::{Path, PathBuf};
 
-use crate::vfs::Vfs;
+use crate::vfs::VfsImpl;
 
 const ONDISK_VERSION: u8 = 1;
 
 pub(super) struct NodeMapDocket {
     pub data_length: usize,
     // TODO: keep here more of the data from `parse()` when we need it
 }
 
 #[derive(BytesCast)]
 #[repr(C)]
 struct DocketHeader {
     uid_size: u8,
     _tip_rev: unaligned::U64Be,
     data_length: unaligned::U64Be,
     _data_unused: unaligned::U64Be,
     tip_node_size: unaligned::U64Be,
 }
 
 impl NodeMapDocket {
     /// Return `Ok(None)` when the caller should proceed without a persistent
     /// nodemap:
     ///
     /// * This revlog does not have a `.n` docket file (it is not generated for
     ///   small revlogs), or
     /// * The docket has an unsupported version number (repositories created by
     ///   later hg, maybe that should be a requirement instead?), or
     /// * The docket file points to a missing (likely deleted) data file (this
     ///   can happen in a rare race condition).
     pub fn read_from_file(
-        store_vfs: &Vfs,
+        store_vfs: &VfsImpl,
         index_path: &Path,
     ) -> Result<Option<(Self, Mmap)>, HgError> {
         let docket_path = index_path.with_extension("n");
         let docket_bytes = if let Some(bytes) =
             store_vfs.read(&docket_path).io_not_found_as_none()?
         {
             bytes
         } else {
             return Ok(None);
         };
 
         let input = if let Some((&ONDISK_VERSION, rest)) =
             docket_bytes.split_first()
         {
             rest
         } else {
             return Ok(None);
         };
 
         /// Treat any error as a parse error
         fn parse<T, E>(result: Result<T, E>) -> Result<T, HgError> {
             result
                 .map_err(|_| HgError::corrupted("nodemap docket parse error"))
         }
 
         let (header, rest) = parse(DocketHeader::from_bytes(input))?;
         let uid_size = header.uid_size as usize;
         // TODO: do we care about overflow for 4 GB+ nodemap files on 32-bit
         // systems?
         let tip_node_size = header.tip_node_size.get() as usize;
         let data_length = header.data_length.get() as usize;
         let (uid, rest) = parse(u8::slice_from_bytes(rest, uid_size))?;
         let (_tip_node, _rest) =
             parse(u8::slice_from_bytes(rest, tip_node_size))?;
         let uid = parse(std::str::from_utf8(uid))?;
         let docket = NodeMapDocket { data_length };
 
         let data_path = rawdata_path(&docket_path, uid);
         // TODO: use `vfs.read()` here when the `persistent-nodemap.mmap`
         // config is false?
         if let Some(mmap) =
             store_vfs.mmap_open(data_path).io_not_found_as_none()?
         {
             if mmap.len() >= data_length {
                 Ok(Some((docket, mmap)))
             } else {
                 Err(HgError::corrupted("persistent nodemap too short"))
             }
         } else {
             // Even if .hg/requires opted in, some revlogs are deemed small
             // enough to not need a persistent nodemap.
             Ok(None)
         }
     }
 }
 
 fn rawdata_path(docket_path: &Path, uid: &str) -> PathBuf {
     let docket_name = docket_path
         .file_name()
         .expect("expected a base name")
         .to_str()
         .expect("expected an ASCII file name in the store");
     let prefix = docket_name
         .strip_suffix(".n.a")
         .or_else(|| docket_name.strip_suffix(".n"))
         .expect("expected docket path in .n or .n.a");
     let name = format!("{}-{}.nd", prefix, uid);
     docket_path
         .parent()
         .expect("expected a non-root path")
         .join(name)
 }

rust/hg-core/src/vfs.rs

@@ -1,205 +1,382
 use crate::errors::{HgError, IoErrorContext, IoResultExt};
+use crate::exit_codes;
+use dyn_clone::DynClone;
 use memmap2::{Mmap, MmapOptions};
+use std::fs::File;
 use std::io::{ErrorKind, Write};
+use std::os::unix::fs::MetadataExt;
 use std::path::{Path, PathBuf};
 
 /// Filesystem access abstraction for the contents of a given "base" diretory
-#[derive(Clone, Copy)]
-pub struct Vfs<'a> {
-    pub(crate) base: &'a Path,
+#[derive(Clone)]
+pub struct VfsImpl {
+    pub(crate) base: PathBuf,
 }
 
 struct FileNotFound(std::io::Error, PathBuf);
 
-impl Vfs<'_> {
+impl VfsImpl {
     pub fn join(&self, relative_path: impl AsRef<Path>) -> PathBuf {
         self.base.join(relative_path)
     }
 
     pub fn symlink_metadata(
         &self,
         relative_path: impl AsRef<Path>,
     ) -> Result<std::fs::Metadata, HgError> {
         let path = self.join(relative_path);
         std::fs::symlink_metadata(&path).when_reading_file(&path)
     }
 
     pub fn read_link(
         &self,
         relative_path: impl AsRef<Path>,
     ) -> Result<PathBuf, HgError> {
         let path = self.join(relative_path);
         std::fs::read_link(&path).when_reading_file(&path)
     }
 
     pub fn read(
         &self,
         relative_path: impl AsRef<Path>,
     ) -> Result<Vec<u8>, HgError> {
         let path = self.join(relative_path);
         std::fs::read(&path).when_reading_file(&path)
     }
 
     /// Returns `Ok(None)` if the file does not exist.
     pub fn try_read(
         &self,
         relative_path: impl AsRef<Path>,
     ) -> Result<Option<Vec<u8>>, HgError> {
         match self.read(relative_path) {
             Err(e) => match &e {
                 HgError::IoError { error, .. } => match error.kind() {
                     ErrorKind::NotFound => Ok(None),
                     _ => Err(e),
                 },
                 _ => Err(e),
             },
             Ok(v) => Ok(Some(v)),
         }
     }
 
     fn mmap_open_gen(
         &self,
         relative_path: impl AsRef<Path>,
     ) -> Result<Result<Mmap, FileNotFound>, HgError> {
         let path = self.join(relative_path);
         let file = match std::fs::File::open(&path) {
             Err(err) => {
                 if let ErrorKind::NotFound = err.kind() {
                     return Ok(Err(FileNotFound(err, path)));
                 };
                 return (Err(err)).when_reading_file(&path);
             }
             Ok(file) => file,
         };
-        // TODO: what are the safety requirements here?
+        // Safety is "enforced" by locks and assuming other processes are
+        // well-behaved. If any misbehaving or malicious process does touch
+        // the index, it could lead to corruption. This is inherent
+        // to file-based `mmap`, though some platforms have some ways of
+        // mitigating.
+        // TODO linux: set the immutable flag with `chattr(1)`?
         let mmap = unsafe { MmapOptions::new().map(&file) }
             .when_reading_file(&path)?;
         Ok(Ok(mmap))
     }
 
     pub fn mmap_open_opt(
         &self,
         relative_path: impl AsRef<Path>,
     ) -> Result<Option<Mmap>, HgError> {
         self.mmap_open_gen(relative_path).map(|res| res.ok())
     }
 
     pub fn mmap_open(
         &self,
         relative_path: impl AsRef<Path>,
     ) -> Result<Mmap, HgError> {
         match self.mmap_open_gen(relative_path)? {
             Err(FileNotFound(err, path)) => Err(err).when_reading_file(&path),
             Ok(res) => Ok(res),
         }
     }
 
     pub fn rename(
         &self,
         relative_from: impl AsRef<Path>,
         relative_to: impl AsRef<Path>,
     ) -> Result<(), HgError> {
         let from = self.join(relative_from);
         let to = self.join(relative_to);
         std::fs::rename(&from, &to)
             .with_context(|| IoErrorContext::RenamingFile { from, to })
     }
 
     pub fn remove_file(
         &self,
         relative_path: impl AsRef<Path>,
     ) -> Result<(), HgError> {
         let path = self.join(relative_path);
         std::fs::remove_file(&path)
             .with_context(|| IoErrorContext::RemovingFile(path))
     }
 
     #[cfg(unix)]
     pub fn create_symlink(
         &self,
         relative_link_path: impl AsRef<Path>,
         target_path: impl AsRef<Path>,
     ) -> Result<(), HgError> {
         let link_path = self.join(relative_link_path);
         std::os::unix::fs::symlink(target_path, &link_path)
             .when_writing_file(&link_path)
     }
 
     /// Write `contents` into a temporary file, then rename to `relative_path`.
     /// This makes writing to a file "atomic": a reader opening that path will
     /// see either the previous contents of the file or the complete new
     /// content, never a partial write.
     pub fn atomic_write(
         &self,
         relative_path: impl AsRef<Path>,
         contents: &[u8],
     ) -> Result<(), HgError> {
-        let mut tmp = tempfile::NamedTempFile::new_in(self.base)
-            .when_writing_file(self.base)?;
+        let mut tmp = tempfile::NamedTempFile::new_in(&self.base)
+            .when_writing_file(&self.base)?;
         tmp.write_all(contents)
             .and_then(|()| tmp.flush())
             .when_writing_file(tmp.path())?;
         let path = self.join(relative_path);
         tmp.persist(&path)
             .map_err(|e| e.error)
             .when_writing_file(&path)?;
         Ok(())
     }
 }
 
 fn fs_metadata(
     path: impl AsRef<Path>,
 ) -> Result<Option<std::fs::Metadata>, HgError> {
     let path = path.as_ref();
     match std::fs::metadata(path) {
         Ok(meta) => Ok(Some(meta)),
         Err(error) => match error.kind() {
             // TODO: when we require a Rust version where `NotADirectory` is
             // stable, invert this logic and return None for it and `NotFound`
             // and propagate any other error.
             ErrorKind::PermissionDenied => Err(error).with_context(|| {
                 IoErrorContext::ReadingMetadata(path.to_owned())
             }),
             _ => Ok(None),
         },
     }
 }
 
+/// Writable file object that atomically updates a file
+///
+/// All writes will go to a temporary copy of the original file. Call
+/// [`Self::close`] when you are done writing, and [`Self`] will rename
+/// the temporary copy to the original name, making the changes
+/// visible. If the object is destroyed without being closed, all your
+/// writes are discarded.
+pub struct AtomicFile {
+    /// The temporary file to write to
+    fp: std::fs::File,
+    /// Path of the temp file
+    temp_path: PathBuf,
+    /// Used when stat'ing the file, is useful only if the target file is
+    /// guarded by any lock (e.g. repo.lock or repo.wlock).
+    check_ambig: bool,
+    /// Path of the target file
+    target_name: PathBuf,
+    /// Whether the file is open or not
+    is_open: bool,
+}
+
+impl AtomicFile {
+    pub fn new(
+        fp: std::fs::File,
+        check_ambig: bool,
+        temp_name: PathBuf,
+        target_name: PathBuf,
+    ) -> Self {
+        Self {
+            fp,
+            check_ambig,
+            temp_path: temp_name,
+            target_name,
+            is_open: true,
+        }
+    }
+
+    /// Write `buf` to the temporary file
+    pub fn write_all(&mut self, buf: &[u8]) -> Result<(), std::io::Error> {
+        self.fp.write_all(buf)
+    }
+
+    fn target(&self) -> PathBuf {
+        self.temp_path
+            .parent()
+            .expect("should not be at the filesystem root")
+            .join(&self.target_name)
+    }
+
+    /// Close the temporary file and rename to the target
+    pub fn close(mut self) -> Result<(), std::io::Error> {
+        self.fp.flush()?;
+        let target = self.target();
+        if self.check_ambig {
+            if let Ok(stat) = std::fs::metadata(&target) {
+                std::fs::rename(&self.temp_path, &target)?;
+                let new_stat = std::fs::metadata(&target)?;
+                let ctime = new_stat.ctime();
+                let is_ambiguous = ctime == stat.ctime();
+                if is_ambiguous {
+                    let advanced =
+                        filetime::FileTime::from_unix_time(ctime + 1, 0);
+                    filetime::set_file_times(target, advanced, advanced)?;
+                }
+            } else {
+                std::fs::rename(&self.temp_path, target)?;
+            }
+        } else {
+            std::fs::rename(&self.temp_path, target).unwrap();
+        }
+        self.is_open = false;
+        Ok(())
+    }
+}
+
+impl Drop for AtomicFile {
+    fn drop(&mut self) {
+        if self.is_open {
+            std::fs::remove_file(self.target()).ok();
+        }
+    }
+}
+
+/// Abstracts over the VFS to allow for different implementations of the
+/// filesystem layer (like passing one from Python).
+pub trait Vfs: Sync + Send + DynClone {
+    fn open(&self, filename: &Path) -> Result<std::fs::File, HgError>;
+    fn open_read(&self, filename: &Path) -> Result<std::fs::File, HgError>;
+    fn open_check_ambig(
+        &self,
+        filename: &Path,
+    ) -> Result<std::fs::File, HgError>;
+    fn create(&self, filename: &Path) -> Result<std::fs::File, HgError>;
+    /// Must truncate the new file if exist
+    fn create_atomic(
+        &self,
+        filename: &Path,
+        check_ambig: bool,
+    ) -> Result<AtomicFile, HgError>;
+    fn file_size(&self, file: &File) -> Result<u64, HgError>;
+    fn exists(&self, filename: &Path) -> bool;
+    fn unlink(&self, filename: &Path) -> Result<(), HgError>;
+    fn rename(
+        &self,
+        from: &Path,
+        to: &Path,
+        check_ambig: bool,
+    ) -> Result<(), HgError>;
+    fn copy(&self, from: &Path, to: &Path) -> Result<(), HgError>;
+}
+
+/// These methods will need to be implemented once `rhg` (and other) non-Python
+/// users of `hg-core` start doing more on their own, like writing to files.
+impl Vfs for VfsImpl {
+    fn open(&self, _filename: &Path) -> Result<std::fs::File, HgError> {
+        todo!()
+    }
+    fn open_read(&self, filename: &Path) -> Result<std::fs::File, HgError> {
+        let path = self.base.join(filename);
+        std::fs::File::open(&path).when_reading_file(&path)
+    }
+    fn open_check_ambig(
+        &self,
+        _filename: &Path,
+    ) -> Result<std::fs::File, HgError> {
+        todo!()
+    }
+    fn create(&self, _filename: &Path) -> Result<std::fs::File, HgError> {
+        todo!()
+    }
+    fn create_atomic(
+        &self,
+        _filename: &Path,
+        _check_ambig: bool,
+    ) -> Result<AtomicFile, HgError> {
+        todo!()
+    }
+    fn file_size(&self, file: &File) -> Result<u64, HgError> {
+        Ok(file
+            .metadata()
+            .map_err(|e| {
+                HgError::abort(
+                    format!("Could not get file metadata: {}", e),
+                    exit_codes::ABORT,
+                    None,
+                )
+            })?
+            .size())
+    }
+    fn exists(&self, _filename: &Path) -> bool {
+        todo!()
+    }
+    fn unlink(&self, _filename: &Path) -> Result<(), HgError> {
+        todo!()
+    }
+    fn rename(
+        &self,
+        _from: &Path,
+        _to: &Path,
+        _check_ambig: bool,
+    ) -> Result<(), HgError> {
+        todo!()
+    }
+    fn copy(&self, _from: &Path, _to: &Path) -> Result<(), HgError> {
+        todo!()
+    }
+}
+
 pub(crate) fn is_dir(path: impl AsRef<Path>) -> Result<bool, HgError> {
     Ok(fs_metadata(path)?.map_or(false, |meta| meta.is_dir()))
 }
 
 pub(crate) fn is_file(path: impl AsRef<Path>) -> Result<bool, HgError> {
     Ok(fs_metadata(path)?.map_or(false, |meta| meta.is_file()))
 }
 
 /// Returns whether the given `path` is on a network file system.
 /// Taken from `cargo`'s codebase.
 #[cfg(target_os = "linux")]
 pub(crate) fn is_on_nfs_mount(path: impl AsRef<Path>) -> bool {
     use std::ffi::CString;
     use std::mem;
     use std::os::unix::prelude::*;
 
     let path = match CString::new(path.as_ref().as_os_str().as_bytes()) {
         Ok(path) => path,
         Err(_) => return false,
     };
 
     unsafe {
         let mut buf: libc::statfs = mem::zeroed();
         let r = libc::statfs(path.as_ptr(), &mut buf);
 
         r == 0 && buf.f_type as u32 == libc::NFS_SUPER_MAGIC as u32
     }
 }
 
 /// Similar to what Cargo does; although detecting NFS (or non-local
 /// file systems) _should_ be possible on other operating systems,
 /// we'll just assume that mmap() works there, for now; after all,
 /// _some_ functionality is better than a compile error, i.e. none at
 /// all
 #[cfg(not(target_os = "linux"))]
 pub(crate) fn is_on_nfs_mount(_path: impl AsRef<Path>) -> bool {
     false
 }

rust/rhg/src/commands/status.rs

@@ -1,826 +1,826
 // status.rs
 //
 // Copyright 2020, Georges Racinet <[e-mail]>
 //
 // This software may be used and distributed according to the terms of the
 // GNU General Public License version 2 or any later version.
 
 use crate::error::CommandError;
 use crate::ui::{
     format_pattern_file_warning, print_narrow_sparse_warnings, relative_paths,
     RelativePaths, Ui,
 };
 use crate::utils::path_utils::RelativizePaths;
 use clap::Arg;
 use format_bytes::format_bytes;
 use hg::config::Config;
 use hg::dirstate::has_exec_bit;
 use hg::dirstate::status::StatusPath;
 use hg::dirstate::TruncatedTimestamp;
 use hg::errors::{HgError, IoResultExt};
 use hg::filepatterns::parse_pattern_args;
 use hg::lock::LockError;
 use hg::manifest::Manifest;
 use hg::matchers::{AlwaysMatcher, IntersectionMatcher};
 use hg::repo::Repo;
 use hg::utils::debug::debug_wait_for_file;
 use hg::utils::files::{
     get_bytes_from_os_str, get_bytes_from_os_string, get_path_from_bytes,
 };
 use hg::utils::hg_path::{hg_path_to_path_buf, HgPath};
 use hg::Revision;
 use hg::StatusError;
 use hg::StatusOptions;
 use hg::{self, narrow, sparse};
 use hg::{DirstateStatus, RevlogOpenOptions};
 use hg::{PatternFileWarning, RevlogType};
 use log::info;
 use rayon::prelude::*;
 use std::borrow::Cow;
 use std::io;
 use std::mem::take;
 use std::path::PathBuf;
 
 pub const HELP_TEXT: &str = "
 Show changed files in the working directory
 
 This is a pure Rust version of `hg status`.
 
 Some options might be missing, check the list below.
 ";
 
 pub fn args() -> clap::Command {
     clap::command!("status")
         .alias("st")
         .about(HELP_TEXT)
         .arg(
             Arg::new("file")
                 .value_parser(clap::value_parser!(std::ffi::OsString))
                 .help("show only these files")
                 .action(clap::ArgAction::Append),
         )
         .arg(
             Arg::new("all")
                 .help("show status of all files")
                 .short('A')
                 .action(clap::ArgAction::SetTrue)
                 .long("all"),
         )
         .arg(
             Arg::new("modified")
                 .help("show only modified files")
                 .short('m')
                 .action(clap::ArgAction::SetTrue)
                 .long("modified"),
         )
         .arg(
             Arg::new("added")
                 .help("show only added files")
                 .short('a')
                 .action(clap::ArgAction::SetTrue)
                 .long("added"),
         )
         .arg(
             Arg::new("removed")
                 .help("show only removed files")
                 .short('r')
                 .action(clap::ArgAction::SetTrue)
                 .long("removed"),
         )
         .arg(
             Arg::new("clean")
                 .help("show only clean files")
                 .short('c')
                 .action(clap::ArgAction::SetTrue)
                 .long("clean"),
         )
         .arg(
             Arg::new("deleted")
                 .help("show only deleted files")
                 .short('d')
                 .action(clap::ArgAction::SetTrue)
                 .long("deleted"),
         )
         .arg(
             Arg::new("unknown")
                 .help("show only unknown (not tracked) files")
                 .short('u')
                 .action(clap::ArgAction::SetTrue)
                 .long("unknown"),
         )
         .arg(
             Arg::new("ignored")
                 .help("show only ignored files")
                 .short('i')
                 .action(clap::ArgAction::SetTrue)
                 .long("ignored"),
         )
         .arg(
             Arg::new("copies")
                 .help("show source of copied files (DEFAULT: ui.statuscopies)")
                 .short('C')
                 .action(clap::ArgAction::SetTrue)
                 .long("copies"),
         )
         .arg(
             Arg::new("print0")
                 .help("end filenames with NUL, for use with xargs")
                 .short('0')
                 .action(clap::ArgAction::SetTrue)
                 .long("print0"),
         )
         .arg(
             Arg::new("no-status")
                 .help("hide status prefix")
                 .short('n')
                 .action(clap::ArgAction::SetTrue)
                 .long("no-status"),
         )
         .arg(
             Arg::new("verbose")
                 .help("enable additional output")
                 .short('v')
                 .action(clap::ArgAction::SetTrue)
                 .long("verbose"),
         )
         .arg(
             Arg::new("rev")
                 .help("show difference from/to revision")
                 .long("rev")
                 .num_args(1)
                 .action(clap::ArgAction::Append)
                 .value_name("REV"),
         )
 }
 
 fn parse_revpair(
     repo: &Repo,
     revs: Option<Vec<String>>,
 ) -> Result<Option<(Revision, Revision)>, CommandError> {
     let revs = match revs {
         None => return Ok(None),
         Some(revs) => revs,
     };
     if revs.is_empty() {
         return Ok(None);
     }
     if revs.len() != 2 {
         return Err(CommandError::unsupported("expected 0 or 2 --rev flags"));
     }
 
     let rev1 = &revs[0];
     let rev2 = &revs[1];
     let rev1 = hg::revset::resolve_single(rev1, repo)
         .map_err(|e| (e, rev1.as_str()))?;
     let rev2 = hg::revset::resolve_single(rev2, repo)
         .map_err(|e| (e, rev2.as_str()))?;
     Ok(Some((rev1, rev2)))
 }
 
 /// Pure data type allowing the caller to specify file states to display
 #[derive(Copy, Clone, Debug)]
 pub struct DisplayStates {
     pub modified: bool,
     pub added: bool,
     pub removed: bool,
     pub clean: bool,
     pub deleted: bool,
     pub unknown: bool,
     pub ignored: bool,
 }
 
 pub const DEFAULT_DISPLAY_STATES: DisplayStates = DisplayStates {
     modified: true,
     added: true,
     removed: true,
     clean: false,
     deleted: true,
     unknown: true,
     ignored: false,
 };
 
 pub const ALL_DISPLAY_STATES: DisplayStates = DisplayStates {
     modified: true,
     added: true,
     removed: true,
     clean: true,
     deleted: true,
     unknown: true,
     ignored: true,
 };
 
 impl DisplayStates {
     pub fn is_empty(&self) -> bool {
         !(self.modified
             || self.added
             || self.removed
             || self.clean
             || self.deleted
             || self.unknown
             || self.ignored)
     }
 }
 
 fn has_unfinished_merge(repo: &Repo) -> Result<bool, CommandError> {
     Ok(repo.dirstate_parents()?.is_merge())
 }
 
 fn has_unfinished_state(repo: &Repo) -> Result<bool, CommandError> {
     // These are all the known values for the [fname] argument of
     // [addunfinished] function in [state.py]
     let known_state_files: &[&str] = &[
         "bisect.state",
         "graftstate",
         "histedit-state",
         "rebasestate",
         "shelvedstate",
         "transplant/journal",
         "updatestate",
     ];
     if has_unfinished_merge(repo)? {
         return Ok(true);
     };
     for f in known_state_files {
         if repo.hg_vfs().join(f).exists() {
             return Ok(true);
         }
     }
     Ok(false)
 }
 
 pub fn run(invocation: &crate::CliInvocation) -> Result<(), CommandError> {
     // TODO: lift these limitations
     if invocation
         .config
         .get(b"commands", b"status.terse")
         .is_some()
     {
         return Err(CommandError::unsupported(
             "status.terse is not yet supported with rhg status",
         ));
     }
 
     let ui = invocation.ui;
     let config = invocation.config;
     let args = invocation.subcommand_args;
 
     let revs = args.get_many::<String>("rev");
     let print0 = args.get_flag("print0");
     let verbose = args.get_flag("verbose")
         || config.get_bool(b"ui", b"verbose")?
         || config.get_bool(b"commands", b"status.verbose")?;
     let verbose = verbose && !print0;
 
     let all = args.get_flag("all");
     let display_states = if all {
         // TODO when implementing `--quiet`: it excludes clean files
         // from `--all`
         ALL_DISPLAY_STATES
     } else {
         let requested = DisplayStates {
             modified: args.get_flag("modified"),
             added: args.get_flag("added"),
             removed: args.get_flag("removed"),
             clean: args.get_flag("clean"),
             deleted: args.get_flag("deleted"),
             unknown: args.get_flag("unknown"),
             ignored: args.get_flag("ignored"),
         };
         if requested.is_empty() {
             DEFAULT_DISPLAY_STATES
         } else {
             requested
         }
     };
     let no_status = args.get_flag("no-status");
     let list_copies = all
         || args.get_flag("copies")
         || config.get_bool(b"ui", b"statuscopies")?;
 
     let repo = invocation.repo?;
     let revpair = parse_revpair(repo, revs.map(|i| i.cloned().collect()))?;
 
     if verbose && has_unfinished_state(repo)? {
         return Err(CommandError::unsupported(
             "verbose status output is not supported by rhg (and is needed because we're in an unfinished operation)",
         ));
     }
 
     let mut dmap = repo.dirstate_map_mut()?;
 
     let check_exec = hg::checkexec::check_exec(repo.working_directory_path());
 
     let options = StatusOptions {
         check_exec,
         list_clean: display_states.clean,
         list_unknown: display_states.unknown,
         list_ignored: display_states.ignored,
         list_copies,
         collect_traversed_dirs: false,
     };
 
     type StatusResult<'a> =
         Result<(DirstateStatus<'a>, Vec<PatternFileWarning>), StatusError>;
 
     let relative_status = config
         .get_option(b"commands", b"status.relative")?
         .expect("commands.status.relative should have a default value");
 
     let relativize_paths = relative_status || {
         // See in Python code with `getuipathfn` usage in `commands.py`.
         let legacy_relative_behavior = args.contains_id("file");
         match relative_paths(invocation.config)? {
             RelativePaths::Legacy => legacy_relative_behavior,
             RelativePaths::Bool(v) => v,
         }
     };
 
     let mut output = DisplayStatusPaths {
         ui,
         no_status,
         relativize: if relativize_paths {
             Some(RelativizePaths::new(repo)?)
         } else {
             None
         },
         print0,
     };
 
     let after_status = |res: StatusResult| -> Result<_, CommandError> {
         let (mut ds_status, pattern_warnings) = res?;
         for warning in pattern_warnings {
             ui.write_stderr(&format_pattern_file_warning(&warning, repo))?;
         }
 
         for (path, error) in take(&mut ds_status.bad) {
             let error = match error {
                 hg::BadMatch::OsError(code) => {
                     std::io::Error::from_raw_os_error(code).to_string()
                 }
                 hg::BadMatch::BadType(ty) => {
                     format!("unsupported file type (type is {})", ty)
                 }
             };
             ui.write_stderr(&format_bytes!(
                 b"{}: {}\n",
                 path.as_bytes(),
                 error.as_bytes()
             ))?
         }
         if !ds_status.unsure.is_empty() {
             info!(
                 "Files to be rechecked by retrieval from filelog: {:?}",
                 ds_status.unsure.iter().map(|s| &s.path).collect::<Vec<_>>()
             );
         }
         let mut fixup = Vec::new();
         if !ds_status.unsure.is_empty()
             && (display_states.modified || display_states.clean)
         {
             let p1 = repo.dirstate_parents()?.p1;
             let manifest = repo.manifest_for_node(p1).map_err(|e| {
                 CommandError::from((e, &*format!("{:x}", p1.short())))
             })?;
             let working_directory_vfs = repo.working_directory_vfs();
             let store_vfs = repo.store_vfs();
             let revlog_open_options =
                 repo.default_revlog_options(RevlogType::Manifestlog)?;
             let res: Vec<_> = take(&mut ds_status.unsure)
                 .into_par_iter()
                 .map(|to_check| {
                     // The compiler seems to get a bit confused with complex
                     // inference when using a parallel iterator + map
                     // + map_err + collect, so let's just inline some of the
                     // logic.
                     match unsure_is_modified(
-                        working_directory_vfs,
-                        store_vfs,
+                        &working_directory_vfs,
+                        &store_vfs,
                         check_exec,
                         &manifest,
                         &to_check.path,
                         revlog_open_options,
                     ) {
                         Err(HgError::IoError { .. }) => {
                             // IO errors most likely stem from the file being
                             // deleted even though we know it's in the
                             // dirstate.
                             Ok((to_check, UnsureOutcome::Deleted))
                         }
                         Ok(outcome) => Ok((to_check, outcome)),
                         Err(e) => Err(e),
                     }
                 })
                 .collect::<Result<_, _>>()?;
             for (status_path, outcome) in res.into_iter() {
                 match outcome {
                     UnsureOutcome::Clean => {
                         if display_states.clean {
                             ds_status.clean.push(status_path.clone());
                         }
                         fixup.push(status_path.path.into_owned())
                     }
                     UnsureOutcome::Modified => {
                         if display_states.modified {
                             ds_status.modified.push(status_path);
                         }
                     }
                     UnsureOutcome::Deleted => {
                         if display_states.deleted {
                             ds_status.deleted.push(status_path);
                         }
                     }
                 }
             }
         }
 
         let dirstate_write_needed = ds_status.dirty;
         let filesystem_time_at_status_start =
             ds_status.filesystem_time_at_status_start;
 
         output.output(display_states, ds_status)?;
 
         Ok((
             fixup,
             dirstate_write_needed,
             filesystem_time_at_status_start,
         ))
     };
     let (narrow_matcher, narrow_warnings) = narrow::matcher(repo)?;
 
     if let Some((rev1, rev2)) = revpair {
         let mut ds_status = DirstateStatus::default();
         if list_copies {
             return Err(CommandError::unsupported(
                 "status --rev --rev with copy information is not implemented yet",
             ));
         }
 
         let stat = hg::operations::status_rev_rev_no_copies(
             repo,
             rev1,
             rev2,
             narrow_matcher,
         )?;
         for entry in stat.iter() {
             let (path, status) = entry?;
             let path = StatusPath {
                 path: Cow::Borrowed(path),
                 copy_source: None,
             };
             match status {
                 hg::operations::DiffStatus::Removed => {
                     if display_states.removed {
                         ds_status.removed.push(path)
                     }
                 }
                 hg::operations::DiffStatus::Added => {
                     if display_states.added {
                         ds_status.added.push(path)
                     }
                 }
                 hg::operations::DiffStatus::Modified => {
                     if display_states.modified {
                         ds_status.modified.push(path)
                     }
                 }
                 hg::operations::DiffStatus::Matching => {
                     if display_states.clean {
                         ds_status.clean.push(path)
                     }
                 }
             }
         }
         output.output(display_states, ds_status)?;
         return Ok(());
     }
 
     let (sparse_matcher, sparse_warnings) = sparse::matcher(repo)?;
     let matcher = match (repo.has_narrow(), repo.has_sparse()) {
         (true, true) => {
             Box::new(IntersectionMatcher::new(narrow_matcher, sparse_matcher))
         }
         (true, false) => narrow_matcher,
         (false, true) => sparse_matcher,
         (false, false) => Box::new(AlwaysMatcher),
     };
     let matcher = match args.get_many::<std::ffi::OsString>("file") {
         None => matcher,
         Some(files) => {
             let patterns: Vec<Vec<u8>> = files
                 .filter(|s| !s.is_empty())
                 .map(get_bytes_from_os_str)
                 .collect();
             for file in &patterns {
                 if file.starts_with(b"set:") {
                     return Err(CommandError::unsupported("fileset"));
                 }
             }
             let cwd = hg::utils::current_dir()?;
             let root = repo.working_directory_path();
             let ignore_patterns = parse_pattern_args(patterns, &cwd, root)?;
             let files_matcher =
                 hg::matchers::PatternMatcher::new(ignore_patterns)?;
             Box::new(IntersectionMatcher::new(
                 Box::new(files_matcher),
                 matcher,
             ))
         }
     };
 
     print_narrow_sparse_warnings(
         &narrow_warnings,
         &sparse_warnings,
         ui,
         repo,
     )?;
     let (fixup, mut dirstate_write_needed, filesystem_time_at_status_start) =
         dmap.with_status(
             matcher.as_ref(),
             repo.working_directory_path().to_owned(),
             ignore_files(repo, config),
             options,
             after_status,
         )?;
 
     // Development config option to test write races
     if let Err(e) =
         debug_wait_for_file(config, "status.pre-dirstate-write-file")
     {
         ui.write_stderr(e.as_bytes()).ok();
     }
 
     if (fixup.is_empty() || filesystem_time_at_status_start.is_none())
         && !dirstate_write_needed
     {
         // Nothing to update
         return Ok(());
     }
 
     // Update the dirstate on disk if we can
     let with_lock_result =
         repo.try_with_wlock_no_wait(|| -> Result<(), CommandError> {
             if let Some(mtime_boundary) = filesystem_time_at_status_start {
                 for hg_path in fixup {
                     use std::os::unix::fs::MetadataExt;
                     let fs_path = hg_path_to_path_buf(&hg_path)
                         .expect("HgPath conversion");
                     // Specifically do not reuse `fs_metadata` from
                     // `unsure_is_clean` which was needed before reading
                     // contents. Here we access metadata again after reading
                     // content, in case it changed in the meantime.
                     let metadata_res = repo
                         .working_directory_vfs()
                         .symlink_metadata(&fs_path);
                     let fs_metadata = match metadata_res {
                         Ok(meta) => meta,
                         Err(err) => match err {
                             HgError::IoError { .. } => {
                                 // The file has probably been deleted. In any
                                 // case, it was in the dirstate before, so
                                 // let's ignore the error.
                                 continue;
                             }
                             _ => return Err(err.into()),
                         },
                     };
                     if let Some(mtime) =
                         TruncatedTimestamp::for_reliable_mtime_of(
                             &fs_metadata,
                             &mtime_boundary,
                         )
                         .when_reading_file(&fs_path)?
                     {
                         let mode = fs_metadata.mode();
                         let size = fs_metadata.len();
                         dmap.set_clean(&hg_path, mode, size as u32, mtime)?;
                         dirstate_write_needed = true
                     }
                 }
             }
             drop(dmap); // Avoid "already mutably borrowed" RefCell panics
             if dirstate_write_needed {
                 repo.write_dirstate()?
             }
             Ok(())
         });
     match with_lock_result {
         Ok(closure_result) => closure_result?,
         Err(LockError::AlreadyHeld) => {
             // Not updating the dirstate is not ideal but not critical:
             // don’t keep our caller waiting until some other Mercurial
             // process releases the lock.
             log::info!("not writing dirstate from `status`: lock is held")
         }
         Err(LockError::Other(HgError::IoError { error, .. }))
             if error.kind() == io::ErrorKind::PermissionDenied
                 || match error.raw_os_error() {
                     None => false,
                     Some(errno) => libc::EROFS == errno,
                 } =>
         {
             // `hg status` on a read-only repository is fine
         }
         Err(LockError::Other(error)) => {
             // Report other I/O errors
             Err(error)?
         }
     }
     Ok(())
 }
 
 fn ignore_files(repo: &Repo, config: &Config) -> Vec<PathBuf> {
     let mut ignore_files = Vec::new();
     let repo_ignore = repo.working_directory_vfs().join(".hgignore");
     if repo_ignore.exists() {
         ignore_files.push(repo_ignore)
     }
     for (key, value) in config.iter_section(b"ui") {
         if key == b"ignore" || key.starts_with(b"ignore.") {
             let path = get_path_from_bytes(value);
             let path = shellexpand::path::full_with_context_no_errors(
                 path,
                 home::home_dir,
                 |s| std::env::var(s).ok(),
             );
             let joined = repo.working_directory_path().join(path);
             ignore_files.push(joined);
         }
     }
     ignore_files
 }
 
 struct DisplayStatusPaths<'a> {
     ui: &'a Ui,
     no_status: bool,
     relativize: Option<RelativizePaths>,
     print0: bool,
 }
 
 impl DisplayStatusPaths<'_> {
     // Probably more elegant to use a Deref or Borrow trait rather than
     // harcode HgPathBuf, but probably not really useful at this point
     fn display(
         &self,
         status_prefix: &[u8],
         label: &'static str,
         mut paths: Vec<StatusPath<'_>>,
     ) -> Result<(), CommandError> {
         paths.sort_unstable();
         // TODO: get the stdout lock once for the whole loop
         // instead of in each write
         for StatusPath { path, copy_source } in paths {
             let relative_path;
             let relative_source;
             let (path, copy_source) = if let Some(relativize) =
                 &self.relativize
             {
                 relative_path = relativize.relativize(&path);
                 relative_source =
                     copy_source.as_ref().map(|s| relativize.relativize(s));
                 (&*relative_path, relative_source.as_deref())
             } else {
                 (path.as_bytes(), copy_source.as_ref().map(|s| s.as_bytes()))
             };
             // TODO: Add a way to use `write_bytes!` instead of `format_bytes!`
             // in order to stream to stdout instead of allocating an
             // itermediate `Vec<u8>`.
             if !self.no_status {
                 self.ui.write_stdout_labelled(status_prefix, label)?
             }
             let linebreak = if self.print0 { b"\x00" } else { b"\n" };
             self.ui.write_stdout_labelled(
                 &format_bytes!(b"{}{}", path, linebreak),
                 label,
             )?;
             if let Some(source) = copy_source.filter(|_| !self.no_status) {
                 let label = "status.copied";
                 self.ui.write_stdout_labelled(
                     &format_bytes!(b"  {}{}", source, linebreak),
                     label,
                 )?
             }
         }
         Ok(())
     }
 
     fn output(
         &mut self,
         display_states: DisplayStates,
         ds_status: DirstateStatus,
     ) -> Result<(), CommandError> {
         if display_states.modified {
             self.display(b"M ", "status.modified", ds_status.modified)?;
         }
         if display_states.added {
             self.display(b"A ", "status.added", ds_status.added)?;
         }
         if display_states.removed {
             self.display(b"R ", "status.removed", ds_status.removed)?;
         }
         if display_states.deleted {
             self.display(b"! ", "status.deleted", ds_status.deleted)?;
         }
         if display_states.unknown {
             self.display(b"? ", "status.unknown", ds_status.unknown)?;
         }
         if display_states.ignored {
             self.display(b"I ", "status.ignored", ds_status.ignored)?;
         }
         if display_states.clean {
             self.display(b"C ", "status.clean", ds_status.clean)?;
         }
         Ok(())
     }
 }
 
 /// Outcome of the additional check for an ambiguous tracked file
 enum UnsureOutcome {
     /// The file is actually clean
     Clean,
     /// The file has been modified
     Modified,
     /// The file was deleted on disk (or became another type of fs entry)
     Deleted,
 }
 
 /// Check if a file is modified by comparing actual repo store and file system.
 ///
 /// This meant to be used for those that the dirstate cannot resolve, due
 /// to time resolution limits.
 fn unsure_is_modified(
-    working_directory_vfs: hg::vfs::Vfs,
-    store_vfs: hg::vfs::Vfs,
+    working_directory_vfs: &hg::vfs::VfsImpl,
+    store_vfs: &hg::vfs::VfsImpl,
     check_exec: bool,
     manifest: &Manifest,
     hg_path: &HgPath,
     revlog_open_options: RevlogOpenOptions,
 ) -> Result<UnsureOutcome, HgError> {
     let vfs = working_directory_vfs;
     let fs_path = hg_path_to_path_buf(hg_path).expect("HgPath conversion");
     let fs_metadata = vfs.symlink_metadata(&fs_path)?;
     let is_symlink = fs_metadata.file_type().is_symlink();
 
     let entry = manifest
         .find_by_path(hg_path)?
         .expect("ambgious file not in p1");
 
     // TODO: Also account for `FALLBACK_SYMLINK` and `FALLBACK_EXEC` from the
     // dirstate
     let fs_flags = if is_symlink {
         Some(b'l')
     } else if check_exec && has_exec_bit(&fs_metadata) {
         Some(b'x')
     } else {
         None
     };
 
     let entry_flags = if check_exec {
         entry.flags
     } else if entry.flags == Some(b'x') {
         None
     } else {
         entry.flags
     };
 
     if entry_flags != fs_flags {
         return Ok(UnsureOutcome::Modified);
     }
     let filelog = hg::filelog::Filelog::open_vfs(
-        &store_vfs,
+        store_vfs,
         hg_path,
         revlog_open_options,
     )?;
     let fs_len = fs_metadata.len();
     let file_node = entry.node_id()?;
     let filelog_entry = filelog.entry_for_node(file_node).map_err(|_| {
         HgError::corrupted(format!(
             "filelog {:?} missing node {:?} from manifest",
             hg_path, file_node
         ))
     })?;
     if filelog_entry.file_data_len_not_equal_to(fs_len) {
         // No need to read file contents:
         // it cannot be equal if it has a different length.
         return Ok(UnsureOutcome::Modified);
     }
 
     let p1_filelog_data = filelog_entry.data()?;
     let p1_contents = p1_filelog_data.file_data()?;
     if p1_contents.len() as u64 != fs_len {
         // No need to read file contents:
         // it cannot be equal if it has a different length.
         return Ok(UnsureOutcome::Modified);
     }
 
     let fs_contents = if is_symlink {
         get_bytes_from_os_string(vfs.read_link(fs_path)?.into_os_string())
     } else {
         vfs.read(fs_path)?
     };
 
     Ok(if p1_contents != &*fs_contents {
         UnsureOutcome::Modified
     } else {
         UnsureOutcome::Clean
     })
 }