This is an archive of the discontinued Mercurial Phabricator instance.

Differential D7253

rust-status: remove dead code
ClosedPublic

Authored by Alphare on Nov 6 2019, 8:21 AM.

Details

Reviewers
kevincox
Group Reviewers
hg-reviewers
Commits
rHGab9b0a20b9e6: rust-status: remove dead code
Summary

The walk_explicit function is only called when using a prefix matcher, which
the Rust code does not yet support. This function will return in a future
patch, probably with a different signature for performance reasons.

With it, the files argument and its interface code can be removed for now.

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Event Timeline

Alphare created this revision.Nov 6 2019, 8:21 AM
kevincox accepted this revision.Nov 6 2019, 11:25 AM
Alphare added a commit: rHGab9b0a20b9e6: rust-status: remove dead code.Nov 6 2019, 1:58 PM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHGab9b0a20b9e6: rust-status: remove dead code (authored by Alphare). · Explain Why
This revision was automatically updated to reflect the committed changes.
Alphare updated this revision to Diff 17710.Nov 7 2019, 5:17 AM

Revision Contents
Changeset List

Diff 17710

mercurial/dirstate.py

added, added,
removed, removed,
deleted, deleted,
unknown, unknown,
clean, clean,
) = rustmod.status( ) = rustmod.status(
dmap._rustmap, dmap._rustmap,
self._rootdir, self._rootdir,
match.files(),
bool(listclean), bool(listclean),
self._lastnormaltime, self._lastnormaltime,
self._checkexec, self._checkexec,
) )
status = scmutil.status( status = scmutil.status(
modified=modified, modified=modified,
added=added, added=added,

rust/hg-core/src/dirstate/status.rs

// status.rs // status.rs
// //
// Copyright 2019 Raphaël Gomès <rgomes@octobus.net> // Copyright 2019 Raphaël Gomès <rgomes@octobus.net>
// //
// This software may be used and distributed according to the terms of the // This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version. // GNU General Public License version 2 or any later version.
//! Rust implementation of dirstate.status (dirstate.py). //! Rust implementation of dirstate.status (dirstate.py).
//! It is currently missing a lot of functionality compared to the Python one //! It is currently missing a lot of functionality compared to the Python one
//! and will only be triggered in narrow cases. //! and will only be triggered in narrow cases.
use crate::utils::files::HgMetadata; use crate::utils::files::HgMetadata;
use crate::utils::hg_path::{hg_path_to_path_buf, HgPath, HgPathBuf}; use crate::utils::hg_path::{hg_path_to_path_buf, HgPathBuf};
use crate::{DirstateEntry, DirstateMap, EntryState}; use crate::{DirstateEntry, DirstateMap, EntryState};
use rayon::prelude::*; use rayon::prelude::*;
use std::collections::HashMap;
use std::fs::Metadata;
use std::path::Path; use std::path::Path;
/// Get stat data about the files explicitly specified by match.
/// TODO subrepos
fn walk_explicit(
files: &[impl AsRef<HgPath> + Sync],
dmap: &DirstateMap,
root_dir: impl AsRef<Path> + Sync,
) -> std::io::Result<HashMap<HgPathBuf, Option<HgMetadata>>> {
let mut results = HashMap::new();
// A tuple of the normalized filename and the `Result` of the call to
// `symlink_metadata` for separate handling.
type WalkTuple<'a> = (&'a HgPath, std::io::Result<Metadata>);
let stats_res: std::io::Result<Vec<WalkTuple>> = files
.par_iter()
.map(|filename| {
// TODO normalization
let normalized = filename.as_ref();
let target_filename =
root_dir.as_ref().join(hg_path_to_path_buf(normalized)?);
Ok((normalized, target_filename.symlink_metadata()))
})
.collect();
for res in stats_res? {
match res {
(normalized, Ok(stat)) => {
if stat.is_file() {
results.insert(
normalized.to_owned(),
Some(HgMetadata::from_metadata(stat)),
);
} else {
if dmap.contains_key(normalized) {
results.insert(normalized.to_owned(), None);
}
}
}
(normalized, Err(_)) => {
if dmap.contains_key(normalized) {
results.insert(normalized.to_owned(), None);
}
}
};
}
Ok(results)
}
// Stat all entries in the `DirstateMap` and return their new metadata. // Stat all entries in the `DirstateMap` and return their new metadata.
pub fn stat_dmap_entries( pub fn stat_dmap_entries(
dmap: &DirstateMap, dmap: &DirstateMap,
results: &HashMap<HgPathBuf, Option<HgMetadata>>,
root_dir: impl AsRef<Path> + Sync, root_dir: impl AsRef<Path> + Sync,
) -> std::io::Result<Vec<(HgPathBuf, Option<HgMetadata>)>> { ) -> std::io::Result<Vec<(HgPathBuf, Option<HgMetadata>)>> {
dmap.par_iter() dmap.par_iter()
.filter_map( .filter_map(
// Getting file metadata is costly, so we don't do it if the // Getting file metadata is costly, so we don't do it if the
// file is already present in the results, hence `filter_map` // file is already present in the results, hence `filter_map`
|(filename, _)| -> Option< |(filename, _)| -> Option<
std::io::Result<(HgPathBuf, Option<HgMetadata>)> std::io::Result<(HgPathBuf, Option<HgMetadata>)>
> { > {
if results.contains_key(filename) {
return None;
}
let meta = match hg_path_to_path_buf(filename) { let meta = match hg_path_to_path_buf(filename) {
Ok(p) => root_dir.as_ref().join(p).symlink_metadata(), Ok(p) => root_dir.as_ref().join(p).symlink_metadata(),
Err(e) => return Some(Err(e.into())), Err(e) => return Some(Err(e.into())),
}; };
Some(match meta { Some(match meta {
Ok(ref m) Ok(ref m)
if !(m.file_type().is_file() if !(m.file_type().is_file()
// TODO unknown // TODO unknown
} }
fn build_response( fn build_response(
dmap: &DirstateMap, dmap: &DirstateMap,
list_clean: bool, list_clean: bool,
last_normal_time: i64, last_normal_time: i64,
check_exec: bool, check_exec: bool,
results: HashMap<HgPathBuf, Option<HgMetadata>>, results: Vec<(HgPathBuf, Option<HgMetadata>)>,
) -> (Vec<HgPathBuf>, StatusResult) { ) -> (Vec<HgPathBuf>, StatusResult) {
let mut lookup = vec![]; let mut lookup = vec![];
let mut modified = vec![]; let mut modified = vec![];
let mut added = vec![]; let mut added = vec![];
let mut removed = vec![]; let mut removed = vec![];
let mut deleted = vec![]; let mut deleted = vec![];
let mut clean = vec![]; let mut clean = vec![];
clean, clean,
}, },
) )
} }
pub fn status( pub fn status(
dmap: &DirstateMap, dmap: &DirstateMap,
root_dir: impl AsRef<Path> + Sync + Copy, root_dir: impl AsRef<Path> + Sync + Copy,
files: &[impl AsRef<HgPath> + Sync],
list_clean: bool, list_clean: bool,
last_normal_time: i64, last_normal_time: i64,
check_exec: bool, check_exec: bool,
) -> std::io::Result<(Vec<HgPathBuf>, StatusResult)> { ) -> std::io::Result<(Vec<HgPathBuf>, StatusResult)> {
let mut results = walk_explicit(files, &dmap, root_dir)?; let results = stat_dmap_entries(&dmap, root_dir)?;
results.extend(stat_dmap_entries(&dmap, &results, root_dir)?);
Ok(build_response( Ok(build_response(
&dmap, &dmap,
list_clean, list_clean,
last_normal_time, last_normal_time,
check_exec, check_exec,
results, results,
)) ))
} }

rust/hg-cpython/src/dirstate.rs

mod copymap; mod copymap;
mod dirs_multiset; mod dirs_multiset;
mod dirstate_map; mod dirstate_map;
mod status; mod status;
use crate::dirstate::{ use crate::dirstate::{
dirs_multiset::Dirs, dirstate_map::DirstateMap, status::status_wrapper, dirs_multiset::Dirs, dirstate_map::DirstateMap, status::status_wrapper,
}; };
use cpython::{ use cpython::{
exc, PyBytes, PyDict, PyErr, PyList, PyModule, PyObject, PyResult, exc, PyBytes, PyDict, PyErr, PyModule, PyObject, PyResult, PySequence,
PySequence, Python, Python,
}; };
use hg::{ use hg::{
utils::hg_path::HgPathBuf, DirstateEntry, DirstateParseError, EntryState, utils::hg_path::HgPathBuf, DirstateEntry, DirstateParseError, EntryState,
StateMap, StateMap,
}; };
use libc::{c_char, c_int}; use libc::{c_char, c_int};
use std::convert::TryFrom; use std::convert::TryFrom;
m.add( m.add(
py, py,
"status", "status",
py_fn!( py_fn!(
py, py,
status_wrapper( status_wrapper(
dmap: DirstateMap, dmap: DirstateMap,
root_dir: PyObject, root_dir: PyObject,
files: PyList,
list_clean: bool, list_clean: bool,
last_normal_time: i64, last_normal_time: i64,
check_exec: bool check_exec: bool
) )
), ),
)?; )?;
let sys = PyModule::import(py, "sys")?; let sys = PyModule::import(py, "sys")?;
let sys_modules: PyDict = sys.get(py, "modules")?.extract(py)?; let sys_modules: PyDict = sys.get(py, "modules")?.extract(py)?;
sys_modules.set_item(py, dotted_name, &m)?; sys_modules.set_item(py, dotted_name, &m)?;
Ok(m) Ok(m)
} }

rust/hg-cpython/src/dirstate/status.rs

use crate::dirstate::DirstateMap; use crate::dirstate::DirstateMap;
use cpython::exc::ValueError; use cpython::exc::ValueError;
use cpython::{ use cpython::{
PyBytes, PyErr, PyList, PyObject, PyResult, Python, PythonObject, PyBytes, PyErr, PyList, PyObject, PyResult, Python, PythonObject,
ToPyObject, ToPyObject,
}; };
use hg::utils::files::get_path_from_bytes; use hg::utils::files::get_path_from_bytes;
use hg::status;
use hg::utils::hg_path::HgPath; use hg::utils::hg_path::HgPath;
use hg::{status, utils::hg_path::HgPathBuf};
/// This will be useless once trait impls for collection are added to `PyBytes` /// This will be useless once trait impls for collection are added to `PyBytes`
/// upstream. /// upstream.
fn collect_pybytes_list<P: AsRef<HgPath>>( fn collect_pybytes_list<P: AsRef<HgPath>>(
py: Python, py: Python,
collection: &[P], collection: &[P],
) -> PyList { ) -> PyList {
let list = PyList::new(py, &[]); let list = PyList::new(py, &[]);
for (i, path) in collection.iter().enumerate() { for (i, path) in collection.iter().enumerate() {
list.insert_item( list.insert_item(
py, py,
i, i,
PyBytes::new(py, path.as_ref().as_bytes()).into_object(), PyBytes::new(py, path.as_ref().as_bytes()).into_object(),
) )
} }
list list
} }
pub fn status_wrapper( pub fn status_wrapper(
py: Python, py: Python,
dmap: DirstateMap, dmap: DirstateMap,
root_dir: PyObject, root_dir: PyObject,
files: PyList,
list_clean: bool, list_clean: bool,
last_normal_time: i64, last_normal_time: i64,
check_exec: bool, check_exec: bool,
) -> PyResult<(PyList, PyList, PyList, PyList, PyList, PyList, PyList)> { ) -> PyResult<(PyList, PyList, PyList, PyList, PyList, PyList, PyList)> {
let bytes = root_dir.extract::<PyBytes>(py)?; let bytes = root_dir.extract::<PyBytes>(py)?;
let root_dir = get_path_from_bytes(bytes.data(py)); let root_dir = get_path_from_bytes(bytes.data(py));
let dmap: DirstateMap = dmap.to_py_object(py); let dmap: DirstateMap = dmap.to_py_object(py);
let dmap = dmap.get_inner(py); let dmap = dmap.get_inner(py);
let files: PyResult<Vec<HgPathBuf>> = files let (lookup, status_res) =
.iter(py) status(&dmap, &root_dir, list_clean, last_normal_time, check_exec)
.map(|f| Ok(HgPathBuf::from_bytes(f.extract::<PyBytes>(py)?.data(py))))
.collect();
let files = files?;
let (lookup, status_res) = status(
&dmap,
&root_dir,
&files,
list_clean,
last_normal_time,
check_exec,
)
.map_err(|e| PyErr::new::<ValueError, _>(py, e.to_string()))?; .map_err(|e| PyErr::new::<ValueError, _>(py, e.to_string()))?;
let modified = collect_pybytes_list(py, status_res.modified.as_ref()); let modified = collect_pybytes_list(py, status_res.modified.as_ref());
let added = collect_pybytes_list(py, status_res.added.as_ref()); let added = collect_pybytes_list(py, status_res.added.as_ref());
let removed = collect_pybytes_list(py, status_res.removed.as_ref()); let removed = collect_pybytes_list(py, status_res.removed.as_ref());
let deleted = collect_pybytes_list(py, status_res.deleted.as_ref()); let deleted = collect_pybytes_list(py, status_res.deleted.as_ref());
let clean = collect_pybytes_list(py, status_res.clean.as_ref()); let clean = collect_pybytes_list(py, status_res.clean.as_ref());
let lookup = collect_pybytes_list(py, lookup.as_ref()); let lookup = collect_pybytes_list(py, lookup.as_ref());
let unknown = PyList::new(py, &[]); let unknown = PyList::new(py, &[]);
Ok((lookup, modified, added, removed, deleted, unknown, clean)) Ok((lookup, modified, added, removed, deleted, unknown, clean))
} }