Do not force `Deref<T>` generic params to always be a `&T`

This is a bit of a toss-up, really neither option is fully correct,
really we need it to depend on the type of object in question, but
that takes more work and it looks like we don't use the `&T`
resolution anymore.

diff --git a/c-bindings-gen/src/types.rs b/c-bindings-gen/src/types.rs
index 2ea9221a63f6a6a22a76c01b93e9a0d29ae92db3..b988a7b6d563a2b60003ee869d648b856b21db83 100644 (file)
--- a/c-bindings-gen/src/types.rs
+++ b/c-bindings-gen/src/types.rs
@@ -283,14 +283,12 @@ impl<'a, 'p: 'a> GenericTypes<'a, 'p> {
                                                                        non_lifetimes_processed = true;
                                                                        assert_simple_bound(&trait_bound);
                                                                        let resolved = types.resolve_path(&trait_bound.path, None);
-                                                                       let ref_ty = syn::Type::Reference(syn::TypeReference {
-                                                                               and_token: syn::Token![&](Span::call_site()),
-                                                                               lifetime: None, mutability: None,
-                                                                               elem: Box::new(syn::Type::Path(syn::TypePath {
-                                                                                       qself: None, path: string_path_to_syn_path(&resolved)
-                                                                               })),
+                                                                       let ty = syn::Type::Path(syn::TypePath {
+                                                                               qself: None, path: string_path_to_syn_path(&resolved)
                                                                        });
-                                                                       self.default_generics.insert(p_ident, (ref_ty.clone(), ref_ty));
+                                                                       let ref_ty = parse_quote!(&#ty);
+                                                                       self.default_generics.insert(p_ident, (ty, ref_ty));
+
                                                                        *gen = Some(resolved);
                                                                }
                                                        }