This is an archive of the discontinued Mercurial Phabricator instance.

Differential D9904

rust: replace ToString impls with Display
ClosedPublic

Authored by SimonSapin on Jan 28 2021, 2:39 PM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG6c778d20c8c2: rust: replace ToString impls with Display
Summary

ToString is automatically implementing for everything that implements
Display, and Display can avoid allocating intermediate strings.

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

SimonSapin created this revision.Jan 28 2021, 2:39 PM
Alphare accepted this revision.Jan 29 2021, 8:54 AM
SimonSapin added a commit: rHG6c778d20c8c2: rust: replace ToString impls with Display.Feb 1 2021, 12:38 PM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHG6c778d20c8c2: rust: replace ToString impls with Display (authored by SimonSapin). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 25438

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

PatternError, PatternError,
}; };
use lazy_static::lazy_static; use lazy_static::lazy_static;
use micro_timer::timed; use micro_timer::timed;
use rayon::prelude::*; use rayon::prelude::*;
use std::{ use std::{
borrow::Cow, borrow::Cow,
collections::HashSet, collections::HashSet,
fmt,
fs::{read_dir, DirEntry}, fs::{read_dir, DirEntry},
io::ErrorKind, io::ErrorKind,
ops::Deref, ops::Deref,
path::{Path, PathBuf}, path::{Path, PathBuf},
}; };
/// Wrong type of file from a `BadMatch` /// Wrong type of file from a `BadMatch`
/// Note: a lot of those don't exist on all platforms. /// Note: a lot of those don't exist on all platforms.
#[derive(Debug, Copy, Clone)] #[derive(Debug, Copy, Clone)]
pub enum BadType { pub enum BadType {
CharacterDevice, CharacterDevice,
BlockDevice, BlockDevice,
FIFO, FIFO,
Socket, Socket,
Directory, Directory,
Unknown, Unknown,
} }
impl ToString for BadType { impl fmt::Display for BadType {
fn to_string(&self) -> String { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self { f.write_str(match self {
BadType::CharacterDevice => "character device", BadType::CharacterDevice => "character device",
BadType::BlockDevice => "block device", BadType::BlockDevice => "block device",
BadType::FIFO => "fifo", BadType::FIFO => "fifo",
BadType::Socket => "socket", BadType::Socket => "socket",
BadType::Directory => "directory", BadType::Directory => "directory",
BadType::Unknown => "unknown", BadType::Unknown => "unknown",
} })
.to_string()
} }
} }
/// Was explicitly matched but cannot be found/accessed /// Was explicitly matched but cannot be found/accessed
#[derive(Debug, Copy, Clone)] #[derive(Debug, Copy, Clone)]
pub enum BadMatch { pub enum BadMatch {
OsError(i32), OsError(i32),
BadType(BadType), BadType(BadType),
/// An invalid path that cannot be represented in Mercurial was found /// An invalid path that cannot be represented in Mercurial was found
Path(HgPathError), Path(HgPathError),
/// An invalid "ignore" pattern was found /// An invalid "ignore" pattern was found
Pattern(PatternError), Pattern(PatternError),
} }
pub type StatusResult<T> = Result<T, StatusError>; pub type StatusResult<T> = Result<T, StatusError>;
impl ToString for StatusError { impl fmt::Display for StatusError {
fn to_string(&self) -> String { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self { match self {
StatusError::IO(e) => e.to_string(), StatusError::IO(error) => error.fmt(f),
StatusError::Path(e) => e.to_string(), StatusError::Path(error) => error.fmt(f),
StatusError::Pattern(e) => e.to_string(), StatusError::Pattern(error) => error.fmt(f),
} }
} }
} }
/// Gives information about which files are changed in the working directory /// Gives information about which files are changed in the working directory
/// and how, compared to the revision we're based on /// and how, compared to the revision we're based on
pub struct Status<'a, M: Matcher + Sync> { pub struct Status<'a, M: Matcher + Sync> {
dmap: &'a DirstateMap, dmap: &'a DirstateMap,

rust/hg-core/src/lib.rs

pub mod utils; pub mod utils;
use crate::utils::hg_path::{HgPathBuf, HgPathError}; use crate::utils::hg_path::{HgPathBuf, HgPathError};
pub use filepatterns::{ pub use filepatterns::{
parse_pattern_syntax, read_pattern_file, IgnorePattern, parse_pattern_syntax, read_pattern_file, IgnorePattern,
PatternFileWarning, PatternSyntax, PatternFileWarning, PatternSyntax,
}; };
use std::collections::HashMap; use std::collections::HashMap;
use std::fmt;
use twox_hash::RandomXxHashBuilder64; use twox_hash::RandomXxHashBuilder64;
/// This is a contract between the `micro-timer` crate and us, to expose /// This is a contract between the `micro-timer` crate and us, to expose
/// the `log` crate as `crate::log`. /// the `log` crate as `crate::log`.
use log; use log;
pub type LineNumber = usize; pub type LineNumber = usize;
/// Rust's default hasher is too slow because it tries to prevent collision /// Rust's default hasher is too slow because it tries to prevent collision
/// attacks. We are not concerned about those: if an ill-minded person has /// attacks. We are not concerned about those: if an ill-minded person has
/// write access to your repository, you have other issues. /// write access to your repository, you have other issues.
pub type FastHashMap<K, V> = HashMap<K, V, RandomXxHashBuilder64>; pub type FastHashMap<K, V> = HashMap<K, V, RandomXxHashBuilder64>;
#[derive(Debug, PartialEq)] #[derive(Debug, PartialEq)]
pub enum DirstateMapError { pub enum DirstateMapError {
PathNotFound(HgPathBuf), PathNotFound(HgPathBuf),
EmptyPath, EmptyPath,
InvalidPath(HgPathError), InvalidPath(HgPathError),
} }
impl ToString for DirstateMapError { impl fmt::Display for DirstateMapError {
fn to_string(&self) -> String { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self { match self {
DirstateMapError::PathNotFound(_) => { DirstateMapError::PathNotFound(_) => {
"expected a value, found none".to_string() f.write_str("expected a value, found none")
} }
DirstateMapError::EmptyPath => "Overflow in dirstate.".to_string(), DirstateMapError::EmptyPath => {
DirstateMapError::InvalidPath(e) => e.to_string(), f.write_str("Overflow in dirstate.")
}
DirstateMapError::InvalidPath(path_error) => path_error.fmt(f),
} }
} }
} }
#[derive(Debug, derive_more::From)] #[derive(Debug, derive_more::From)]
pub enum DirstateError { pub enum DirstateError {
Map(DirstateMapError), Map(DirstateMapError),
Common(errors::HgError), Common(errors::HgError),
} }
#[derive(Debug, derive_more::From)] #[derive(Debug, derive_more::From)]
pub enum PatternError { pub enum PatternError {
#[from] #[from]
Path(HgPathError), Path(HgPathError),
UnsupportedSyntax(String), UnsupportedSyntax(String),
UnsupportedSyntaxInFile(String, String, usize), UnsupportedSyntaxInFile(String, String, usize),
TooLong(usize), TooLong(usize),
#[from] #[from]
IO(std::io::Error), IO(std::io::Error),
/// Needed a pattern that can be turned into a regex but got one that /// Needed a pattern that can be turned into a regex but got one that
/// can't. This should only happen through programmer error. /// can't. This should only happen through programmer error.
NonRegexPattern(IgnorePattern), NonRegexPattern(IgnorePattern),
} }
impl ToString for PatternError { impl fmt::Display for PatternError {
fn to_string(&self) -> String { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self { match self {
PatternError::UnsupportedSyntax(syntax) => { PatternError::UnsupportedSyntax(syntax) => {
format!("Unsupported syntax {}", syntax) write!(f, "Unsupported syntax {}", syntax)
} }
PatternError::UnsupportedSyntaxInFile(syntax, file_path, line) => { PatternError::UnsupportedSyntaxInFile(syntax, file_path, line) => {
format!( write!(
f,
"{}:{}: unsupported syntax {}", "{}:{}: unsupported syntax {}",
file_path, line, syntax file_path, line, syntax
) )
} }
PatternError::TooLong(size) => { PatternError::TooLong(size) => {
format!("matcher pattern is too long ({} bytes)", size) write!(f, "matcher pattern is too long ({} bytes)", size)
} }
PatternError::IO(e) => e.to_string(), PatternError::IO(error) => error.fmt(f),
PatternError::Path(e) => e.to_string(), PatternError::Path(error) => error.fmt(f),
PatternError::NonRegexPattern(pattern) => { PatternError::NonRegexPattern(pattern) => {
format!("'{:?}' cannot be turned into a regex", pattern) write!(f, "'{:?}' cannot be turned into a regex", pattern)
} }
} }
} }
} }

