Represent type names with generic lifetime parameters

syntax/impls.rs

@@ -1,5 +1,5 @@
 use crate::syntax::{
-    Array, ExternFn, Impl, Include, Receiver, Ref, Signature, SliceRef, Ty1, Type, Var,
+    Array, ExternFn, Impl, Include, Lifetimes, Receiver, Ref, Signature, SliceRef, Ty1, Type, Var,
 };
 use std::borrow::Borrow;
 use std::hash::{Hash, Hasher};
@@ -81,6 +81,38 @@ impl PartialEq for Type {
     }
 }
 
+impl Eq for Lifetimes {}
+
+impl PartialEq for Lifetimes {
+    fn eq(&self, other: &Lifetimes) -> bool {
+        let Lifetimes {
+            lt_token: _,
+            lifetimes,
+            gt_token: _,
+        } = self;
+        let Lifetimes {
+            lt_token: _,
+            lifetimes: lifetimes2,
+            gt_token: _,
+        } = other;
+        lifetimes.iter().eq(lifetimes2)
+    }
+}
+
+impl Hash for Lifetimes {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        let Lifetimes {
+            lt_token: _,
+            lifetimes,
+            gt_token: _,
+        } = self;
+        lifetimes.len().hash(state);
+        for lifetime in lifetimes {
+            lifetime.hash(state);
+        }
+    }
+}
+
 impl Eq for Ty1 {}
 
 impl PartialEq for Ty1 {

syntax/mod.rs

@@ -254,8 +254,8 @@ pub struct Pair {
 
 // Wrapper for a type which needs to be resolved before it can be printed in
 // C++.
-#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[repr(transparent)]
+#[derive(PartialEq, Eq, Hash)]
 pub struct RustName {
     pub rust: Ident,
+    pub generics: Lifetimes,
 }

syntax/names.rs

@@ -1,6 +1,7 @@
-use crate::syntax::{Pair, RustName, Symbol, Types};
+use crate::syntax::{Lifetimes, Pair, RustName, Symbol, Types};
 use proc_macro2::{Ident, Span};
 use std::iter;
+use syn::punctuated::Punctuated;
 
 impl Pair {
     pub fn to_symbol(&self) -> Symbol {
@@ -23,11 +24,12 @@ impl Pair {
 
 impl RustName {
     pub fn new(rust: Ident) -> Self {
-        RustName { rust }
-    }
-
-    pub fn from_ref(rust: &Ident) -> &Self {
-        unsafe { &*(rust as *const Ident as *const Self) }
+        let generics = Lifetimes {
+            lt_token: None,
+            lifetimes: Punctuated::new(),
+            gt_token: None,
+        };
+        RustName { rust, generics }
     }
 
     pub fn span(&self) -> Span {

syntax/tokens.rs

@@ -256,7 +256,7 @@ impl ToTokens for Signature {
 
 impl ToTokens for RustName {
     fn to_tokens(&self, tokens: &mut TokenStream) {
-        let RustName { rust } = self;
+        let RustName { rust, generics: _ } = self;
         rust.to_tokens(tokens);
     }
 }

syntax/types.rs

@@ -19,7 +19,7 @@ pub struct Types<'a> {
     pub untrusted: Map<&'a Ident, &'a ExternType>,
     pub required_trivial: Map<&'a Ident, Vec<TrivialReason<'a>>>,
     pub explicit_impls: Set<&'a Impl>,
-    pub resolutions: Map<&'a RustName, &'a Pair>,
+    pub resolutions: Map<&'a Ident, &'a Pair>,
     pub struct_improper_ctypes: UnorderedSet<&'a Ident>,
     pub toposorted_structs: Vec<&'a Struct>,
 }
@@ -63,7 +63,7 @@ impl<'a> Types<'a> {
         }
 
         let mut add_resolution = |pair: &'a Pair| {
-            resolutions.insert(RustName::from_ref(&pair.rust), pair);
+            resolutions.insert(&pair.rust, pair);
         };
 
         let mut type_names = UnorderedSet::new();
@@ -238,7 +238,9 @@ impl<'a> Types<'a> {
     }
 
     pub fn resolve(&self, ident: &RustName) -> &Pair {
-        self.resolutions.get(ident).expect("Unable to resolve type")
+        self.resolutions
+            .get(&ident.rust)
+            .expect("Unable to resolve type")
     }
 }