Allow missing fields in derived FromValue::from_value calls (#13206)

# Description
In #13031 I added the derive macros for `FromValue` and `IntoValue`. In
that implementation, in particular for structs with named fields, it was
not possible to omit fields while loading them from a value, when the
field is an `Option`. This PR adds extra handling for this behavior, so
if a field is an `Option` and that field is missing in the `Value`, then
the field becomes `None`. This behavior is also tested in
`nu_protocol::value::test_derive::missing_options`.

# User-Facing Changes
When using structs for options or similar, users can now just emit
fields in the record and the derive `from_value` method will be able to
understand this, if the struct has an `Option` type for that field.

# Tests + Formatting
- :green_circle: `toolkit fmt`
- :green_circle: `toolkit clippy`
- :green_circle: `toolkit test`
- :green_circle: `toolkit test stdlib`

# After Submitting
A showcase for this feature would be great, I tried to use the current
derive macro in a plugin of mine for a config but without this addition,
they are annoying to use. So, when this is done, I would add an example
for such plugin configs that may be loaded via `FromValue`.

crates/nu-derive-value/src/from.rs

@@ -3,6 +3,7 @@ use proc_macro2::TokenStream as TokenStream2;
 use quote::{quote, ToTokens};
 use syn::{
  spanned::Spanned, Attribute, Data, DataEnum, DataStruct, DeriveInput, Fields, Generics, Ident,
+ Type,
 };
 
 use crate::attributes::{self, ContainerAttributes};
@@ -116,15 +117,11 @@ fn derive_struct_from_value(
 /// src_span: span
 /// })?,
 /// )?,
-/// favorite_toy: <Option<String> as nu_protocol::FromValue>::from_value(
-/// record
-/// .remove("favorite_toy")
-/// .ok_or_else(|| nu_protocol::ShellError::CantFindColumn {
-/// col_name: std::string::ToString::to_string("favorite_toy"),
-/// span: std::option::Option::None,
-/// src_span: span
-/// })?,
-/// )?, 
+/// favorite_toy: record
+/// .remove("favorite_toy")
+/// .map(|v| <#ty as nu_protocol::FromValue>::from_value(v))
+/// .transpose()?
+/// .flatten(), 
 /// })
 /// }
 /// }
@@ -480,20 +477,29 @@ fn parse_value_via_fields(fields: &Fields, self_ident: impl ToTokens) -> TokenSt
  match fields {
  Fields::Named(fields) => {
  let fields = fields.named.iter().map(|field| {
- // TODO: handle missing fields for Options as None
  let ident = field.ident.as_ref().expect("named has idents");
  let ident_s = ident.to_string();
  let ty = &field.ty;
- quote! {
- #ident: <#ty as nu_protocol::FromValue>::from_value(
- record
+ match type_is_option(ty) {
+ true => quote! {
+ #ident: record
  .remove(#ident_s)
- .ok_or_else(|| nu_protocol::ShellError::CantFindColumn {
- col_name: std::string::ToString::to_string(#ident_s),
- span: std::option::Option::None,
- src_span: span
- })?,
- )?
+ .map(|v| <#ty as nu_protocol::FromValue>::from_value(v))
+ .transpose()?
+ .flatten()
+ },
+
+ false => quote! {
+ #ident: <#ty as nu_protocol::FromValue>::from_value(
+ record
+ .remove(#ident_s)
+ .ok_or_else(|| nu_protocol::ShellError::CantFindColumn {
+ col_name: std::string::ToString::to_string(#ident_s),
+ span: std::option::Option::None,
+ src_span: span
+ })?,
+ )?
+ },
  }
  });
  quote! {
@@ -537,3 +543,25 @@ fn parse_value_via_fields(fields: &Fields, self_ident: impl ToTokens) -> TokenSt
  },
  }
 }
+
+const FULLY_QUALIFIED_OPTION: &str = "std::option::Option";
+const PARTIALLY_QUALIFIED_OPTION: &str = "option::Option";
+const PRELUDE_OPTION: &str = "Option";
+
+/// Check if the field type is an `Option`.
+///
+/// This function checks if a given type is an `Option`.
+/// We assume that an `Option` is [`std::option::Option`] because we can't see the whole code and
+/// can't ask the compiler itself.
+/// If the `Option` type isn't `std::option::Option`, the user will get a compile error due to a
+/// type mismatch.
+/// It's very unusual for people to override `Option`, so this should rarely be an issue.
+///
+/// When [rust#63084](https://github.com/rust-lang/rust/issues/63084) is resolved, we can use
+/// [`std::any::type_name`] for a static assertion check to get a more direct error messages.
+fn type_is_option(ty: &Type) -> bool {
+ let s = ty.to_token_stream().to_string();
+ s.starts_with(PRELUDE_OPTION)
+ || s.starts_with(PARTIALLY_QUALIFIED_OPTION)
+ || s.starts_with(FULLY_QUALIFIED_OPTION)
+}

crates/nu-protocol/src/value/test_derive.rs

@@ -171,6 +171,62 @@ fn named_fields_struct_incorrect_type() {
  assert!(res.is_err());
 }
 
+#[derive(IntoValue, FromValue, Debug, PartialEq, Default)]
+struct ALotOfOptions {
+ required: bool,
+ float: Option<f64>,
+ int: Option<i64>,
+ value: Option<Value>,
+ nested: Option<Nestee>,
+}
+
+#[test]
+fn missing_options() {
+ let value = Value::test_record(Record::new());
+ let res: Result<ALotOfOptions, _> = ALotOfOptions::from_value(value);
+ assert!(res.is_err());
+
+ let value = Value::test_record(record! {"required" => Value::test_bool(true)});
+ let expected = ALotOfOptions {
+ required: true,
+ ..Default::default()
+ };
+ let actual = ALotOfOptions::from_value(value).unwrap();
+ assert_eq!(expected, actual);
+
+ let value = Value::test_record(record! {
+ "required" => Value::test_bool(true),
+ "float" => Value::test_float(std::f64::consts::PI),
+ });
+ let expected = ALotOfOptions {
+ required: true,
+ float: Some(std::f64::consts::PI),
+ ..Default::default()
+ };
+ let actual = ALotOfOptions::from_value(value).unwrap();
+ assert_eq!(expected, actual);
+
+ let value = Value::test_record(record! {
+ "required" => Value::test_bool(true),
+ "int" => Value::test_int(12),
+ "nested" => Value::test_record(record! {
+ "u32" => Value::test_int(34),
+ }),
+ });
+ let expected = ALotOfOptions {
+ required: true,
+ int: Some(12),
+ nested: Some(Nestee {
+ u32: 34,
+ some: None,
+ none: None,
+ }),
+ ..Default::default()
+ };
+ let actual = ALotOfOptions::from_value(value).unwrap();
+ assert_eq!(expected, actual);
+}
+
 #[derive(IntoValue, FromValue, Debug, PartialEq)]
 struct UnnamedFieldsStruct<T>(u32, String, T)
 where