clippy fixes

dhuseby · dhuseby · commit ea97df0f67b3 · 2024-08-27T20:03:16.000-06:00
Signed-off-by: Dave Huseby &lt;dwh@linuxprogrammer.org&gt;
diff --git a/src/attrid.rs b/src/attrid.rs
@@ -28,7 +28,7 @@ pub enum AttrId {
 impl AttrId {
     /// Get the code for the attribute id
     pub fn code(&self) -> u8 {
-        self.clone().into()
+        (*self).into()
     }
 
     /// Convert the attribute id to &str
@@ -45,9 +45,9 @@ impl AttrId {
     }
 }
 
-impl Into<u8> for AttrId {
-    fn into(self) -> u8 {
-        self as u8
+impl From<AttrId> for u8 {
+    fn from(val: AttrId) -> Self {
+        val as u8
     }
 }
 
@@ -68,9 +68,9 @@ impl TryFrom<u8> for AttrId {
     }
 }
 
-impl Into<Vec<u8>> for AttrId {
-    fn into(self) -> Vec<u8> {
-        self.code().encode_into()
+impl From<AttrId> for Vec<u8> {
+    fn from(val: AttrId) -> Self {
+        val.code().encode_into()
     }
 }
 
diff --git a/src/ms.rs b/src/ms.rs
@@ -77,19 +77,19 @@ impl EncodingInfo for Multisig {
     }
 }
 
-impl Into<Vec<u8>> for Multisig {
-    fn into(self) -> Vec<u8> {
+impl From<Multisig> for Vec<u8> {
+    fn from(val: Multisig) -> Self {
         let mut v = Vec::default();
         // add in the sigil
         v.append(&mut SIGIL.into());
         // add in the signature codec
-        v.append(&mut self.codec.into());
+        v.append(&mut val.codec.into());
         // add in the message
-        v.append(&mut Varbytes(self.message.clone()).into());
+        v.append(&mut Varbytes(val.message.clone()).into());
         // add in the number of attributes
-        v.append(&mut Varuint(self.attributes.len()).into());
+        v.append(&mut Varuint(val.attributes.len()).into());
         // add in the attributes
-        self.attributes.iter().for_each(|(id, attr)| {
+        val.attributes.iter().for_each(|(id, attr)| {
             v.append(&mut (*id).into());
             v.append(&mut Varbytes(attr.clone()).into());
         });
@@ -167,7 +167,7 @@ impl fmt::Debug for Multisig {
             "{:?} - {:?} - {}",
             SIGIL,
             self.codec(),
-            if self.message.len() > 0 {
+            if !self.message.is_empty() {
                 "Combined"
             } else {
                 "Detached"
@@ -405,7 +405,7 @@ impl Builder {
 
     fn with_attribute(mut self, attr: AttrId, data: &Vec<u8>) -> Self {
         let mut attributes = self.attributes.unwrap_or_default();
-        attributes.insert(attr, data.clone());
+        attributes.insert(attr, data.to_owned());
         self.attributes = Some(attributes);
         self
     }
@@ -457,7 +457,7 @@ impl Builder {
     pub fn try_build_encoded(self) -> Result<EncodedMultisig, Error> {
         Ok(BaseEncoded::new(
             self.base_encoding
-                .unwrap_or_else(|| Multisig::preferred_encoding()),
+                .unwrap_or_else(Multisig::preferred_encoding),
             self.try_build()?,
         ))
     }
diff --git a/src/serde/de.rs b/src/serde/de.rs
@@ -30,28 +30,28 @@ impl<'de> Deserialize<'de> for AttrId {
             where
                 E: Error,
             {
-                Ok(AttrId::try_from(c).map_err(|e| Error::custom(e.to_string()))?)
+                AttrId::try_from(c).map_err(|e| Error::custom(e.to_string()))
             }
 
             fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
             where
                 E: Error,
             {
-                Ok(AttrId::try_from(s).map_err(|e| Error::custom(e.to_string()))?)
+                AttrId::try_from(s).map_err(|e| Error::custom(e.to_string()))
             }
 
             fn visit_borrowed_str<E>(self, s: &'de str) -> Result<Self::Value, E>
             where
                 E: Error,
             {
-                Ok(AttrId::try_from(s).map_err(|e| Error::custom(e.to_string()))?)
+                AttrId::try_from(s).map_err(|e| Error::custom(e.to_string()))
             }
 
             fn visit_string<E>(self, s: String) -> Result<Self::Value, E>
             where
                 E: Error,
             {
-                Ok(AttrId::try_from(s.as_str()).map_err(|e| Error::custom(e.to_string()))?)
+                AttrId::try_from(s.as_str()).map_err(|e| Error::custom(e.to_string()))
             }
         }
 
@@ -65,7 +65,7 @@ impl<'de> Deserialize<'de> for Multisig {
     where
         D: Deserializer<'de>,
     {
-        const FIELDS: &'static [&'static str] = &["codec", "message", "attributes"];
+        const FIELDS: &[&str] = &["codec", "message", "attributes"];
 
         #[derive(Deserialize)]
         #[serde(field_identifier, rename_all = "lowercase")]
diff --git a/src/views/bls12381.rs b/src/views/bls12381.rs
@@ -37,7 +37,7 @@ pub enum SchemeTypeId {
 impl SchemeTypeId {
     /// Get the code for the attribute id
     pub fn code(&self) -> u8 {
-        self.clone().into()
+        (*self).into()
     }
 
     /// Convert the attribute id to &str
@@ -50,9 +50,9 @@ impl SchemeTypeId {
     }
 }
 
-impl Into<u8> for SchemeTypeId {
-    fn into(self) -> u8 {
-        self as u8
+impl From<SchemeTypeId> for u8 {
+    fn from(val: SchemeTypeId) -> Self {
+        val as u8
     }
 }
 
@@ -69,9 +69,9 @@ impl TryFrom<u8> for SchemeTypeId {
     }
 }
 
-impl Into<SignatureSchemes> for SchemeTypeId {
-    fn into(self) -> SignatureSchemes {
-        match self {
+impl From<SchemeTypeId> for SignatureSchemes {
+    fn from(val: SchemeTypeId) -> Self {
+        match val {
             SchemeTypeId::Basic => SignatureSchemes::Basic,
             SchemeTypeId::MessageAugmentation => SignatureSchemes::MessageAugmentation,
             SchemeTypeId::ProofOfPossession => SignatureSchemes::ProofOfPossession,
@@ -115,9 +115,9 @@ where
     }
 }
 
-impl Into<Vec<u8>> for SchemeTypeId {
-    fn into(self) -> Vec<u8> {
-        self.code().encode_into()
+impl From<SchemeTypeId> for Vec<u8> {
+    fn from(val: SchemeTypeId) -> Self {
+        val.code().encode_into()
     }
 }
 
@@ -167,13 +167,13 @@ pub struct SigCombined(
     pub Vec<u8>,
 );
 
-impl Into<Vec<u8>> for SigCombined {
-    fn into(self) -> Vec<u8> {
+impl From<SigCombined> for Vec<u8> {
+    fn from(val: SigCombined) -> Self {
         let mut v = Vec::default();
         // add in the signature type id
-        v.append(&mut self.0.into());
+        v.append(&mut val.0.into());
         // add in the signature bytes
-        v.append(&mut Varbytes(self.1.clone()).into());
+        v.append(&mut Varbytes(val.1.clone()).into());
         v
     }
 }
@@ -214,19 +214,19 @@ pub struct SigShare(
     pub Vec<u8>,
 );
 
-impl Into<Vec<u8>> for SigShare {
-    fn into(self) -> Vec<u8> {
+impl From<SigShare> for Vec<u8> {
+    fn from(val: SigShare) -> Self {
         let mut v = Vec::default();
         // add in the share identifier
-        v.append(&mut Varuint(self.0).into());
+        v.append(&mut Varuint(val.0).into());
         // add in the share threshold
-        v.append(&mut Varuint(self.1).into());
+        v.append(&mut Varuint(val.1).into());
         // add in the share limit
-        v.append(&mut Varuint(self.2).into());
+        v.append(&mut Varuint(val.2).into());
         // add in the share type id
-        v.append(&mut self.3.into());
+        v.append(&mut val.3.into());
         // add in the share data
-        v.append(&mut Varbytes(self.4.clone()).into());
+        v.append(&mut Varbytes(val.4.clone()).into());
         v
     }
 }
@@ -270,13 +270,13 @@ impl<'a> TryDecodeFrom<'a> for SigShare {
 #[derive(Clone, Default)]
 pub(crate) struct ThresholdData(pub(crate) BTreeMap<u8, SigShare>);
 
-impl Into<Vec<u8>> for ThresholdData {
-    fn into(self) -> Vec<u8> {
+impl From<ThresholdData> for Vec<u8> {
+    fn from(val: ThresholdData) -> Self {
         let mut v = Vec::default();
         // add in the number of sig shares
-        v.append(&mut Varuint(self.0.len()).into());
+        v.append(&mut Varuint(val.0.len()).into());
         // add in the sig shares
-        self.0.iter().for_each(|(_, share)| {
+        val.0.iter().for_each(|(_, share)| {
             v.append(&mut share.clone().into());
         });
         v
@@ -607,11 +607,7 @@ impl<'a> ThresholdView for View<'a> {
             match av.payload_encoding() {
                 Ok(encoding) => Some(encoding),
                 Err(_) => {
-                    if let Some(encoding) = encoding {
-                        Some(encoding)
-                    } else {
-                        None
-                    }
+                    encoding
                 }
             }
         };
@@ -737,7 +733,7 @@ impl<'a> ThresholdView for View<'a> {
                     builder.try_build()
                 }
             }
-            _ => return Err(Error::UnsupportedAlgorithm(self.ms.codec.to_string())),
+            _ => Err(Error::UnsupportedAlgorithm(self.ms.codec.to_string())),
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -28,7 +28,7 @@ pub enum AttrId {`
`28`	`28`	`impl AttrId {`
`29`	`29`	`/// Get the code for the attribute id`
`30`	`30`	`pub fn code(&self) -> u8 {`
`31`		`- self.clone().into()`
	`31`	`+ (*self).into()`
`32`	`32`	`}`
`33`	`33`
`34`	`34`	`/// Convert the attribute id to &str`
`@@ -45,9 +45,9 @@ impl AttrId {`
`45`	`45`	`}`
`46`	`46`	`}`
`47`	`47`
`48`		`-impl Into<u8> for AttrId {`
`49`		`- fn into(self) -> u8 {`
`50`		`- self as u8`
	`48`	`+impl From<AttrId> for u8 {`
	`49`	`+ fn from(val: AttrId) -> Self {`
	`50`	`+ val as u8`
`51`	`51`	`}`
`52`	`52`	`}`
`53`	`53`
`@@ -68,9 +68,9 @@ impl TryFrom<u8> for AttrId {`
`68`	`68`	`}`
`69`	`69`	`}`
`70`	`70`
`71`		`-impl Into<Vec<u8>> for AttrId {`
`72`		`- fn into(self) -> Vec<u8> {`
`73`		`- self.code().encode_into()`
	`71`	`+impl From<AttrId> for Vec<u8> {`
	`72`	`+ fn from(val: AttrId) -> Self {`
	`73`	`+ val.code().encode_into()`
`74`	`74`	`}`
`75`	`75`	`}`
`76`	`76`
Original file line number	Diff line number	Diff line change
`@@ -30,28 +30,28 @@ impl<'de> Deserialize<'de> for AttrId {`
`30`	`30`	`where`
`31`	`31`	`E: Error,`
`32`	`32`	`{`
`33`		`- Ok(AttrId::try_from(c).map_err(\|e\| Error::custom(e.to_string()))?)`
	`33`	`+ AttrId::try_from(c).map_err(\|e\| Error::custom(e.to_string()))`
`34`	`34`	`}`
`35`	`35`
`36`	`36`	`fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>`
`37`	`37`	`where`
`38`	`38`	`E: Error,`
`39`	`39`	`{`
`40`		`- Ok(AttrId::try_from(s).map_err(\|e\| Error::custom(e.to_string()))?)`
	`40`	`+ AttrId::try_from(s).map_err(\|e\| Error::custom(e.to_string()))`
`41`	`41`	`}`
`42`	`42`
`43`	`43`	`fn visit_borrowed_str<E>(self, s: &'de str) -> Result<Self::Value, E>`
`44`	`44`	`where`
`45`	`45`	`E: Error,`
`46`	`46`	`{`
`47`		`- Ok(AttrId::try_from(s).map_err(\|e\| Error::custom(e.to_string()))?)`
	`47`	`+ AttrId::try_from(s).map_err(\|e\| Error::custom(e.to_string()))`
`48`	`48`	`}`
`49`	`49`
`50`	`50`	`fn visit_string<E>(self, s: String) -> Result<Self::Value, E>`
`51`	`51`	`where`
`52`	`52`	`E: Error,`
`53`	`53`	`{`
`54`		`- Ok(AttrId::try_from(s.as_str()).map_err(\|e\| Error::custom(e.to_string()))?)`
	`54`	`+ AttrId::try_from(s.as_str()).map_err(\|e\| Error::custom(e.to_string()))`
`55`	`55`	`}`
`56`	`56`	`}`
`57`	`57`
`@@ -65,7 +65,7 @@ impl<'de> Deserialize<'de> for Multisig {`
`65`	`65`	`where`
`66`	`66`	`D: Deserializer<'de>,`
`67`	`67`	`{`
`68`		`- const FIELDS: &'static [&'static str] = &["codec", "message", "attributes"];`
	`68`	`+ const FIELDS: &[&str] = &["codec", "message", "attributes"];`
`69`	`69`
`70`	`70`	`#[derive(Deserialize)]`
`71`	`71`	`#[serde(field_identifier, rename_all = "lowercase")]`
Original file line number	Diff line number	Diff line change
`@@ -37,7 +37,7 @@ pub enum SchemeTypeId {`
`37`	`37`	`impl SchemeTypeId {`
`38`	`38`	`/// Get the code for the attribute id`
`39`	`39`	`pub fn code(&self) -> u8 {`
`40`		`- self.clone().into()`
	`40`	`+ (*self).into()`
`41`	`41`	`}`
`42`	`42`
`43`	`43`	`/// Convert the attribute id to &str`
`@@ -50,9 +50,9 @@ impl SchemeTypeId {`
`50`	`50`	`}`
`51`	`51`	`}`
`52`	`52`
`53`		`-impl Into<u8> for SchemeTypeId {`
`54`		`- fn into(self) -> u8 {`
`55`		`- self as u8`
	`53`	`+impl From<SchemeTypeId> for u8 {`
	`54`	`+ fn from(val: SchemeTypeId) -> Self {`
	`55`	`+ val as u8`
`56`	`56`	`}`
`57`	`57`	`}`
`58`	`58`
`@@ -69,9 +69,9 @@ impl TryFrom<u8> for SchemeTypeId {`
`69`	`69`	`}`
`70`	`70`	`}`
`71`	`71`
`72`		`-impl Into<SignatureSchemes> for SchemeTypeId {`
`73`		`- fn into(self) -> SignatureSchemes {`
`74`		`- match self {`
	`72`	`+impl From<SchemeTypeId> for SignatureSchemes {`
	`73`	`+ fn from(val: SchemeTypeId) -> Self {`
	`74`	`+ match val {`
`75`	`75`	`SchemeTypeId::Basic => SignatureSchemes::Basic,`
`76`	`76`	`SchemeTypeId::MessageAugmentation => SignatureSchemes::MessageAugmentation,`
`77`	`77`	`SchemeTypeId::ProofOfPossession => SignatureSchemes::ProofOfPossession,`
`@@ -115,9 +115,9 @@ where`
`115`	`115`	`}`
`116`	`116`	`}`
`117`	`117`
`118`		`-impl Into<Vec<u8>> for SchemeTypeId {`
`119`		`- fn into(self) -> Vec<u8> {`
`120`		`- self.code().encode_into()`
	`118`	`+impl From<SchemeTypeId> for Vec<u8> {`
	`119`	`+ fn from(val: SchemeTypeId) -> Self {`
	`120`	`+ val.code().encode_into()`
`121`	`121`	`}`
`122`	`122`	`}`
`123`	`123`
`@@ -167,13 +167,13 @@ pub struct SigCombined(`
`167`	`167`	`pub Vec<u8>,`
`168`	`168`	`);`
`169`	`169`
`170`		`-impl Into<Vec<u8>> for SigCombined {`
`171`		`- fn into(self) -> Vec<u8> {`
	`170`	`+impl From<SigCombined> for Vec<u8> {`
	`171`	`+ fn from(val: SigCombined) -> Self {`
`172`	`172`	`let mut v = Vec::default();`
`173`	`173`	`// add in the signature type id`
`174`		`- v.append(&mut self.0.into());`
	`174`	`+ v.append(&mut val.0.into());`
`175`	`175`	`// add in the signature bytes`
`176`		`- v.append(&mut Varbytes(self.1.clone()).into());`
	`176`	`+ v.append(&mut Varbytes(val.1.clone()).into());`
`177`	`177`	`v`
`178`	`178`	`}`
`179`	`179`	`}`
`@@ -214,19 +214,19 @@ pub struct SigShare(`
`214`	`214`	`pub Vec<u8>,`
`215`	`215`	`);`
`216`	`216`
`217`		`-impl Into<Vec<u8>> for SigShare {`
`218`		`- fn into(self) -> Vec<u8> {`
	`217`	`+impl From<SigShare> for Vec<u8> {`
	`218`	`+ fn from(val: SigShare) -> Self {`
`219`	`219`	`let mut v = Vec::default();`
`220`	`220`	`// add in the share identifier`
`221`		`- v.append(&mut Varuint(self.0).into());`
	`221`	`+ v.append(&mut Varuint(val.0).into());`
`222`	`222`	`// add in the share threshold`
`223`		`- v.append(&mut Varuint(self.1).into());`
	`223`	`+ v.append(&mut Varuint(val.1).into());`
`224`	`224`	`// add in the share limit`
`225`		`- v.append(&mut Varuint(self.2).into());`
	`225`	`+ v.append(&mut Varuint(val.2).into());`
`226`	`226`	`// add in the share type id`
`227`		`- v.append(&mut self.3.into());`
	`227`	`+ v.append(&mut val.3.into());`
`228`	`228`	`// add in the share data`
`229`		`- v.append(&mut Varbytes(self.4.clone()).into());`
	`229`	`+ v.append(&mut Varbytes(val.4.clone()).into());`
`230`	`230`	`v`
`231`	`231`	`}`
`232`	`232`	`}`
`@@ -270,13 +270,13 @@ impl<'a> TryDecodeFrom<'a> for SigShare {`
`270`	`270`	`#[derive(Clone, Default)]`
`271`	`271`	`pub(crate) struct ThresholdData(pub(crate) BTreeMap<u8, SigShare>);`
`272`	`272`
`273`		`-impl Into<Vec<u8>> for ThresholdData {`
`274`		`- fn into(self) -> Vec<u8> {`
	`273`	`+impl From<ThresholdData> for Vec<u8> {`
	`274`	`+ fn from(val: ThresholdData) -> Self {`
`275`	`275`	`let mut v = Vec::default();`
`276`	`276`	`// add in the number of sig shares`
`277`		`- v.append(&mut Varuint(self.0.len()).into());`
	`277`	`+ v.append(&mut Varuint(val.0.len()).into());`
`278`	`278`	`// add in the sig shares`
`279`		`- self.0.iter().for_each(\|(_, share)\| {`
	`279`	`+ val.0.iter().for_each(\|(_, share)\| {`
`280`	`280`	`v.append(&mut share.clone().into());`
`281`	`281`	`});`
`282`	`282`	`v`
`@@ -607,11 +607,7 @@ impl<'a> ThresholdView for View<'a> {`
`607`	`607`	`match av.payload_encoding() {`
`608`	`608`	`Ok(encoding) => Some(encoding),`
`609`	`609`	`Err(_) => {`
`610`		`- if let Some(encoding) = encoding {`
`611`		`- Some(encoding)`
`612`		`- } else {`
`613`		`- None`
`614`		`- }`
	`610`	`+ encoding`
`615`	`611`	`}`
`616`	`612`	`}`
`617`	`613`	`};`
`@@ -737,7 +733,7 @@ impl<'a> ThresholdView for View<'a> {`
`737`	`733`	`builder.try_build()`
`738`	`734`	`}`
`739`	`735`	`}`
`740`		`- _ => return Err(Error::UnsupportedAlgorithm(self.ms.codec.to_string())),`
	`736`	`+ _ => Err(Error::UnsupportedAlgorithm(self.ms.codec.to_string())),`
`741`	`737`	`}`
`742`	`738`	`}`
`743`	`739`	`}`