rust-index: stop using C index

We still keep its wrapper implementation in `hg-cpython::cindex`,
because we might want to recreate ancestors handling objects using
it for the case of REVLOGV2.

Also, we still instantiate it (from Python code) and store it as
attribute, for the likes of `get_cindex` and the caller that
relies on it, but that is soon to be removed, too.

rust/hg-cpython/src/revlog.rs

@@ -14,9 +14,9 b' use crate::{'
 use cpython::{
     buffer::{Element, PyBuffer},
     exc::{IndexError, ValueError},
-    ObjectProtocol, PyBool, PyBytes, PyClone, PyDict, PyErr, PyInt, PyList,
-    PyModule, PyObject, PyResult, PySet, PyString, PyTuple, Python,
-    PythonObject, ToPyObject, UnsafePyLeaked,
+    ObjectProtocol, PyBytes, PyClone, PyDict, PyErr, PyInt, PyList, PyModule,
+    PyObject, PyResult, PySet, PyString, PyTuple, Python, PythonObject,
+    ToPyObject, UnsafePyLeaked,
 };
 use hg::{
     errors::HgError,
@@ -123,14 +123,10 b' py_class!(pub class MixedIndex |py| {'
     def get_rev(&self, node: PyBytes) -> PyResult<Option<PyRevision>> {
         let opt = self.get_nodetree(py)?.borrow();
         let nt = opt.as_ref().unwrap();
-        let idx = &*self.cindex(py).borrow();
         let ridx = &*self.index(py).borrow();
         let node = node_from_py_bytes(py, &node)?;
         let rust_rev =
             nt.find_bin(ridx, node.into()).map_err(|e| nodemap_error(py, e))?;
-        let c_rev =
-            nt.find_bin(idx, node.into()).map_err(|e| nodemap_error(py, e))?;
-        assert_eq!(rust_rev, c_rev);
         Ok(rust_rev.map(Into::into))
 
     }
@@ -202,24 +198,22 b' py_class!(pub class MixedIndex |py| {'
         let node = node_from_py_object(py, &node_bytes)?;
 
         let rev = self.len(py)? as BaseRevision;
-        let mut idx = self.cindex(py).borrow_mut();
 
         // This is ok since we will just add the revision to the index
         let rev = Revision(rev);
-        idx.append(py, tup.clone_ref(py))?;
         self.index(py)
             .borrow_mut()
             .append(py_tuple_to_revision_data_params(py, tup)?)
             .unwrap();
+        let idx = &*self.index(py).borrow();
         self.get_nodetree(py)?.borrow_mut().as_mut().unwrap()
-            .insert(&*idx, &node, rev)
+            .insert(idx, &node, rev)
             .map_err(|e| nodemap_error(py, e))?;
         Ok(py.None())
     }
 
     def __delitem__(&self, key: PyObject) -> PyResult<()> {
         // __delitem__ is both for `del idx[r]` and `del idx[r1:r2]`
-        self.cindex(py).borrow().inner().del_item(py, &key)?;
         let start = key.getattr(py, "start")?;
         let start = UncheckedRevision(start.extract(py)?);
         let start = self.index(py)
@@ -237,80 +231,60 b' py_class!(pub class MixedIndex |py| {'
     }
 
     //
-    // Reforwarded C index API
+    // Index methods previously reforwarded to C index (tp_methods)
+    // Same ordering as in revlog.c
     //
 
-    // index_methods (tp_methods). Same ordering as in revlog.c
-
     /// return the gca set of the given revs
