Touch up PR 1681

Author: dtolnay

macro/src/generics.rs

@@ -3,7 +3,7 @@ use crate::syntax::instantiate::NamedImplKey;
 use crate::syntax::types::ConditionalImpl;
 use crate::syntax::{Lifetimes, Type, Types};
 use proc_macro2::TokenStream;
-use quote::{quote_spanned, ToTokens};
+use quote::{quote, ToTokens};
 use syn::{Lifetime, Token};
 
 pub(crate) struct ResolvedGenericType<'a> {
@@ -62,13 +62,12 @@ impl<'a> ToTokens for ResolvedGenericType<'a> {
                 }
             }
             Type::RustBox(ty1) => {
-                let span = ty1.name.span();
                 let inner = ResolvedGenericType {
                     ty: &ty1.inner,
                     explicit_impl: self.explicit_impl,
                     types: self.types,
                 };
-                tokens.extend(quote_spanned! {span=>
+                tokens.extend(quote! {
                     ::cxx::alloc::boxed::Box<#inner>
                 });
             }
@@ -77,7 +76,7 @@ impl<'a> ToTokens for ResolvedGenericType<'a> {
     }
 }
 
-fn get_impl_generics<'a>(ty: &Type, types: &'a Types<'a>) -> &'a Lifetimes {
+fn get_impl_generics<'a>(ty: &Type, types: &Types<'a>) -> &'a Lifetimes {
     match ty {
         Type::Ident(named_type) => types.resolve(named_type).generics,
         Type::RustBox(ty1) => get_impl_generics(&ty1.inner, types),
@@ -88,16 +87,14 @@ fn get_impl_generics<'a>(ty: &Type, types: &'a Types<'a>) -> &'a Lifetimes {
 pub(crate) fn format_for_prevent_unwind_label(ty: &Type) -> TokenStream {
     match ty {
         Type::Ident(named_type) => {
-            let span = named_type.rust.span();
             let rust_name = named_type.rust.to_string();
-            quote_spanned! {span=>
+            quote! {
                 ::cxx::core::concat!(::cxx::core::module_path!(), "::", #rust_name)
             }
         }
         Type::RustBox(ty1) => {
-            let span = ty1.name.span();
             let inner = format_for_prevent_unwind_label(&ty1.inner);
-            quote_spanned! {span=>
+            quote! {
                 ::cxx::core::concat!("Box<", #inner, ">")
             }
         }

macro/src/tests.rs

@@ -168,14 +168,14 @@ fn test_vec_of_box() {
             }
         }
     });
+
     assert!(rs.contains("unsafe impl ::cxx::private::ImplBox for R {}"));
     assert!(rs.contains("export_name = \"cxxbridge1$box$R$drop\""));
 
-    assert!(rs.contains("unsafe impl ::cxx::private::ImplVec for ::cxx::alloc::boxed::Box<R> {}"),);
+    assert!(rs.contains("unsafe impl ::cxx::private::ImplVec for ::cxx::alloc::boxed::Box<R> {}"));
     assert!(rs.contains("export_name = \"cxxbridge1$rust_vec$box$R$set_len\""));
 
-    // Covering these lines, because an early WIP incorrectly said
-    // `RustVec<*mut R>` instead of `RustVec<Box<R>>` in *some* of these lines.
+    // Not supposed to be `RustVec<*mut R>` (which happened in an early draft).
     assert!(rs.contains("__return: *mut ::cxx::private::RustVec<::cxx::alloc::boxed::Box<R>>"));
     assert!(rs.contains("fn __foo() -> ::cxx::alloc::vec::Vec<::cxx::alloc::boxed::Box<R>>"));
 }

syntax/types.rs

@@ -338,8 +338,8 @@ impl<'a> Types<'a> {
                     || self.aliases.contains_key(ident)
             }
             Type::CxxVector(_) => false,
-            // Note: `Type::RustBox(_)` cannot be used as an inner type of
-            // `CxxVector`, `UniquePtr`, nor `SharedPtr`.
+            // No other type can appear as the inner type of CxxVector,
+            // UniquePtr, or SharedPtr.
             _ => unreachable!("syntax/check.rs should reject other types"),
         }
     }
@@ -374,9 +374,9 @@ impl<'a> Types<'a> {
                 Atom::from(&ident.rust).is_none() && !self.aliases.contains_key(&ident.rust)
             }
             Type::RustBox(ty1) => {
-                // From Rust reference [1]: "Any time a type T is considered local [...]
-                // Box<T> [... is] also considered local."
-                // [1] https://doc.rust-lang.org/reference/glossary.html#fundamental-type-constructors
+                // https://doc.rust-lang.org/reference/glossary.html#fundamental-type-constructors
+                // "Any time a type T is considered local [...] Box<T> [... is]
+                // also considered local."
                 self.is_local(&ty1.inner)
             }
             Type::Array(_)