Support arbitrary inner type in NamedImplKey.

Before this commit `NamedImplKey` could only represent the inner type as
`rust: &'a Ident`.  For example, it could represent `Vec<Foo>` but could
not represent `Vec<Box<Foo>>` where the inner type (`Box<Foo>` in our
example) is not a simple identifier.

After this commit `NamedImplKey` is refactored to support an arbitrary
inner type.  Note that (to simplify and to minimize risks associated
with this commit) this new ability is not actually used at this point -
it is planned to be used in follow-up commits to incrementally relax
generic type argument restrictions in `syntax/check.rs`.

This commit is quite big, but it seems difficult to extract some changes
to smaller, separate commits, because all of the changes stem from the
refactoring of the `NamedImplKey`.  At a high-level this commit contains
the following changes:

1. `syntax/instantiate.rs`: Changing `pub rust: &'a Ident` field of
   `NamedImplKey` to `pub inner: &'a Type`.  This is the main/root
   change in this commit.
2. `gen/src/write.rs`: supporting arbitrary inner types
   when writing C++ thunks exposing instantiations/monomorphizations of
   templates/generics supported by `cxx`.
    * This depends on `fn stringify_type` introduced in
      `gen/src/write.rs` in an earlier commit.
    * Handling arbitrary inner types *in general* means that we can
      delete `enum UniquePtr` which provided handling of two *specific*
      inner types.
3. `macro/src/expand.rs`: supporting arbitrary inner types
   when writing Rust thunks exposing instantiations/monomorphizations of
   templates/generics supported by `cxx`.
    * Using `#inner` instead of `#ident` may now (optionally) cover
      generic lifetime arguments.  This is why this commit also changes
      `macro/src/generics.rs`.  And this is why we can no longer need
      the `ty_generics` field from `struct Impl`.
    * One minor functional change here is changing the error messages
      so that references to type names are generated purely in the
      generated bindings, without depending on `fn display_namespaced`.
4. `syntax/mangle.rs`: supporting mangling of individual types.  This
   helps to:
    * Support the (long-term, not-yet-realized) high-level goal of
      actually allowing and using arbitrary inner types
    * Deduplicate mangling code details that were somewhat duplicated
      in `macro/src/expand.rs` and `gen/src/write.rs`.
5. `syntax/types.rs`: Supporting arbitrary inner types in
    * `fn is_maybe_trivial`
    * `fn is_local` (this function supports an earlier refactoring
      that changed how `cxx` decides whether to provide an *implicit*
      impl of a given generic/template instantiation/monomorphization)

Author: anforowicz

gen/src/write.rs

@@ -10,13 +10,12 @@ use crate::syntax::map::UnorderedMap as Map;
 use crate::syntax::namespace::Namespace;
 use crate::syntax::primitive::{self, PrimitiveKind};
 use crate::syntax::set::UnorderedSet;
-use crate::syntax::symbol::{self, Symbol};
+use crate::syntax::symbol::Symbol;
 use crate::syntax::trivial::{self, TrivialReason};
 use crate::syntax::{
     derive, mangle, Api, Doc, Enum, ExternFn, ExternType, FnKind, Lang, Pair, Signature, Struct,
     Trait, Type, TypeAlias, Types, Var,
 };
-use proc_macro2::Ident;
 
 pub(super) fn gen(apis: &[Api], types: &Types, opt: &Opt, header: bool) -> Vec<u8> {
     let mut out_file = OutFile::new(header, opt, types);
@@ -1573,57 +1572,6 @@ fn write_space_after_type_to_generic_writer(
     }
 }
 
