kernel_cmdline: Standardize Deref/AsRef impls across types

Implement generic AsRef in terms of Deref as suggested in:

https://doc.rust-lang.org/std/convert/trait.AsRef.html#generic-implementations

I'm not 100% sold on this since in some case (like the change to the
tests here) you have to end up doing `&*` coercion to get the right
type, but this at least makes everything consistent.

Would be a bit nicer when/if str_as_str[1] stabilizes, at least for
the most common UTF-8 case.

[1] rust-lang/rust#130366

Signed-off-by: John Eckersberg <[email protected]>

Author: jeckersb

crates/kernel_cmdline/src/bytes.rs

@@ -39,6 +39,16 @@ impl Deref for Cmdline<'_> {
     }
 }
 
+impl<'a, T> AsRef<T> for Cmdline<'a>
+where
+    T: ?Sized,
+    <Cmdline<'a> as Deref>::Target: AsRef<T>,
+{
+    fn as_ref(&self) -> &T {
+        self.deref().as_ref()
+    }
+}
+
 impl From<Vec<u8>> for CmdlineOwned {
     /// Creates a new `Cmdline` from an owned `Vec<u8>`.
     fn from(input: Vec<u8>) -> Self {
@@ -340,12 +350,6 @@ impl<'a> Cmdline<'a> {
     }
 }
 
-impl<'a> AsRef<[u8]> for Cmdline<'a> {
-    fn as_ref(&self) -> &[u8] {
-        &self.0
-    }
-}
-
 impl<'a> IntoIterator for &'a Cmdline<'a> {
     type Item = Parameter<'a>;
     type IntoIter = CmdlineIter<'a>;
@@ -376,10 +380,10 @@ impl<'a, 'other> Extend<Parameter<'other>> for Cmdline<'a> {
 #[derive(Clone, Debug, Eq)]
 pub struct ParameterKey<'a>(pub(crate) &'a [u8]);
 
-impl<'a> Deref for ParameterKey<'a> {
+impl Deref for ParameterKey<'_> {
     type Target = [u8];
 
-    fn deref(&self) -> &'a Self::Target {
+    fn deref(&self) -> &Self::Target {
         self.0
     }
 }
@@ -509,14 +513,24 @@ impl<'a> PartialEq for Parameter<'a> {
     }
 }
 
-impl<'a> std::ops::Deref for Parameter<'a> {
+impl Deref for Parameter<'_> {
     type Target = [u8];
 
-    fn deref(&self) -> &'a Self::Target {
+    fn deref(&self) -> &Self::Target {
         self.parameter
     }
 }
 
+impl<'a, T> AsRef<T> for Parameter<'a>
+where
+    T: ?Sized,
+    <Parameter<'a> as Deref>::Target: AsRef<T>,
+{
+    fn as_ref(&self) -> &T {
+        self.deref().as_ref()
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

crates/kernel_cmdline/src/utf8.rs

@@ -224,10 +224,13 @@ impl Deref for Cmdline<'_> {
     }
 }
 
-impl<'a> AsRef<str> for Cmdline<'a> {
-    fn as_ref(&self) -> &str {
-        str::from_utf8(self.0.as_ref())
-            .expect("We only construct the underlying bytes from valid UTF-8")
+impl<'a, T> AsRef<T> for Cmdline<'a>
+where
+    T: ?Sized,
+    <Cmdline<'a> as Deref>::Target: AsRef<T>,
+{
+    fn as_ref(&self) -> &T {
+        self.deref().as_ref()
     }
 }
 
@@ -267,7 +270,7 @@ impl<'a, 'other> Extend<Parameter<'other>> for Cmdline<'a> {
 #[derive(Clone, Debug, Eq)]
 pub struct ParameterKey<'a>(bytes::ParameterKey<'a>);
 
-impl<'a> Deref for ParameterKey<'a> {
+impl Deref for ParameterKey<'_> {
     type Target = str;
 
     fn deref(&self) -> &Self::Target {
@@ -381,7 +384,7 @@ impl<'a> std::fmt::Display for Parameter<'a> {
     }
 }
 
-impl<'a> Deref for Parameter<'a> {
+impl Deref for Parameter<'_> {
     type Target = str;
 
     fn deref(&self) -> &Self::Target {
@@ -391,6 +394,16 @@ impl<'a> Deref for Parameter<'a> {
     }
 }
 
+impl<'a, T> AsRef<T> for Parameter<'a>
+where
+    T: ?Sized,
+    <Parameter<'a> as Deref>::Target: AsRef<T>,
+{
+    fn as_ref(&self) -> &T {
+        self.deref().as_ref()
+    }
+}
+
 impl<'a> PartialEq for Parameter<'a> {
     fn eq(&self, other: &Self) -> bool {
         self.0 == other.0
@@ -769,7 +782,7 @@ mod tests {
     fn test_add_empty_cmdline() {
         let mut kargs = Cmdline::from("");
         assert!(matches!(kargs.add(&param("foo")), Action::Added));
-        assert_eq!(kargs.as_ref(), "foo");
+        assert_eq!(&*kargs, "foo");
     }
 
     #[test]
@@ -809,7 +822,7 @@ mod tests {
     fn test_add_or_modify_empty_cmdline() {
         let mut kargs = Cmdline::from("");
         assert!(matches!(kargs.add_or_modify(&param("foo")), Action::Added));
-        assert_eq!(kargs.as_ref(), "foo");
+        assert_eq!(&*kargs, "foo");
     }
 
     #[test]