This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10238

rhg: Add more conversions between error types
ClosedPublic

Authored by SimonSapin on Mar 19 2021, 8:28 AM.

Details

Reviewers
pulkit
Group Reviewers
hg-reviewers
Commits
rHGbcdcb4423ae3: rhg: Add more conversions between error types
Summary

This allows using the ? operator in more places, as the next commit does.

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.Mar 19 2021, 8:28 AM
pulkit accepted this revision.Mar 22 2021, 5:33 AM
pulkit added a subscriber: pulkit.

Thanks, this will definitely help with my detailed_exit_code work.

This revision is now accepted and ready to land.Mar 22 2021, 5:33 AM
SimonSapin added a commit: rHGbcdcb4423ae3: rhg: Add more conversions between error types.Mar 22 2021, 5:51 AM
Closed by commit rHGbcdcb4423ae3: rhg: Add more conversions between error types (authored by SimonSapin). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 26528

rust/hg-core/src/config/config.rs

use crate::config::layer::{ use crate::config::layer::{
ConfigError, ConfigLayer, ConfigOrigin, ConfigValue, ConfigError, ConfigLayer, ConfigOrigin, ConfigValue,
}; };
use crate::utils::files::get_bytes_from_os_str; use crate::utils::files::get_bytes_from_os_str;
use crate::utils::SliceExt; use crate::utils::SliceExt;
use format_bytes::{write_bytes, DisplayBytes}; use format_bytes::{write_bytes, DisplayBytes};
use std::collections::HashSet; use std::collections::HashSet;
use std::env; use std::env;
use std::fmt;
use std::path::{Path, PathBuf}; use std::path::{Path, PathBuf};
use std::str; use std::str;
use crate::errors::{HgResultExt, IoResultExt}; use crate::errors::{HgResultExt, IoResultExt};
/// Holds the config values for the current repository /// Holds the config values for the current repository
/// TODO update this docstring once we support more sources /// TODO update this docstring once we support more sources
#[derive(Clone)] #[derive(Clone)]
pub origin: ConfigOrigin, pub origin: ConfigOrigin,
pub line: Option<usize>, pub line: Option<usize>,
pub section: Vec<u8>, pub section: Vec<u8>,
pub item: Vec<u8>, pub item: Vec<u8>,
pub value: Vec<u8>, pub value: Vec<u8>,
pub expected_type: &'static str, pub expected_type: &'static str,
} }
impl fmt::Display for ConfigValueParseError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
// TODO: add origin and line number information, here and in
// corresponding python code
write!(
f,
"config error: {}.{} is not a {} ('{}')",
String::from_utf8_lossy(&self.section),
String::from_utf8_lossy(&self.item),
self.expected_type,
String::from_utf8_lossy(&self.value)
)
}
}
impl Config { impl Config {
/// Load system and user configuration from various files. /// Load system and user configuration from various files.
/// ///
/// This is also affected by some environment variables. /// This is also affected by some environment variables.
pub fn load( pub fn load(
cli_config_args: impl IntoIterator<Item = impl AsRef<[u8]>>, cli_config_args: impl IntoIterator<Item = impl AsRef<[u8]>>,
) -> Result<Self, ConfigError> { ) -> Result<Self, ConfigError> {
let mut config = Self { layers: Vec::new() }; let mut config = Self { layers: Vec::new() };

rust/hg-core/src/errors.rs

write!(f, "abort: {}: {}", context, error) write!(f, "abort: {}: {}", context, error)
} }
HgError::CorruptedRepository(explanation) => { HgError::CorruptedRepository(explanation) => {
write!(f, "abort: {}", explanation) write!(f, "abort: {}", explanation)
} }
HgError::UnsupportedFeature(explanation) => { HgError::UnsupportedFeature(explanation) => {
write!(f, "unsupported feature: {}", explanation) write!(f, "unsupported feature: {}", explanation)
} }
HgError::ConfigValueParseError(ConfigValueParseError { HgError::ConfigValueParseError(error) => error.fmt(f),
origin: _,
line: _,
section,
item,
value,
expected_type,
}) => {
// TODO: add origin and line number information, here and in
// corresponding python code
write!(
f,
"config error: {}.{} is not a {} ('{}')",
String::from_utf8_lossy(section),
String::from_utf8_lossy(item),
expected_type,
String::from_utf8_lossy(value)
)
}
} }
} }
} }
// TODO: use `DisplayBytes` instead to show non-Unicode filenames losslessly? // TODO: use `DisplayBytes` instead to show non-Unicode filenames losslessly?
impl fmt::Display for IoErrorContext { impl fmt::Display for IoErrorContext {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self { match self {

rust/hg-core/src/lib.rs

pub mod discovery; pub mod discovery;
pub mod requirements; pub mod requirements;
pub mod testing; // unconditionally built, for use from integration tests pub mod testing; // unconditionally built, for use from integration tests
pub use dirstate::{ pub use dirstate::{
dirs_multiset::{DirsMultiset, DirsMultisetIter}, dirs_multiset::{DirsMultiset, DirsMultisetIter},
dirstate_map::DirstateMap, dirstate_map::DirstateMap,
parsers::{pack_dirstate, parse_dirstate, PARENT_SIZE}, parsers::{pack_dirstate, parse_dirstate, PARENT_SIZE},
status::{ status::{
status, BadMatch, BadType, DirstateStatus, StatusError, StatusOptions, status, BadMatch, BadType, DirstateStatus, HgPathCow, StatusError,
StatusOptions,
}, },
CopyMap, CopyMapIter, DirstateEntry, DirstateParents, EntryState, CopyMap, CopyMapIter, DirstateEntry, DirstateParents, EntryState,
StateMap, StateMapIter, StateMap, StateMapIter,
}; };
pub mod copy_tracing; pub mod copy_tracing;
mod filepatterns; mod filepatterns;
pub mod matchers; pub mod matchers;
pub mod repo; pub mod repo;

rust/rhg/src/error.rs

use crate::ui::utf8_to_local; use crate::ui::utf8_to_local;
use crate::ui::UiError; use crate::ui::UiError;
use crate::NoRepoInCwdError; use crate::NoRepoInCwdError;
use format_bytes::format_bytes; use format_bytes::format_bytes;
use hg::config::{ConfigError, ConfigParseError}; use hg::config::{ConfigError, ConfigParseError, ConfigValueParseError};
use hg::errors::HgError; use hg::errors::HgError;
use hg::repo::RepoError; use hg::repo::RepoError;
use hg::revlog::revlog::RevlogError; use hg::revlog::revlog::RevlogError;
use hg::utils::files::get_bytes_from_path; use hg::utils::files::get_bytes_from_path;
use hg::{DirstateError, DirstateMapError, StatusError};
use std::convert::From; use std::convert::From;
/// The kind of command error /// The kind of command error
#[derive(Debug)] #[derive(Debug)]
pub enum CommandError { pub enum CommandError {
/// Exit with an error message and "standard" failure exit code. /// Exit with an error message and "standard" failure exit code.
Abort { message: Vec<u8> }, Abort { message: Vec<u8> },
HgError::UnsupportedFeature(message) => { HgError::UnsupportedFeature(message) => {
CommandError::unsupported(message) CommandError::unsupported(message)
} }
_ => CommandError::abort(error.to_string()), _ => CommandError::abort(error.to_string()),
} }
} }
} }
impl From<ConfigValueParseError> for CommandError {
fn from(error: ConfigValueParseError) -> Self {
CommandError::abort(error.to_string())
}
}
impl From<UiError> for CommandError { impl From<UiError> for CommandError {
fn from(_error: UiError) -> Self { fn from(_error: UiError) -> Self {
// If we already failed writing to stdout or stderr, // If we already failed writing to stdout or stderr,
// writing an error message to stderr about it would be likely to fail // writing an error message to stderr about it would be likely to fail
// too. // too.
CommandError::abort("") CommandError::abort("")
} }
} }
RevlogError::AmbiguousPrefix => CommandError::abort(format!( RevlogError::AmbiguousPrefix => CommandError::abort(format!(
"abort: ambiguous revision identifier: {}", "abort: ambiguous revision identifier: {}",
rev rev
)), )),
RevlogError::Other(error) => error.into(), RevlogError::Other(error) => error.into(),
} }
} }
} }
impl From<StatusError> for CommandError {
fn from(error: StatusError) -> Self {
CommandError::abort(format!("{}", error))
}
}
impl From<DirstateMapError> for CommandError {
fn from(error: DirstateMapError) -> Self {
CommandError::abort(format!("{}", error))
}
}
impl From<DirstateError> for CommandError {
fn from(error: DirstateError) -> Self {
match error {
DirstateError::Common(error) => error.into(),
DirstateError::Map(error) => error.into(),
}
}
}