-    def ancestors(&self, *args, **kw) -> PyResult<PyObject> {
+    def ancestors(&self, *args, **_kw) -> PyResult<PyObject> {
         let rust_res = self.inner_ancestors(py, args)?;
-
-        let c_res = self.call_cindex(py, "ancestors", args, kw)?;
-        // the algorithm should always provide the results in reverse ordering
-        assert_py_eq(py, "ancestors", &rust_res, &c_res)?;
-
         Ok(rust_res)
     }
 
     /// return the heads of the common ancestors of the given revs
-    def commonancestorsheads(&self, *args, **kw) -> PyResult<PyObject> {
+    def commonancestorsheads(&self, *args, **_kw) -> PyResult<PyObject> {
         let rust_res = self.inner_commonancestorsheads(py, args)?;
-
-        let c_res = self.call_cindex(py, "commonancestorsheads", args, kw)?;
-        // the algorithm should always provide the results in reverse ordering
-        assert_py_eq(py, "commonancestorsheads", &rust_res, &c_res)?;
-
         Ok(rust_res)
     }
 
     /// Clear the index caches and inner py_class data.
     /// It is Python's responsibility to call `update_nodemap_data` again.
-    def clearcaches(&self, *args, **kw) -> PyResult<PyObject> {
+    def clearcaches(&self) -> PyResult<PyObject> {
         self.nt(py).borrow_mut().take();
         self.docket(py).borrow_mut().take();
         self.nodemap_mmap(py).borrow_mut().take();
         self.index(py).borrow().clear_caches();
-        self.call_cindex(py, "clearcaches", args, kw)
+        Ok(py.None())
     }
 
     /// return the raw binary string representing a revision
-    def entry_binary(&self, *args, **kw) -> PyResult<PyObject> {
+    def entry_binary(&self, *args, **_kw) -> PyResult<PyObject> {
         let rindex = self.index(py).borrow();
         let rev = UncheckedRevision(args.get_item(py, 0).extract(py)?);
         let rust_bytes = rindex.check_revision(rev).and_then(
             |r| rindex.entry_binary(r))
             .ok_or_else(|| rev_not_in_index(py, rev))?;
         let rust_res = PyBytes::new(py, rust_bytes).into_object();
-
-        let c_res = self.call_cindex(py, "entry_binary", args, kw)?;
-        assert_py_eq(py, "entry_binary", &rust_res, &c_res)?;
         Ok(rust_res)
     }
 
     /// return a binary packed version of the header
-    def pack_header(&self, *args, **kw) -> PyResult<PyObject> {
+    def pack_header(&self, *args, **_kw) -> PyResult<PyObject> {
         let rindex = self.index(py).borrow();
         let packed = rindex.pack_header(args.get_item(py, 0).extract(py)?);
         let rust_res = PyBytes::new(py, &packed).into_object();
-
-        let c_res = self.call_cindex(py, "pack_header", args, kw)?;
-        assert_py_eq(py, "pack_header", &rust_res, &c_res)?;
         Ok(rust_res)
     }
 
     /// compute phases
-    def computephasesmapsets(&self, *args, **kw) -> PyResult<PyObject> {
+    def computephasesmapsets(&self, *args, **_kw) -> PyResult<PyObject> {
         let py_roots = args.get_item(py, 0).extract::<PyDict>(py)?;
         let rust_res = self.inner_computephasesmapsets(py, py_roots)?;
-
-        let c_res = self.call_cindex(py, "computephasesmapsets", args, kw)?;
-        assert_py_eq(py, "computephasesmapsets", &rust_res, &c_res)?;
         Ok(rust_res)
     }
 
     /// reachableroots
-    def reachableroots2(&self, *args, **kw) -> PyResult<PyObject> {
+    def reachableroots2(&self, *args, **_kw) -> PyResult<PyObject> {
         let rust_res = self.inner_reachableroots2(
             py,
             UncheckedRevision(args.get_item(py, 0).extract(py)?),
@@ -318,51 +292,34 b' py_class!(pub class MixedIndex |py| {'
             args.get_item(py, 2),
             args.get_item(py, 3).extract(py)?,
         )?;
-
-        let c_res = self.call_cindex(py, "reachableroots2", args, kw)?;
-        // ordering of C result depends on how the computation went, and
-        // Rust result ordering is arbitrary. Hence we compare after
-        // sorting the results (in Python to avoid reconverting everything
-        // back to Rust structs).
-        assert_py_eq_normalized(py, "reachableroots2", &rust_res, &c_res,
-                                |v| format!("sorted({})", v))?;
-
         Ok(rust_res)
     }
 
     /// get head revisions
-    def headrevs(&self, *args, **kw) -> PyResult<PyObject> {
+    def headrevs(&self) -> PyResult<PyObject> {
         let rust_res = self.inner_headrevs(py)?;
-
-        let c_res = self.call_cindex(py, "headrevs", args, kw)?;
-        assert_py_eq(py, "headrevs", &rust_res, &c_res)?;
         Ok(rust_res)
     }
 
     /// get filtered head revisions
-    def headrevsfiltered(&self, *args, **kw) -> PyResult<PyObject> {
+    def headrevsfiltered(&self, *args, **_kw) -> PyResult<PyObject> {
         let rust_res = self.inner_headrevsfiltered(py, &args.get_item(py, 0))?;
-        let c_res = self.call_cindex(py, "headrevsfiltered", args, kw)?;
-
-        assert_py_eq(py, "headrevsfiltered", &rust_res, &c_res)?;
         Ok(rust_res)
     }
 
     /// True if the object is a snapshot
-    def issnapshot(&self, *args, **kw) -> PyResult<bool> {
+    def issnapshot(&self, *args, **_kw) -> PyResult<bool> {
         let index = self.index(py).borrow();
         let result = index
             .is_snapshot(UncheckedRevision(args.get_item(py, 0).extract(py)?))
             .map_err(|e| {
                 PyErr::new::<cpython::exc::ValueError, _>(py, e.to_string())
             })?;
-        let cresult = self.call_cindex(py, "issnapshot", args, kw)?;
-        assert_eq!(result, cresult.extract(py)?);
         Ok(result)
     }
 
     /// Gather snapshot data in a cache dict
-    def findsnapshots(&self, *args, **kw) -> PyResult<PyObject> {
+    def findsnapshots(&self, *args, **_kw) -> PyResult<PyObject> {
         let index = self.index(py).borrow();
         let cache: PyDict = args.get_item(py, 0).extract(py)?;
         // this methods operates by setting new values in the cache,
@@ -382,24 +339,11 b' py_class!(pub class MixedIndex |py| {'
             end_rev,
             &mut cache_wrapper,
         ).map_err(|_| revlog_error(py))?;
-
-        let c_args = PyTuple::new(
-            py,
-            &[
-                c_cache.clone_ref(py).into_object(),
-                args.get_item(py, 1),
-                args.get_item(py, 2)
-            ]
-        );
-        self.call_cindex(py, "findsnapshots", &c_args, kw)?;
-        assert_py_eq(py, "findsnapshots cache",
-                     &cache_wrapper.into_object(),
-                     &c_cache.into_object())?;
         Ok(py.None())
     }
 
     /// determine revisions with deltas to reconstruct fulltext
-    def deltachain(&self, *args, **kw) -> PyResult<PyObject> {
+    def deltachain(&self, *args, **_kw) -> PyResult<PyObject> {
         let index = self.index(py).borrow();
         let rev = args.get_item(py, 0).extract::<BaseRevision>(py)?.into();
         let stop_rev =
@@ -422,13 +366,7 b' py_class!(pub class MixedIndex |py| {'
             PyErr::new::<cpython::exc::ValueError, _>(py, e.to_string())
         })?;
 
-        let cresult = self.call_cindex(py, "deltachain", args, kw)?;
-        let cchain: Vec<BaseRevision> =
-            cresult.get_item(py, 0)?.extract::<Vec<BaseRevision>>(py)?;
         let chain: Vec<_> = chain.into_iter().map(|r| r.0).collect();
-        assert_eq!(chain, cchain);
-        assert_eq!(stopped, cresult.get_item(py, 1)?.extract(py)?);
-
         Ok(
             PyTuple::new(
                 py,
@@ -442,16 +380,13 b' py_class!(pub class MixedIndex |py| {'
     }
 
     /// slice planned chunk read to reach a density threshold
-    def slicechunktodensity(&self, *args, **kw) -> PyResult<PyObject> {
+    def slicechunktodensity(&self, *args, **_kw) -> PyResult<PyObject> {
         let rust_res = self.inner_slicechunktodensity(
             py,
             args.get_item(py, 0),
             args.get_item(py, 1).extract(py)?,
             args.get_item(py, 2).extract(py)?
         )?;
-
-        let c_res = self.call_cindex(py, "slicechunktodensity", args, kw)?;
-        assert_py_eq(py, "slicechunktodensity", &rust_res, &c_res)?;
         Ok(rust_res)
     }
 
@@ -468,23 +403,6 b' py_class!(pub class MixedIndex |py| {'
 
     def __getitem__(&self, key: PyObject) -> PyResult<PyObject> {
         let rust_res = self.inner_getitem(py, key.clone_ref(py))?;
-
-        // this conversion seems needless, but that's actually because
-        // `index_getitem` does not handle conversion from PyLong,
-        // which expressions such as [e for e in index] internally use.
-        // Note that we don't seem to have a direct way to call
-        // PySequence_GetItem (does the job), which would possibly be better
-        // for performance
-        // gracinet 2023: the above comment can be removed when we use
-        // the pure Rust impl only. Note also that `key` can be a binary
-        // node id.
-        let c_key = match key.extract::<BaseRevision>(py) {
-            Ok(rev) => rev.to_py_object(py).into_object(),
-            Err(_) => key,
-        };
-        let c_res = self.cindex(py).borrow().inner().get_item(py, c_key)?;
-
-        assert_py_eq(py, "__getitem__", &rust_res, &c_res)?;
         Ok(rust_res)
     }
 
@@ -492,7 +410,6 b' py_class!(pub class MixedIndex |py| {'
         // ObjectProtocol does not seem to provide contains(), so
         // this is an equivalent implementation of the index_contains()
         // defined in revlog.c
-        let cindex = self.cindex(py).borrow();
         match item.extract::<i32>(py) {
             Ok(rev) => {
                 Ok(rev >= -1 && rev < self.len(py)? as BaseRevision)
@@ -500,15 +417,6 b' py_class!(pub class MixedIndex |py| {'
             Err(_) => {
                 let item_bytes: PyBytes = item.extract(py)?;
                 let rust_res = self.has_node(py, item_bytes)?;
-
-                let c_res = cindex.inner().call_method(
-                    py,
-                    "has_node",
-                    PyTuple::new(py, &[item.clone_ref(py)]),
-                    None)?
-                .extract(py)?;
-
-                assert_eq!(rust_res, c_res);
                 Ok(rust_res)
             }
         }
@@ -532,11 +440,6 b' py_class!(pub class MixedIndex |py| {'
     @property
     def entry_size(&self) -> PyResult<PyInt> {
         let rust_res: PyInt = INDEX_ENTRY_SIZE.to_py_object(py);
-
-        let c_res = self.cindex(py).borrow().inner()
-            .getattr(py, "entry_size")?;
-        assert_py_eq(py, "entry_size", rust_res.as_object(), &c_res)?;
-
         Ok(rust_res)
     }
 
@@ -545,11 +448,6 b' py_class!(pub class MixedIndex |py| {'
         // will be entirely removed when the Rust index yet useful to
         // implement in Rust to detangle things when removing `self.cindex`
         let rust_res: PyInt = 1.to_py_object(py);
-
-        let c_res = self.cindex(py).borrow().inner()
-            .getattr(py, "rust_ext_compat")?;
-        assert_py_eq(py, "rust_ext_compat", rust_res.as_object(), &c_res)?;
-
         Ok(rust_res)
     }
 
@@ -672,12 +570,6 b" struct PySnapshotsCache<'p> {"
     dict: PyDict,
 }
 
-impl<'p> PySnapshotsCache<'p> {
-    fn into_object(self) -> PyObject {
-        self.dict.into_object()
-    }
-}
-
 impl<'p> SnapshotsCache for PySnapshotsCache<'p> {
     fn insert_for(
         &mut self,
@@ -731,8 +623,6 b' impl MixedIndex {'
 
     fn len(&self, py: Python) -> PyResult<usize> {
         let rust_index_len = self.index(py).borrow().len();
-        let cindex_len = self.cindex(py).borrow().inner().len(py)?;
-        assert_eq!(rust_index_len, cindex_len);
         Ok(rust_index_len)
     }
 
@@ -767,20 +657,6 b' impl MixedIndex {'
         Ok(self.nt(py))
     }
 
-    /// forward a method call to the underlying C index
-    fn call_cindex(
-        &self,
-        py: Python,
-        name: &str,
-        args: &PyTuple,
-        kwargs: Option<&PyDict>,
-    ) -> PyResult<PyObject> {
-        self.cindex(py)
-            .borrow()
-            .inner()
-            .call_method(py, name, args, kwargs)
-    }
-
     pub fn clone_cindex(&self, py: Python) -> cindex::Index {
         self.cindex(py).borrow().clone_ref(py)
     }
@@ -1144,51 +1020,6 b' fn nodemap_error(py: Python, err: NodeMa'
     }
 }
 
-/// assert two Python objects to be equal from a Python point of view
-///
-/// `method` is a label for the assertion error message, intended to be the
-/// name of the caller.
-/// `normalizer` is a function that takes a Python variable name and returns
-/// an expression that the conparison will actually use.
-/// Foe example: `|v| format!("sorted({})", v)`
-fn assert_py_eq_normalized(
-    py: Python,
-    method: &str,
-    rust: &PyObject,
-    c: &PyObject,
-    normalizer: impl FnOnce(&str) -> String + Copy,
-) -> PyResult<()> {
-    let locals = PyDict::new(py);
-    locals.set_item(py, "rust".into_py_object(py).into_object(), rust)?;
-    locals.set_item(py, "c".into_py_object(py).into_object(), c)?;
-    //    let lhs = format!(normalizer_fmt, "rust");
-    //    let rhs = format!(normalizer_fmt, "c");
-    let is_eq: PyBool = py
-        .eval(
-            &format!("{} == {}", &normalizer("rust"), &normalizer("c")),
-            None,
-            Some(&locals),
-        )?
-        .extract(py)?;
-    assert!(
-        is_eq.is_true(),
-        "{} results differ. Rust: {:?} C: {:?} (before any normalization)",
-        method,
-        rust,
-        c
-    );
-    Ok(())
-}
-
-fn assert_py_eq(
-    py: Python,
-    method: &str,
-    rust: &PyObject,
-    c: &PyObject,
-) -> PyResult<()> {
-    assert_py_eq_normalized(py, method, rust, c, |v| v.to_owned())
-}
-
 /// Create the module, with __package__ given from parent
 pub fn init_module(py: Python, package: &str) -> PyResult<PyModule> {
     let dotted_name = &format!("{}.revlog", package);