From 7d549f29d63df264884e80f1e95d881d7c0f7407 Mon Sep 17 00:00:00 2001
From: Martin Fischer <martin@push-f.com>
Date: Sat, 20 Nov 2021 10:01:15 +0100
Subject: refactor: use syn::Generics::type_params iterators
---
src/lib.rs | 18 ++++++-------
src/transform.rs | 79 ++++++++++++++++++++++++++------------------------------
2 files changed, 45 insertions(+), 52 deletions(-)
diff --git a/src/lib.rs b/src/lib.rs
index b655778..957d424 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -178,16 +178,14 @@ pub fn dynamize(_attr: TokenStream, input: TokenStream) -> TokenStream {
let mut generic_map = HashMap::new();
- for generic in &dyn_trait.generics.params {
- if let GenericParam::Type(type_param) = generic {
- generic_map.insert(type_param.ident.clone(), type_param.bounds.clone());
- for trait_bound in trait_bounds(&type_param.bounds) {
- if let Some(assoc_type) = find_in_path(&trait_bound.path, &AssocTypeMatcher) {
- return abort!(
- assoc_type.span(),
- "dynamize does not support associated types in trait generic bounds"
- );
- }
+ for type_param in dyn_trait.generics.type_params() {
+ generic_map.insert(type_param.ident.clone(), type_param.bounds.clone());
+ for trait_bound in trait_bounds(&type_param.bounds) {
+ if let Some(assoc_type) = find_in_path(&trait_bound.path, &AssocTypeMatcher) {
+ return abort!(
+ assoc_type.span(),
+ "dynamize does not support associated types in trait generic bounds"
+ );
}
}
}
diff --git a/src/transform.rs b/src/transform.rs
index 39b32cc..cbada94 100644
--- a/src/transform.rs
+++ b/src/transform.rs
@@ -1,9 +1,7 @@
use std::collections::HashMap;
use proc_macro2::Span;
-use syn::{
- spanned::Spanned, GenericParam, Generics, Ident, PathArguments, Type, TypeParamBound, TypePath,
-};
+use syn::{spanned::Spanned, Generics, Ident, PathArguments, Type, TypeParamBound, TypePath};
use crate::{
parse_assoc_type::DestType,
@@ -107,51 +105,48 @@ pub fn dynamize_function_bounds(
) -> Result<HashMap<Ident, Vec<TypeTransform>>, (Span, MethodParseError)> {
let mut type_param_transforms = HashMap::new();
- for generic_param in &mut generics.params {
- if let GenericParam::Type(type_param) = generic_param {
- for bound in &mut type_param.bounds {
- if let TypeParamBound::Trait(bound) = bound {
- if bound.path.segments.len() == 1 {
- let segment = bound.path.segments.first_mut().unwrap();
+ for type_param in generics.type_params_mut() {
+ for bound in &mut type_param.bounds {
+ if let TypeParamBound::Trait(bound) = bound {
+ if bound.path.segments.len() == 1 {
+ let segment = bound.path.segments.first_mut().unwrap();
- if let PathArguments::Parenthesized(args) = &mut segment.arguments {
- if segment.ident == "Fn"
- || segment.ident == "FnOnce"
- || segment.ident == "FnMut"
- {
- let mut transforms = Vec::new();
- for input_type in &mut args.inputs {
- match assoc_type_conversions.parse_type_path(input_type) {
- Ok(ret_type) => {
- transforms.push(ret_type);
- }
- Err(TransformError::UnconvertibleAssocType(span)) => {
- return Err((
- span,
- MethodParseError::UnconvertibleAssocType,
- ));
- }
- Err(TransformError::AssocTypeInUnsupportedType(span)) => {
- return Err((
- span,
- MethodParseError::UnconvertibleAssocTypeInFnInput,
- ));
- }
+ if let PathArguments::Parenthesized(args) = &mut segment.arguments {
+ if segment.ident == "Fn"
+ || segment.ident == "FnOnce"
+ || segment.ident == "FnMut"
+ {
+ let mut transforms = Vec::new();
+ for input_type in &mut args.inputs {
+ match assoc_type_conversions.parse_type_path(input_type) {
+ Ok(ret_type) => {
+ transforms.push(ret_type);
+ }
+ Err(TransformError::UnconvertibleAssocType(span)) => {
+ return Err((
+ span,
+ MethodParseError::UnconvertibleAssocType,
+ ));
+ }
+ Err(TransformError::AssocTypeInUnsupportedType(span)) => {
+ return Err((
+ span,
+ MethodParseError::UnconvertibleAssocTypeInFnInput,
+ ));
}
}
- if transforms.iter().any(|t| !matches!(t, TypeTransform::NoOp)) {
- type_param_transforms
- .insert(type_param.ident.clone(), transforms);
- }
+ }
+ if transforms.iter().any(|t| !matches!(t, TypeTransform::NoOp)) {
+ type_param_transforms.insert(type_param.ident.clone(), transforms);
}
}
}
- if let Some(path) = find_in_path(&bound.path, &AssocTypeMatcher) {
- return Err((
- path.span(),
- MethodParseError::UnconvertibleAssocTypeInTraitBound,
- ));
- }
+ }
+ if let Some(path) = find_in_path(&bound.path, &AssocTypeMatcher) {
+ return Err((
+ path.span(),
+ MethodParseError::UnconvertibleAssocTypeInTraitBound,
+ ));
}
}
}
--
cgit v1.2.3