Fix most clippy warnings (paritytech#392)

* Get rid of scary conversions in to_delegate.rs

* Fix minor Clippy complaints

* Update derive/src/to_delegate.rs

Co-Authored-By: kirushik <[email protected]>

Author: kirushik

derive/src/rpc_attr.rs

@@ -73,7 +73,7 @@ impl RpcMethodAttribute {
 									.map_or(Vec::new(), |ml| get_aliases(ml));
 								Ok(RpcMethodAttribute {
 									attr: attr.clone(),
-									name: name.into(),
+									name: name,
 									aliases,
 									kind
 								})
@@ -106,7 +106,7 @@ impl RpcMethodAttribute {
 						Err(Error::new_spanned(meta, NEITHER_SUB_OR_UNSUB_ERR)),
 				};
 				kind.map(|kind| AttributeKind::PubSub {
-					subscription_name: sub_name.into(),
+					subscription_name: sub_name,
 					kind,
 				})
 			})
@@ -157,16 +157,16 @@ fn validate_attribute_meta(meta: syn::Meta) -> Result<syn::Meta> {
 
 fn validate_idents(meta: &syn::Meta, attr_idents: &[String], valid: &[&str]) -> Result<syn::Meta> {
 	let invalid_meta_words: Vec<_> = attr_idents
-		.into_iter()
+		.iter()
 		.filter(|w| !valid.iter().any(|v| v == w))
 		.cloned()
 		.collect();
-	if !invalid_meta_words.is_empty() {
+	if invalid_meta_words.is_empty() {
+		Ok(meta.clone())
+	} else {
 		let expected = format!("Expected '{}'", valid.join(", "));
 		let msg = format!("{} '{}'. {}", INVALID_ATTR_PARAM_NAMES_ERR, invalid_meta_words.join(", "), expected);
 		Err(Error::new_spanned(meta, msg))
-	} else {
-		Ok(meta.clone())
 	}
 }
 
@@ -203,7 +203,7 @@ fn has_meta_word(word: &str, ml: &syn::MetaList) -> bool {
 		.iter()
 		.any(|nested|
 			if let syn::NestedMeta::Meta(syn::Meta::Word(w)) = nested {
-				word == w.to_string()
+				w == word
 			} else {
 				false
 			}

derive/src/rpc_trait.rs

@@ -28,15 +28,14 @@ struct RpcTrait {
 
 impl<'a> Fold for RpcTrait {
 	fn fold_trait_item_method(&mut self, method: syn::TraitItemMethod) -> syn::TraitItemMethod {
-		let mut method = method.clone();
-		let method_item = method.clone();
+		let mut foldable_method = method.clone();
 		// strip rpc attributes
-		method.attrs.retain(|a| {
+		foldable_method.attrs.retain(|a| {
 			let rpc_method =
-				self.methods.iter().find(|m| m.trait_item == method_item);
+				self.methods.iter().find(|m| m.trait_item == method);
 			rpc_method.map_or(true, |rpc| rpc.attr.attr != *a)
 		});
-		fold::fold_trait_item_method(self, method)
+		fold::fold_trait_item_method(self, foldable_method)
 	}
 
 	fn fold_trait_item_type(&mut self, ty: syn::TraitItemType) -> syn::TraitItemType {
@@ -59,10 +58,10 @@ fn generate_rpc_item_trait(item_trait: &syn::ItemTrait) -> Result<(syn::ItemTrai
 		.iter()
 		.filter_map(|trait_item| {
 			if let syn::TraitItem::Method(method) = trait_item {
-				match RpcMethodAttribute::parse_attr(&method) {
+				match RpcMethodAttribute::parse_attr(method) {
 					Ok(Some(attr)) =>
 						Some(Ok(RpcMethod::new(
-							attr.clone(),
+							attr,
 							method.clone(),
 						))),
 					Ok(None) => None, // non rpc annotated trait method
@@ -150,7 +149,7 @@ fn rpc_wrapper_mod_name(rpc_trait: &syn::ItemTrait) -> syn::Ident {
 pub fn rpc_impl(input: syn::Item) -> Result<proc_macro2::TokenStream> {
 	let rpc_trait = match input {
 		syn::Item::Trait(item_trait) => item_trait,
-		item @ _ => return Err(syn::Error::new_spanned(item, "The #[rpc] custom attribute only works with trait declarations")),
+		item => return Err(syn::Error::new_spanned(item, "The #[rpc] custom attribute only works with trait declarations")),
 	};
 
 	let (rpc_trait, has_pubsub_methods) = generate_rpc_item_trait(&rpc_trait)?;

derive/src/to_delegate.rs

@@ -75,6 +75,8 @@ const SUBCRIBER_TYPE_IDENT: &str = "Subscriber";
 const METADATA_CLOSURE_ARG: &str = "meta";
 const SUBSCRIBER_CLOSURE_ARG: &str = "subscriber";
 
+const TUPLE_FIELD_NAMES: [&str; 26] = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"];
+
 pub fn generate_trait_item_method(
 	methods: &[MethodRegistration],
 	trait_item: &syn::ItemTrait,
@@ -169,9 +171,7 @@ impl RpcMethod {
 			special_args.iter().find(|(_,sty)| sty == ty).is_none());
 
 		let tuple_fields : &Vec<_> =
-			&(0..param_types.len() as u8)
-				.map(|x| ident(&((x + 'a' as u8) as char).to_string()))
-				.collect();
+			&(TUPLE_FIELD_NAMES.iter().take(param_types.len()).map(|name| ident(name)).collect());
 		let param_types = &param_types;
 		let parse_params = {
 			// last arguments that are `Option`-s are optional 'trailing' arguments
@@ -235,7 +235,7 @@ impl RpcMethod {
 		let meta_arg =
 			param_types.first().and_then(|ty|
 				if *ty == parse_quote!(Self::Metadata) { Some(ty.clone()) } else { None });
-		let subscriber_arg = param_types.iter().nth(1).and_then(|ty| {
+		let subscriber_arg = param_types.get(1).and_then(|ty| {
 			if let syn::Type::Path(path) = ty {
 				if path.path.segments.iter().any(|s| s.ident == SUBCRIBER_TYPE_IDENT) {
 					Some(ty.clone())