Merge remote-tracking branch 'JelteF/master' into hash-derive

Author: fredszaq

CHANGELOG.md

@@ -5,13 +5,18 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/)
 and this project adheres to [Semantic Versioning](http://semver.org/).
 
-## Unreleased
+## master
 
 ### Added
- - Add `Hash` derive similar to `std`'s one, but considering generics correctly,
-   and supporting custom hash functions per field or skipping fields.
-   ([#532](https://github.com/JelteF/derive_more/pull/532))
+- Add `Hash` derive similar to `std`'s one, but considering generics correctly,
+  and supporting custom hash functions per field or skipping fields.
+  ([#532](https://github.com/JelteF/derive_more/pull/532))
 
+### Fixed
+
+- Mistakenly generated code for `owned` type in `TryInto`, `Unwrap` and `TryUnwrap`
+  derives when it shouldn't be there (`ref`/`ref_mut` specified without `owned`).
+  ([#531](https://github.com/JelteF/derive_more/pull/531))
 
 ## 2.1.1 - 2025-12-22
 

impl/Cargo.toml

@@ -27,7 +27,7 @@ proc-macro2 = "1.0"
 quote = "1.0"
 syn = "2.0.45"
 convert_case = { version = "0.10", optional = true }
-unicode-xid = { version = "0.2.2", optional = true }
+unicode-ident = { version = "1.0", optional = true }
 
 [build-dependencies]
 rustc_version = "0.4"
@@ -53,10 +53,10 @@ add = ["syn/extra-traits", "syn/visit"]
 add_assign = ["syn/extra-traits", "syn/visit"]
 as_ref = ["syn/extra-traits", "syn/visit"]
 constructor = []
-debug = ["syn/extra-traits", "dep:unicode-xid"]
+debug = ["syn/extra-traits", "dep:unicode-ident"]
 deref = []
 deref_mut = []
-display = ["syn/extra-traits", "dep:unicode-xid", "dep:convert_case"]
+display = ["syn/extra-traits", "dep:unicode-ident", "dep:convert_case"]
 eq = ["syn/extra-traits", "syn/visit"]
 error = ["syn/extra-traits"]
 from = ["syn/extra-traits"]

impl/doc/try_into.md

@@ -38,10 +38,10 @@ let mut mixed_int3 = mixed_int1.clone();
 
 assert_eq!(123u32, mixed_int1.try_into().unwrap());
 
-let int_ref : &u32 = (&mixed_int2).try_into().unwrap();
+let int_ref: &u32 = (&mixed_int2).try_into().unwrap();
 assert_eq!(&123u32, int_ref);
 
-let int_ref_mut : &mut u32 = (&mut mixed_int3).try_into().unwrap();
+let int_ref_mut: &mut u32 = (&mut mixed_int3).try_into().unwrap();
 assert_eq!(&mut 123u32, int_ref_mut);
 
 assert_eq!("foo".to_string(), String::try_from(mixed_string.clone()).unwrap());

impl/doc/try_unwrap.md

@@ -2,18 +2,22 @@
 
 This works almost like `Unwrap`.
 When an enum is decorated with `#[derive(TryUnwrap)]`, for each variant `foo` in the enum, with fields `(a, b, c, ...)` a public instance method `try_unwrap_foo(self) -> Result<(a, b, c, ...), TryUnwrapError<Self>>` is generated.
+
 If you don't want the `try_unwrap_foo` method generated for a variant, you can put the `#[try_unwrap(ignore)]` attribute on that variant.
-If you want to treat a reference, you can put the `#[try_unwrap(ref)]` attribute on the enum declaration or that variant, then `try_unwrap_foo_ref(self) -> Result<(&a, &b, &c, ...), TryUnwrapError<&Self>>` will be generated. You can also use mutable references by putting `#[unwrap(ref_mut)]`.
+
+By using `#[try_unwrap(owned, ref, ref_mut)]` it's possible to generate methods implementation for reference types as well (like `try_unwrap_foo_ref(&self) -> Result<(&a, &b, &c, ...), TryUnwrapError<&Self>>`).
+You can pick any combination of `owned`, `ref` and `ref_mut`. If that's not provided the default is `#[try_unwrap(owned)]`.
+
 However, unlike `Unwrap`, it does not panic if the conversion fails. Also, values that fail to convert are not dropped but returned as an `Err`.
 
 ## Example usage
 
 ```rust
 # use derive_more::TryUnwrap;
-# 
+#
 # #[derive(Debug, PartialEq)]
 #[derive(TryUnwrap)]
-#[try_unwrap(ref)]
+#[try_unwrap(owned, ref, ref_mut)]
 enum Maybe<T> {
     Nothing,
     Just(T),
@@ -37,6 +41,7 @@ fn main() {
     );
 
     assert_eq!((&Maybe::Just(42)).try_unwrap_just_ref(), Ok(&42));
+    assert_eq!((&mut Maybe::Just(42)).try_unwrap_just_mut(), Ok(&mut 42));
 }
 ```
 
@@ -64,6 +69,12 @@ impl<T> Maybe<T> {
             val @ _ => Err(todo!("TryUnwrapError::new(val, /* omitted */)")),
         }
     }
+    pub fn try_unwrap_nothing_mut(&mut self) -> Result<(), TryUnwrapError<&mut Self>> {
+        match self {
+            Maybe::Nothing => Ok(()),
+            val @ _ => Err(todo!("TryUnwrapError::new(val, /* omitted */)")),
+        }
+    }
     pub fn try_unwrap_just(self) -> Result<T, TryUnwrapError<Self>> {
         match self {
             Maybe::Just(field_0) => Ok(field_0),
@@ -76,5 +87,11 @@ impl<T> Maybe<T> {
             val @ _ => Err(todo!("TryUnwrapError::new(val, /* omitted */)")),
         }
     }
+    pub fn try_unwrap_just_mut(&mut self) -> Result<&mut T, TryUnwrapError<&mut Self>> {
+        match self {
+            Maybe::Just(field_0) => Ok(field_0),
+            val @ _ => Err(todo!("TryUnwrapError::new(val, /* omitted */)")),
+        }
+    }
 }
 ```

impl/doc/unwrap.md

@@ -1,8 +1,11 @@
 # What `#[derive(Unwrap)]` generates
 
 When an enum is decorated with `#[derive(Unwrap)]`, for each variant `foo` in the enum, with fields `(a, b, c, ...)` a public instance method `unwrap_foo(self) -> (a, b, c, ...)` is generated.
+
 If you don't want the `unwrap_foo` method generated for a variant, you can put the `#[unwrap(ignore)]` attribute on that variant.
-If you want to treat a reference, you can put the `#[unwrap(ref)]` attribute on the enum declaration or that variant, then `unwrap_foo_ref(self) -> (&a, &b, &c, ...)` will be generated. You can also use mutable references by putting `#[unwrap(ref_mut)]`.
+
+By using `#[unwrap(owned, ref, ref_mut)]` it's possible to generate methods implementation for reference types as well (like `unwrap_foo_ref(&self) -> (&a, &b, &c, ...)`).
+You can pick any combination of `owned`, `ref` and `ref_mut`. If that's not provided the default is `#[unwrap(owned)]`.
 
 
 
@@ -11,10 +14,10 @@ If you want to treat a reference, you can put the `#[unwrap(ref)]` attribute on
 
 ```rust
 # use derive_more::Unwrap;
-# 
+#
 # #[derive(Debug, PartialEq)]
 #[derive(Unwrap)]
-#[unwrap(ref)]
+#[unwrap(owned, ref, ref_mut)]
 enum Maybe<T> {
     Just(T),
     Nothing,
@@ -28,6 +31,7 @@ fn main() {
     // assert_eq!(Maybe::Just(2).unwrap_nothing(), /* panic */);
 
     assert_eq!((&Maybe::Just(42)).unwrap_just_ref(), &42);
+    assert_eq!((&mut Maybe::Just(42)).unwrap_just_mut(), &mut 42);
 }
 ```
 
@@ -54,6 +58,12 @@ impl<T> Maybe<T> {
             _ => panic!(),
         }
     }
+    pub fn unwrap_nothing_mut(&mut self) -> () {
+        match self {
+            Maybe::Nothing => (),
+            _ => panic!(),
+        }
+    }
     pub fn unwrap_just(self) -> T {
         match self {
             Maybe::Just(field_0) => field_0,
@@ -66,5 +76,11 @@ impl<T> Maybe<T> {
             _ => panic!(),
         }
     }
+    pub fn unwrap_just_mut(&mut self) -> &mut T {
+        match self {
+            Maybe::Just(field_0) => field_0,
+            _ => panic!(),
+        }
+    }
 }
 ```

impl/src/fmt/parsing.rs

@@ -4,7 +4,7 @@
 
 use std::iter;
 
-use unicode_xid::UnicodeXID as XID;
+use unicode_ident::{is_xid_continue, is_xid_start};
 
 /// Output of the [`format_string`] parser.
 #[derive(Clone, Debug, Eq, PartialEq)]
@@ -517,10 +517,10 @@ fn identifier(input: &str) -> Option<(LeftToParse<'_>, Identifier<'_>)> {
     map(
         alt(&mut [
             &mut map(
-                check_char(XID::is_xid_start),
-                take_while0(check_char(XID::is_xid_continue)),
+                check_char(is_xid_start),
+                take_while0(check_char(is_xid_continue)),
             ),
-            &mut and_then(char('_'), take_while1(check_char(XID::is_xid_continue))),
+            &mut and_then(char('_'), take_while1(check_char(is_xid_continue))),
         ]),
         |(i, _)| (i, &input[..(input.len() - i.len())]),
     )(input)

impl/src/utils.rs

@@ -447,17 +447,17 @@ impl<'input> State<'input> {
             first_match.map_or(true, |info| !info.enabled.unwrap())
         };
 
+        // Default to owned true, unless the struct_meta_info or first attribute has ref type specified.
+        // - struct attribute with ref type specified means default false
+        // - not a single attribute means default true
+        // - an attribute, but non of owned, ref or ref_mut means default true
+        // - an attribute, and owned, ref or ref_mut means default false
+        let default_owned = !struct_meta_info.is_ref_type_specified()
+            && first_match.map_or(true, |info| !info.is_ref_type_specified());
         let defaults = struct_meta_info.into_full(FullMetaInfo {
             enabled: default_enabled,
             forward: false,
-            // Default to owned true, except when first attribute has one of owned,
-            // ref or ref_mut
-            // - not a single attribute means default true
-            // - an attribute, but non of owned, ref or ref_mut means default true
-            // - an attribute, and owned, ref or ref_mut means default false
-            owned: first_match.map_or(true, |info| {
-                info.owned.is_none() && info.ref_.is_none() || info.ref_mut.is_none()
-            }),
+            owned: default_owned,
             ref_: false,
             ref_mut: false,
             info: MetaInfo::default(),
@@ -1248,6 +1248,10 @@ impl MetaInfo {
             info: self,
         }
     }
+
+    fn is_ref_type_specified(&self) -> bool {
+        self.owned.is_some() || self.ref_.is_some() || self.ref_mut.is_some()
+    }
 }
 
 impl FullMetaInfo {

tests/compile_fail/as_mut/unknown_field_attr_arg.stderr

@@ -1,4 +1,4 @@
-error[E0412]: cannot find type `baz` in this scope
+error[E0425]: cannot find type `baz` in this scope
  --> tests/compile_fail/as_mut/unknown_field_attr_arg.rs:3:14
   |
 3 |     #[as_mut(baz)]

tests/compile_fail/as_mut/unknown_struct_attr_arg.stderr

@@ -1,4 +1,4 @@
-error[E0412]: cannot find type `baz` in this scope
+error[E0425]: cannot find type `baz` in this scope
  --> tests/compile_fail/as_mut/unknown_struct_attr_arg.rs:2:10
   |
 2 | #[as_mut(baz)]

tests/compile_fail/as_ref/unknown_field_attr_arg.stderr

@@ -1,4 +1,4 @@
-error[E0412]: cannot find type `baz` in this scope
+error[E0425]: cannot find type `baz` in this scope
  --> tests/compile_fail/as_ref/unknown_field_attr_arg.rs:3:14
   |
 3 |     #[as_ref(baz)]