dd7b7311b3
# Description * I was dismayed to discover recently that UnsupportedInput and TypeMismatch are used *extremely* inconsistently across the codebase. UnsupportedInput is sometimes used for input type-checks (as per the name!!), but *also* used for argument type-checks. TypeMismatch is also used for both. I thus devised the following standard: input type-checking *only* uses UnsupportedInput, and argument type-checking *only* uses TypeMismatch. Moreover, to differentiate them, UnsupportedInput now has *two* error arrows (spans), one pointing at the command and the other at the input origin, while TypeMismatch only has the one (because the command should always be nearby) * In order to apply that standard, a very large number of UnsupportedInput uses were changed so that the input's span could be retrieved and delivered to it. * Additionally, I noticed many places where **errors are not propagated correctly**: there are lots of `match` sites which take a Value::Error, then throw it away and replace it with a new Value::Error with less/misleading information (such as reporting the error as an "incorrect type"). I believe that the earliest errors are the most important, and should always be propagated where possible. * Also, to standardise one broad subset of UnsupportedInput error messages, who all used slightly different wordings of "expected `<type>`, got `<type>`", I created OnlySupportsThisInputType as a variant of it. * Finally, a bunch of error sites that had "repeated spans" - i.e. where an error expected two spans, but `call.head` was given for both - were fixed to use different spans. # Example BEFORE ``` 〉20b | str starts-with 'a' Error: nu:🐚:unsupported_input (link) × Unsupported input ╭─[entry #31:1:1] 1 │ 20b | str starts-with 'a' · ┬ · ╰── Input's type is filesize. This command only works with strings. ╰──── 〉'a' | math cos Error: nu:🐚:unsupported_input (link) × Unsupported input ╭─[entry #33:1:1] 1 │ 'a' | math cos · ─┬─ · ╰── Only numerical values are supported, input type: String ╰──── 〉0x[12] | encode utf8 Error: nu:🐚:unsupported_input (link) × Unsupported input ╭─[entry #38:1:1] 1 │ 0x[12] | encode utf8 · ───┬── · ╰── non-string input ╰──── ``` AFTER ``` 〉20b | str starts-with 'a' Error: nu:🐚:pipeline_mismatch (link) × Pipeline mismatch. ╭─[entry #1:1:1] 1 │ 20b | str starts-with 'a' · ┬ ───────┬─────── · │ ╰── only string input data is supported · ╰── input type: filesize ╰──── 〉'a' | math cos Error: nu:🐚:pipeline_mismatch (link) × Pipeline mismatch. ╭─[entry #2:1:1] 1 │ 'a' | math cos · ─┬─ ────┬─── · │ ╰── only numeric input data is supported · ╰── input type: string ╰──── 〉0x[12] | encode utf8 Error: nu:🐚:pipeline_mismatch (link) × Pipeline mismatch. ╭─[entry #3:1:1] 1 │ 0x[12] | encode utf8 · ───┬── ───┬── · │ ╰── only string input data is supported · ╰── input type: binary ╰──── ``` # User-Facing Changes Various error messages suddenly make more sense (i.e. have two arrows instead of one). # Tests + Formatting Don't forget to add tests that cover your changes. Make sure you've run and fixed any issues with these commands: - `cargo fmt --all -- --check` to check standard code formatting (`cargo fmt --all` applies these changes) - `cargo clippy --workspace -- -D warnings -D clippy::unwrap_used -A clippy::needless_collect` to check that you're using the standard code style - `cargo test --workspace` to check that all tests pass # After Submitting If your PR had any user-facing changes, update [the documentation](https://github.com/nushell/nushell.github.io) after the PR is merged, if necessary. This will help us keep the docs up to date.
316 lines
10 KiB
Rust
316 lines
10 KiB
Rust
use chrono::{DateTime, FixedOffset};
|
|
use nu_protocol::{ShellError, Span, Value};
|
|
use std::hash::{Hash, Hasher};
|
|
|
|
/// A subset of [Value](crate::Value), which is hashable.
|
|
/// And it means that we can put the value into something like [HashMap](std::collections::HashMap) or [HashSet](std::collections::HashSet)
|
|
/// for further usage like value statistics.
|
|
///
|
|
/// For now the main way to crate a [HashableValue] is using [from_value](HashableValue::from_value)
|
|
///
|
|
/// Please note that although each variant contains `span` field, but during hashing, this field will not be concerned.
|
|
/// Which means that the following will be true:
|
|
/// ```text
|
|
/// assert_eq!(HashableValue::Bool {val: true, span: Span{start: 0, end: 1}}, HashableValue::Bool {val: true, span: Span{start: 90, end: 1000}})
|
|
/// ```
|
|
#[derive(Eq, Debug, Ord, PartialOrd)]
|
|
pub enum HashableValue {
|
|
Bool {
|
|
val: bool,
|
|
span: Span,
|
|
},
|
|
Int {
|
|
val: i64,
|
|
span: Span,
|
|
},
|
|
Float {
|
|
val: [u8; 8], // because f64 is not hashable, we save it as [u8;8] array to make it hashable.
|
|
span: Span,
|
|
},
|
|
Filesize {
|
|
val: i64,
|
|
span: Span,
|
|
},
|
|
Duration {
|
|
val: i64,
|
|
span: Span,
|
|
},
|
|
Date {
|
|
val: DateTime<FixedOffset>,
|
|
span: Span,
|
|
},
|
|
String {
|
|
val: String,
|
|
span: Span,
|
|
},
|
|
Binary {
|
|
val: Vec<u8>,
|
|
span: Span,
|
|
},
|
|
}
|
|
|
|
impl Default for HashableValue {
|
|
fn default() -> Self {
|
|
HashableValue::Bool {
|
|
val: false,
|
|
span: Span::unknown(),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl HashableValue {
|
|
/// Try to convert from `value` to self
|
|
///
|
|
/// A `span` is required because when there is an error in value, it may not contain `span` field.
|
|
///
|
|
/// If the given value is not hashable(mainly because of it is structured data), an error will returned.
|
|
pub fn from_value(value: Value, span: Span) -> Result<Self, ShellError> {
|
|
match value {
|
|
Value::Bool { val, span } => Ok(HashableValue::Bool { val, span }),
|
|
Value::Int { val, span } => Ok(HashableValue::Int { val, span }),
|
|
Value::Filesize { val, span } => Ok(HashableValue::Filesize { val, span }),
|
|
Value::Duration { val, span } => Ok(HashableValue::Duration { val, span }),
|
|
Value::Date { val, span } => Ok(HashableValue::Date { val, span }),
|
|
Value::Float { val, span } => Ok(HashableValue::Float {
|
|
val: val.to_ne_bytes(),
|
|
span,
|
|
}),
|
|
Value::String { val, span } => Ok(HashableValue::String { val, span }),
|
|
Value::Binary { val, span } => Ok(HashableValue::Binary { val, span }),
|
|
|
|
// Explictly propagate errors instead of dropping them.
|
|
Value::Error { error } => Err(error),
|
|
_ => Err(ShellError::UnsupportedInput(
|
|
"input value is not hashable".into(),
|
|
format!("input type: {:?}", value.get_type()),
|
|
span,
|
|
value.expect_span(),
|
|
)),
|
|
}
|
|
}
|
|
|
|
/// Convert from self to nu's core data type `Value`.
|
|
pub fn into_value(self) -> Value {
|
|
match self {
|
|
HashableValue::Bool { val, span } => Value::Bool { val, span },
|
|
HashableValue::Int { val, span } => Value::Int { val, span },
|
|
HashableValue::Filesize { val, span } => Value::Filesize { val, span },
|
|
HashableValue::Duration { val, span } => Value::Duration { val, span },
|
|
HashableValue::Date { val, span } => Value::Date { val, span },
|
|
HashableValue::Float { val, span } => Value::Float {
|
|
val: f64::from_ne_bytes(val),
|
|
span,
|
|
},
|
|
HashableValue::String { val, span } => Value::String { val, span },
|
|
HashableValue::Binary { val, span } => Value::Binary { val, span },
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Hash for HashableValue {
|
|
fn hash<H: Hasher>(&self, state: &mut H) {
|
|
match self {
|
|
HashableValue::Bool { val, .. } => val.hash(state),
|
|
HashableValue::Int { val, .. } => val.hash(state),
|
|
HashableValue::Filesize { val, .. } => val.hash(state),
|
|
HashableValue::Duration { val, .. } => val.hash(state),
|
|
HashableValue::Date { val, .. } => val.hash(state),
|
|
HashableValue::Float { val, .. } => val.hash(state),
|
|
HashableValue::String { val, .. } => val.hash(state),
|
|
HashableValue::Binary { val, .. } => val.hash(state),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl PartialEq for HashableValue {
|
|
fn eq(&self, other: &Self) -> bool {
|
|
match (self, other) {
|
|
(HashableValue::Bool { val: lhs, .. }, HashableValue::Bool { val: rhs, .. }) => {
|
|
lhs == rhs
|
|
}
|
|
(HashableValue::Int { val: lhs, .. }, HashableValue::Int { val: rhs, .. }) => {
|
|
lhs == rhs
|
|
}
|
|
(
|
|
HashableValue::Filesize { val: lhs, .. },
|
|
HashableValue::Filesize { val: rhs, .. },
|
|
) => lhs == rhs,
|
|
(
|
|
HashableValue::Duration { val: lhs, .. },
|
|
HashableValue::Duration { val: rhs, .. },
|
|
) => lhs == rhs,
|
|
(HashableValue::Date { val: lhs, .. }, HashableValue::Date { val: rhs, .. }) => {
|
|
lhs == rhs
|
|
}
|
|
(HashableValue::Float { val: lhs, .. }, HashableValue::Float { val: rhs, .. }) => {
|
|
lhs == rhs
|
|
}
|
|
(HashableValue::String { val: lhs, .. }, HashableValue::String { val: rhs, .. }) => {
|
|
lhs == rhs
|
|
}
|
|
(HashableValue::Binary { val: lhs, .. }, HashableValue::Binary { val: rhs, .. }) => {
|
|
lhs == rhs
|
|
}
|
|
_ => false,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod test {
|
|
use super::*;
|
|
use nu_protocol::ast::{CellPath, PathMember};
|
|
use std::collections::{HashMap, HashSet};
|
|
|
|
#[test]
|
|
fn from_value() {
|
|
let span = Span::test_data();
|
|
let values = vec![
|
|
(
|
|
Value::Bool { val: true, span },
|
|
HashableValue::Bool { val: true, span },
|
|
),
|
|
(
|
|
Value::Int { val: 1, span },
|
|
HashableValue::Int { val: 1, span },
|
|
),
|
|
(
|
|
Value::Filesize { val: 1, span },
|
|
HashableValue::Filesize { val: 1, span },
|
|
),
|
|
(
|
|
Value::Duration { val: 1, span },
|
|
HashableValue::Duration { val: 1, span },
|
|
),
|
|
(
|
|
Value::Date {
|
|
val: DateTime::<FixedOffset>::parse_from_rfc2822(
|
|
"Wed, 18 Feb 2015 23:16:09 GMT",
|
|
)
|
|
.unwrap(),
|
|
span,
|
|
},
|
|
HashableValue::Date {
|
|
val: DateTime::<FixedOffset>::parse_from_rfc2822(
|
|
"Wed, 18 Feb 2015 23:16:09 GMT",
|
|
)
|
|
.unwrap(),
|
|
span,
|
|
},
|
|
),
|
|
(
|
|
Value::String {
|
|
val: "1".to_string(),
|
|
span,
|
|
},
|
|
HashableValue::String {
|
|
val: "1".to_string(),
|
|
span,
|
|
},
|
|
),
|
|
(
|
|
Value::Binary { val: vec![1], span },
|
|
HashableValue::Binary { val: vec![1], span },
|
|
),
|
|
];
|
|
for (val, expect_hashable_val) in values.into_iter() {
|
|
assert_eq!(
|
|
HashableValue::from_value(val, Span::unknown()).unwrap(),
|
|
expect_hashable_val
|
|
);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn from_unhashable_value() {
|
|
let span = Span::test_data();
|
|
let values = [
|
|
Value::List {
|
|
vals: vec![Value::Bool { val: true, span }],
|
|
span,
|
|
},
|
|
Value::Closure {
|
|
val: 0,
|
|
captures: HashMap::new(),
|
|
span,
|
|
},
|
|
Value::Nothing { span },
|
|
Value::Error {
|
|
error: ShellError::DidYouMean("what?".to_string(), span),
|
|
},
|
|
Value::CellPath {
|
|
val: CellPath {
|
|
members: vec![PathMember::Int { val: 0, span }],
|
|
},
|
|
span,
|
|
},
|
|
];
|
|
for v in values {
|
|
assert!(HashableValue::from_value(v, Span::unknown()).is_err())
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn from_to_tobe_same() {
|
|
let span = Span::test_data();
|
|
let values = vec![
|
|
Value::Bool { val: true, span },
|
|
Value::Int { val: 1, span },
|
|
Value::Filesize { val: 1, span },
|
|
Value::Duration { val: 1, span },
|
|
Value::String {
|
|
val: "1".to_string(),
|
|
span,
|
|
},
|
|
Value::Binary { val: vec![1], span },
|
|
];
|
|
for val in values.into_iter() {
|
|
let expected_val = val.clone();
|
|
assert_eq!(
|
|
HashableValue::from_value(val, Span::unknown())
|
|
.unwrap()
|
|
.into_value(),
|
|
expected_val
|
|
);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn hashable_value_eq_without_concern_span() {
|
|
assert_eq!(
|
|
HashableValue::Bool {
|
|
val: true,
|
|
span: Span::new(0, 1)
|
|
},
|
|
HashableValue::Bool {
|
|
val: true,
|
|
span: Span::new(90, 1000)
|
|
}
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn put_to_hashset() {
|
|
let span = Span::test_data();
|
|
let mut set = HashSet::new();
|
|
set.insert(HashableValue::Bool { val: true, span });
|
|
assert!(set.contains(&HashableValue::Bool { val: true, span }));
|
|
|
|
// hashable value doesn't care about span.
|
|
let diff_span = Span::new(1, 2);
|
|
set.insert(HashableValue::Bool {
|
|
val: true,
|
|
span: diff_span,
|
|
});
|
|
assert!(set.contains(&HashableValue::Bool { val: true, span }));
|
|
assert!(set.contains(&HashableValue::Bool {
|
|
val: true,
|
|
span: diff_span
|
|
}));
|
|
assert_eq!(set.len(), 1);
|
|
|
|
set.insert(HashableValue::Int { val: 2, span });
|
|
assert_eq!(set.len(), 2);
|
|
}
|
|
}
|