3 files changed, 25 insertions, 6 deletions
diff --git a/src/lib.rs b/src/lib.rs
index 17cea6d..439288e 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -110,9 +110,11 @@ pub fn dynamize(_attr: TokenStream, input: TokenStream) -> TokenStream {
                     MethodParseError::AssocTypeInUnsupportedReturnType
                     | MethodParseError::UnconvertibleAssocTypeInFnInput,
                 )) => return abort!(span, "dynamize does not know how to convert this type"),
-                Err((span, MethodParseError::UnconvertibleAssocTypeInTraitBound)) => {
-                    return abort!(span, "dynamize does not support associated types here")
-                }
+                Err((
+                    span,
+                    MethodParseError::UnconvertibleAssocTypeInTraitBound
+                    | MethodParseError::UnconvertibleAssocTypeInWhereClause,
+                )) => return abort!(span, "dynamize does not support associated types here"),
                 Err((span, MethodParseError::ImplTraitInInputs)) => {
                     return abort!(
                         span,
diff --git a/src/parse_trait_sig.rs b/src/parse_trait_sig.rs
index 508e131..82b8ee9 100644
--- a/src/parse_trait_sig.rs
+++ b/src/parse_trait_sig.rs
@@ -28,6 +28,7 @@ pub enum MethodParseError {
     AssocTypeInUnsupportedReturnType,
     UnconvertibleAssocTypeInFnInput,
     UnconvertibleAssocTypeInTraitBound,
+    UnconvertibleAssocTypeInWhereClause,
     UnconvertibleAssocType,
 }
 
diff --git a/src/transform.rs b/src/transform.rs
index 676cfd8..b13b7cf 100644
--- a/src/transform.rs
+++ b/src/transform.rs
@@ -141,11 +141,27 @@ pub fn dynamize_function_bounds(
                     }
                 }
 
-                // TODO: return error if predicate_type.bounded_ty contains associated type
+                // just to provide better error messages
+                if let Some(assoc_type) =
+                    iter_type(&predicate_type.bounded_ty).find_map(filter_map_assoc_paths)
+                {
+                    return Err((
+                        assoc_type.span(),
+                        MethodParseError::UnconvertibleAssocTypeInWhereClause,
+                    ));
+                }
 
+                // just to provide better error messages
                 for bound in &mut predicate_type.bounds {
-                    if let TypeParamBound::Trait(_bound) = bound {
-                        // TODO: return error if bound.path contains associated type
+                    if let TypeParamBound::Trait(bound) = bound {
+                        if let Some(assoc_type) =
+                            iter_path(&bound.path).find_map(filter_map_assoc_paths)
+                        {
+                            return Err((
+                                assoc_type.span(),
+                                MethodParseError::UnconvertibleAssocTypeInWhereClause,
+                            ));
+                        }
                     }
                 }
             }