-#[derive(Copy, Clone)]
-enum UniquePtr<'a> {
-    Ident(&'a Ident),
-    CxxVector(&'a Ident),
-}
-
-// TODO(@anforowicz): Replace `trait ToTypename` with `stringify_type`.
-trait ToTypename {
-    /// Formats `self` using C++ syntax.  For example, if `self` represents `UniquePtr<u32>`,
-    /// then it will be formatted as `::std::unique_ptr<uint32_t>`.
-    fn to_typename(&self, types: &Types) -> String;
-}
-
-impl ToTypename for Ident {
-    fn to_typename(&self, types: &Types) -> String {
-        types.resolve(self).name.to_fully_qualified()
-    }
-}
-
-impl<'a> ToTypename for UniquePtr<'a> {
-    fn to_typename(&self, types: &Types) -> String {
-        match self {
-            UniquePtr::Ident(ident) => ident.to_typename(types),
-            UniquePtr::CxxVector(element) => {
-                format!("::std::vector<{}>", element.to_typename(types))
-            }
-        }
-    }
-}
-
-trait ToMangled {
-    fn to_mangled(&self, types: &Types) -> Symbol;
-}
-
-impl ToMangled for Ident {
-    fn to_mangled(&self, types: &Types) -> Symbol {
-        types.resolve(self).name.to_symbol()
-    }
-}
-
-impl<'a> ToMangled for UniquePtr<'a> {
-    fn to_mangled(&self, types: &Types) -> Symbol {
-        match self {
-            UniquePtr::Ident(ident) => ident.to_mangled(types),
-            UniquePtr::CxxVector(element) => {
-                symbol::join(&[&"std", &"vector", &element.to_mangled(types)])
-            }
-        }
-    }
-}
-
 fn write_generic_instantiations(out: &mut OutFile) {
     if out.header {
         return;
@@ -1659,9 +1607,8 @@ fn write_generic_instantiations(out: &mut OutFile) {
 }
 
 fn write_rust_box_extern(out: &mut OutFile, key: &NamedImplKey) {
-    let resolve = out.types.resolve(key);
-    let inner = resolve.name.to_fully_qualified();
-    let instance = resolve.name.to_symbol();
+    let inner = stringify_type(key.inner, out.types);
+    let instance = &key.symbol;
 
     out.pragma.dollar_in_identifier = true;
 
@@ -1683,9 +1630,8 @@ fn write_rust_box_extern(out: &mut OutFile, key: &NamedImplKey) {
 }
 
 fn write_rust_vec_extern(out: &mut OutFile, key: &NamedImplKey) {
-    let element = key.rust;
-    let inner = element.to_typename(out.types);
-    let instance = element.to_mangled(out.types);
+    let inner = stringify_type(key.inner, out.types);
+    let instance = &key.symbol;
 
     out.include.cstddef = true;
     out.pragma.dollar_in_identifier = true;
@@ -1733,9 +1679,8 @@ fn write_rust_vec_extern(out: &mut OutFile, key: &NamedImplKey) {
 }
 
 fn write_rust_box_impl(out: &mut OutFile, key: &NamedImplKey) {
-    let resolve = out.types.resolve(key);
-    let inner = resolve.name.to_fully_qualified();
-    let instance = resolve.name.to_symbol();
+    let inner = stringify_type(key.inner, out.types);
+    let instance = &key.symbol;
 
     out.pragma.dollar_in_identifier = true;
 
@@ -1767,9 +1712,8 @@ fn write_rust_box_impl(out: &mut OutFile, key: &NamedImplKey) {
 }
 
 fn write_rust_vec_impl(out: &mut OutFile, key: &NamedImplKey) {
-    let element = key.rust;
-    let inner = element.to_typename(out.types);
-    let instance = element.to_mangled(out.types);
+    let inner = stringify_type(key.inner, out.types);
+    let instance = &key.symbol;
 
     out.include.cstddef = true;
     out.pragma.dollar_in_identifier = true;
@@ -1856,28 +1800,25 @@ fn write_rust_vec_impl(out: &mut OutFile, key: &NamedImplKey) {
 }
 
 fn write_unique_ptr(out: &mut OutFile, key: &NamedImplKey) {
-    let ty = UniquePtr::Ident(key.rust);
-    write_unique_ptr_common(out, ty);
+    write_unique_ptr_common(out, key.inner);
 }
 
 // Shared by UniquePtr<T> and UniquePtr<CxxVector<T>>.
-fn write_unique_ptr_common(out: &mut OutFile, ty: UniquePtr) {
+fn write_unique_ptr_common(out: &mut OutFile, ty: &Type) {
     out.include.new = true;
     out.include.utility = true;
     out.pragma.dollar_in_identifier = true;
     out.pragma.missing_declarations = true;
 
-    let inner = ty.to_typename(out.types);
-    let instance = ty.to_mangled(out.types);
+    let inner = stringify_type(ty, out.types);
+    let instance = crate::syntax::mangle::type_(ty)
+        .expect("Earlier syntax/check.rs checks should filter out non-mangle-able types");
 
-    let can_construct_from_value = match ty {
-        // Some aliases are to opaque types; some are to trivial types. We can't
-        // know at code generation time, so we generate both C++ and Rust side
-        // bindings for a "new" method anyway. But the Rust code can't be called
-        // for Opaque types because the 'new' method is not implemented.
-        UniquePtr::Ident(ident) => out.types.is_maybe_trivial(ident),
-        UniquePtr::CxxVector(_) => false,
-    };
+    // Some aliases are to opaque types; some are to trivial types. We can't
+    // know at code generation time, so we generate both C++ and Rust side
+    // bindings for a "new" method anyway. But the Rust code can't be called
+    // for Opaque types because the 'new' method is not implemented.
+    let can_construct_from_value = out.types.is_maybe_trivial(ty);
 
     out.builtin.is_complete = true;
     writeln!(
@@ -1966,10 +1907,8 @@ fn write_unique_ptr_common(out: &mut OutFile, ty: UniquePtr) {
 }
 
 fn write_shared_ptr(out: &mut OutFile, key: &NamedImplKey) {
-    let ident = key.rust;
-    let resolve = out.types.resolve(ident);
-    let inner = resolve.name.to_fully_qualified();
-    let instance = resolve.name.to_symbol();
+    let inner = stringify_type(key.inner, out.types);
+    let instance = &key.symbol;
 
     out.include.new = true;
     out.include.utility = true;
@@ -1980,7 +1919,7 @@ fn write_shared_ptr(out: &mut OutFile, key: &NamedImplKey) {
     // know at code generation time, so we generate both C++ and Rust side
     // bindings for a "new" method anyway. But the Rust code can't be called for
     // Opaque types because the 'new' method is not implemented.
-    let can_construct_from_value = out.types.is_maybe_trivial(ident);
+    let can_construct_from_value = out.types.is_maybe_trivial(key.inner);
 
     writeln!(
         out,
@@ -2064,9 +2003,8 @@ fn write_shared_ptr(out: &mut OutFile, key: &NamedImplKey) {
 }
 
 fn write_weak_ptr(out: &mut OutFile, key: &NamedImplKey) {
-    let resolve = out.types.resolve(key);
-    let inner = resolve.name.to_fully_qualified();
-    let instance = resolve.name.to_symbol();
+    let inner = stringify_type(key.inner, out.types);
+    let instance = &key.symbol;
 
     out.include.new = true;
     out.include.utility = true;
@@ -2135,9 +2073,8 @@ fn write_weak_ptr(out: &mut OutFile, key: &NamedImplKey) {
 }
 
 fn write_cxx_vector(out: &mut OutFile, key: &NamedImplKey) {
-    let element = key.rust;
-    let inner = element.to_typename(out.types);
-    let instance = element.to_mangled(out.types);
+    let inner = stringify_type(key.inner, out.types);
+    let instance = &key.symbol;
 
     out.include.cstddef = true;
     out.include.utility = true;
@@ -2195,7 +2132,7 @@ fn write_cxx_vector(out: &mut OutFile, key: &NamedImplKey) {
     );
     writeln!(out, "}}");
 
-    if out.types.is_maybe_trivial(element) {
+    if out.types.is_maybe_trivial(key.inner) {
         begin_function_definition(out);
         writeln!(
             out,
@@ -2218,5 +2155,5 @@ fn write_cxx_vector(out: &mut OutFile, key: &NamedImplKey) {
     }
 
     out.include.memory = true;
-    write_unique_ptr_common(out, UniquePtr::CxxVector(element));
+    write_unique_ptr_common(out, key.outer);
 }