mirror of
https://github.com/rust-lang/rust.git
synced 2025-04-29 19:47:38 +00:00
01e33a3600
Error message all end up passing into a function as an `impl
Into<{D,Subd}iagnosticMessage>`. If an error message is creatd as
`&format("...")` that means we allocate a string (in the `format!`
call), then take a reference, and then clone (allocating again) the
reference to produce the `{D,Subd}iagnosticMessage`, which is silly.
This commit removes the leading `&` from a lot of these cases. This
means the original `String` is moved into the
`{D,Subd}iagnosticMessage`, avoiding the double allocations. This
requires changing some function argument types from `&str` to `String`
(when all arguments are `String`) or `impl
Into<{D,Subd}iagnosticMessage>` (when some arguments are `String` and
some are `&str`).
52 lines
1.5 KiB
Rust
52 lines
1.5 KiB
Rust
use std::error;
|
|
use std::fmt;
|
|
use std::fs;
|
|
use std::io;
|
|
|
|
fn arg_expand(arg: String) -> Result<Vec<String>, Error> {
|
|
if let Some(path) = arg.strip_prefix('@') {
|
|
let file = match fs::read_to_string(path) {
|
|
Ok(file) => file,
|
|
Err(ref err) if err.kind() == io::ErrorKind::InvalidData => {
|
|
return Err(Error::Utf8Error(Some(path.to_string())));
|
|
}
|
|
Err(err) => return Err(Error::IOError(path.to_string(), err)),
|
|
};
|
|
Ok(file.lines().map(ToString::to_string).collect())
|
|
} else {
|
|
Ok(vec![arg])
|
|
}
|
|
}
|
|
|
|
pub fn arg_expand_all(at_args: &[String]) -> Vec<String> {
|
|
let mut args = Vec::new();
|
|
for arg in at_args {
|
|
match arg_expand(arg.clone()) {
|
|
Ok(arg) => args.extend(arg),
|
|
Err(err) => rustc_session::early_error(
|
|
rustc_session::config::ErrorOutputType::default(),
|
|
format!("Failed to load argument file: {err}"),
|
|
),
|
|
}
|
|
}
|
|
args
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub enum Error {
|
|
Utf8Error(Option<String>),
|
|
IOError(String, io::Error),
|
|
}
|
|
|
|
impl fmt::Display for Error {
|
|
fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
match self {
|
|
Error::Utf8Error(None) => write!(fmt, "Utf8 error"),
|
|
Error::Utf8Error(Some(path)) => write!(fmt, "Utf8 error in {path}"),
|
|
Error::IOError(path, err) => write!(fmt, "IO Error: {path}: {err}"),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl error::Error for Error {}
|