From 19ebe5e21418685c3393e788a4af576830b983e7 Mon Sep 17 00:00:00 2001
From: Matt Corallo <git@bluematt.me>
Date: Wed, 22 Sep 2021 06:04:50 +0000
Subject: [PATCH] Use `GenericTypes`'s type resolver instead of re-resolving

When we resolve a type with `GenericTypes::maybe_resolve_path` it
returns a resolved-path string as well as a syn::Path. When
resolving we'd previously then re-resolve the Path with the current
type/import information, instead of just accepting what was already
resolved. Simply accepting what was already resolved not only
simplifies a few cases, but also allows us to clean up where the
"crate::" prefix is printed, keeping "crate::" prefixes out of all
type resolution.
---
 c-bindings-gen/src/blocks.rs |  2 +-
 c-bindings-gen/src/types.rs  | 20 +++++++++-----------
 2 files changed, 10 insertions(+), 12 deletions(-)

diff --git a/c-bindings-gen/src/blocks.rs b/c-bindings-gen/src/blocks.rs
index 9c32ef1..fab69f6 100644
--- a/c-bindings-gen/src/blocks.rs
+++ b/c-bindings-gen/src/blocks.rs
@@ -737,7 +737,7 @@ pub fn maybe_write_generics<W: std::io::Write>(w: &mut W, generics: &syn::Generi
 					for bound in type_param.bounds.iter() {
 						if let syn::TypeParamBound::Trait(trait_bound) = bound {
 							assert_simple_bound(&trait_bound);
-							write!(w, "{}{}", if idx != 0 { ", " } else { "" }, gen_types.maybe_resolve_ident(&type_param.ident).unwrap()).unwrap();
+							write!(w, "{}crate::{}", if idx != 0 { ", " } else { "" }, gen_types.maybe_resolve_ident(&type_param.ident).unwrap()).unwrap();
 							if printed_param {
 								unimplemented!("Can't print generic params that have multiple non-lifetime bounds");
 							}
diff --git a/c-bindings-gen/src/types.rs b/c-bindings-gen/src/types.rs
index b4b46a8..50800bb 100644
--- a/c-bindings-gen/src/types.rs
+++ b/c-bindings-gen/src/types.rs
@@ -205,13 +205,12 @@ impl<'a, 'p: 'a> GenericTypes<'a, 'p> {
 							if path_matches_nongeneric(&trait_bound.path, &["core", "clone", "Clone"]) { continue; }
 
 							assert_simple_bound(&trait_bound);
-							if let Some(mut path) = types.maybe_resolve_path(&trait_bound.path, None) {
+							if let Some(path) = types.maybe_resolve_path(&trait_bound.path, None) {
 								if types.skip_path(&path) { continue; }
 								if path == "Sized" { continue; }
 								if non_lifetimes_processed { return false; }
 								non_lifetimes_processed = true;
 								let new_ident = if path != "std::ops::Deref" && path != "core::ops::Deref" {
-									path = "crate::".to_string() + &path;
 									Some(&trait_bound.path)
 								} else if trait_bound.path.segments.len() == 1 {
 									// If we're templated on Deref<Target = ConcreteThing>, store
@@ -267,7 +266,7 @@ impl<'a, 'p: 'a> GenericTypes<'a, 'p> {
 									if non_lifetimes_processed { return false; }
 									non_lifetimes_processed = true;
 									assert_simple_bound(&trait_bound);
-									*gen = ("crate::".to_string() + &types.resolve_path(&trait_bound.path, None),
+									*gen = (types.resolve_path(&trait_bound.path, None),
 										Some(&trait_bound.path));
 								}
 							}
@@ -292,14 +291,13 @@ impl<'a, 'p: 'a> GenericTypes<'a, 'p> {
 					match bounds_iter.next().unwrap() {
 						syn::TypeParamBound::Trait(tr) => {
 							assert_simple_bound(&tr);
-							if let Some(mut path) = types.maybe_resolve_path(&tr.path, None) {
+							if let Some(path) = types.maybe_resolve_path(&tr.path, None) {
 								if types.skip_path(&path) { continue; }
 								// In general we handle Deref<Target=X> as if it were just X (and
 								// implement Deref<Target=Self> for relevant types). We don't
 								// bother to implement it for associated types, however, so we just
 								// ignore such bounds.
 								let new_ident = if path != "std::ops::Deref" && path != "core::ops::Deref" {
-									path = "crate::".to_string() + &path;
 									Some(&tr.path)
 								} else { None };
 								self.typed_generics.insert(&t.ident, (path, new_ident));
@@ -581,12 +579,12 @@ impl<'mod_lifetime, 'crate_lft: 'mod_lifetime> ImportResolver<'mod_lifetime, 'cr
 		} else { None }
 	}
 
-	pub fn maybe_resolve_path(&self, p_arg: &syn::Path, generics: Option<&GenericTypes>) -> Option<String> {
-		let p = if let Some(gen_types) = generics {
-			if let Some((_, synpath)) = gen_types.maybe_resolve_path(p_arg) {
-				synpath
-			} else { p_arg }
-		} else { p_arg };
+	pub fn maybe_resolve_path(&self, p: &syn::Path, generics: Option<&GenericTypes>) -> Option<String> {
+		if let Some(gen_types) = generics {
+			if let Some((resp, _)) = gen_types.maybe_resolve_path(p) {
+				return Some(resp.clone());
+			}
+		}
 
 		if p.leading_colon.is_some() {
 			let mut res: String = p.segments.iter().enumerate().map(|(idx, seg)| {
-- 
2.39.5