rust/hg-core/src/utils/hg_path.rs

NotFsCompliant(HgPathBuf), NotFsCompliant(HgPathBuf),
/// `path` is the smallest invalid path /// `path` is the smallest invalid path
NotUnderRoot { NotUnderRoot {
path: PathBuf, path: PathBuf,
root: PathBuf, root: PathBuf,
}, },
} }
impl ToString for HgPathError { impl fmt::Display for HgPathError {
fn to_string(&self) -> String { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self { match self {
HgPathError::LeadingSlash(bytes) => { HgPathError::LeadingSlash(bytes) => {
format!("Invalid HgPath '{:?}': has a leading slash.", bytes) write!(f, "Invalid HgPath '{:?}': has a leading slash.", bytes)
} }
HgPathError::ConsecutiveSlashes { HgPathError::ConsecutiveSlashes {
bytes, bytes,
second_slash_index: pos, second_slash_index: pos,
} => format!( } => write!(
f,
"Invalid HgPath '{:?}': consecutive slashes at pos {}.", "Invalid HgPath '{:?}': consecutive slashes at pos {}.",
bytes, pos bytes, pos
), ),
HgPathError::ContainsNullByte { HgPathError::ContainsNullByte {
bytes, bytes,
null_byte_index: pos, null_byte_index: pos,
} => format!( } => write!(
f,
"Invalid HgPath '{:?}': contains null byte at pos {}.", "Invalid HgPath '{:?}': contains null byte at pos {}.",
bytes, pos bytes, pos
), ),
HgPathError::DecodeError(bytes) => { HgPathError::DecodeError(bytes) => write!(
format!("Invalid HgPath '{:?}': could not be decoded.", bytes) f,
} "Invalid HgPath '{:?}': could not be decoded.",
bytes
),
HgPathError::EndsWithSlash(path) => { HgPathError::EndsWithSlash(path) => {
format!("Audit failed for '{}': ends with a slash.", path) write!(f, "Audit failed for '{}': ends with a slash.", path)
} }
HgPathError::ContainsIllegalComponent(path) => format!( HgPathError::ContainsIllegalComponent(path) => write!(
f,
"Audit failed for '{}': contains an illegal component.", "Audit failed for '{}': contains an illegal component.",
path path
), ),
HgPathError::InsideDotHg(path) => format!( HgPathError::InsideDotHg(path) => write!(
f,
"Audit failed for '{}': is inside the '.hg' folder.", "Audit failed for '{}': is inside the '.hg' folder.",
path path
), ),
HgPathError::IsInsideNestedRepo { HgPathError::IsInsideNestedRepo {
path, path,
nested_repo: nested, nested_repo: nested,
} => format!( } => {
write!(f,
"Audit failed for '{}': is inside a nested repository '{}'.", "Audit failed for '{}': is inside a nested repository '{}'.",
path, nested path, nested
), )
HgPathError::TraversesSymbolicLink { path, symlink } => format!( }
HgPathError::TraversesSymbolicLink { path, symlink } => write!(
f,
"Audit failed for '{}': traverses symbolic link '{}'.", "Audit failed for '{}': traverses symbolic link '{}'.",
path, symlink path, symlink
), ),
HgPathError::NotFsCompliant(path) => format!( HgPathError::NotFsCompliant(path) => write!(
f,
"Audit failed for '{}': cannot be turned into a \ "Audit failed for '{}': cannot be turned into a \
filesystem path.", filesystem path.",
path path
), ),
HgPathError::NotUnderRoot { path, root } => format!( HgPathError::NotUnderRoot { path, root } => write!(
f,
"Audit failed for '{}': not under root {}.", "Audit failed for '{}': not under root {}.",
path.display(), path.display(),
root.display() root.display()
), ),
} }
} }
} }