Extract is_implicit_impl_ok from Types::collect into a method of ImplKey.

Author: anforowicz

syntax/instantiate.rs

@@ -1,3 +1,4 @@
+use crate::syntax::types::Types;
 use crate::syntax::{NamedType, Ty1, Type};
 use proc_macro2::{Ident, Span};
 use std::hash::{Hash, Hasher};
@@ -13,6 +14,36 @@ pub(crate) enum ImplKey<'a> {
     CxxVector(NamedImplKey<'a>),
 }
 
+impl<'a> ImplKey<'a> {
+    /// Whether to generate an implicit instantiation/monomorphization of a given generic type
+    /// binding.  ("implicit" = without an explicit `impl Foo<T> {}` - see
+    /// <https://cxx.rs/extern-c++.html?highlight=explicit#explicit-shim-trait-impls>).
+    ///
+    /// The main consideration is avoiding introducing conflicting/overlapping impls:
+    ///
+    /// * The `cxx` crate already provides impls for cases where `T` is a primitive
+    ///   type like `u32`
+    /// * Some generics (e.g. Rust bindings for C++ templates like `CxxVector<T>`, `UniquePtr<T>`,
+    ///   etc.) require an `impl` of a `trait` provided by the `cxx` crate (such as
+    ///   [`cxx::vector::VectorElement`] or [`cxx::memory::UniquePtrTarget`]).  To avoid violating
+    ///   [Rust orphan rule](https://doc.rust-lang.org/reference/items/implementations.html#r-items.impl.trait.orphan-rule.intro)
+    ///   we restrict `T` to be a local type
+    ///   (TODO: or a fundamental type like `Box<LocalType>`).
+    /// * Other generics (e.g. C++ bindings for Rust generics like `Vec<T>` or `Box<T>`)
+    ///   don't necessarily need to follow the orphan rule, but we conservatively also
+    ///   only generate implicit impls if `T` is a local type.  TODO: revisit?
+    pub(crate) fn is_implicit_impl_ok(&self, types: &Types) -> bool {
+        match self {
+            ImplKey::RustBox(ident)
+            | ImplKey::RustVec(ident)
+            | ImplKey::UniquePtr(ident)
+            | ImplKey::SharedPtr(ident)
+            | ImplKey::WeakPtr(ident)
+            | ImplKey::CxxVector(ident) => types.is_local(ident.rust),
+        }
+    }
+}
+
 pub(crate) struct NamedImplKey<'a> {
     #[cfg_attr(not(proc_macro), expect(dead_code))]
     pub begin_span: Span,

syntax/map.rs

@@ -27,6 +27,10 @@ mod ordered {
         {
             self.0.contains_key(key)
         }
+
+        pub(crate) fn iter<'a>(&'a self) -> impl Iterator<Item = (&'a K, &'a V)> {
+            self.0.iter()
+        }
     }
 
     impl<K, V> OrderedMap<K, V>

syntax/types.rs

@@ -216,30 +216,6 @@ impl<'a> Types<'a> {
             }
         }
 
-        for (ty, cfg) in &all {
-            let Some(impl_key) = ty.impl_key() else {
-                continue;
-            };
-            let implicit_impl = match &impl_key {
-                ImplKey::RustBox(ident)
-                | ImplKey::RustVec(ident)
-                | ImplKey::UniquePtr(ident)
-                | ImplKey::SharedPtr(ident)
-                | ImplKey::WeakPtr(ident)
-                | ImplKey::CxxVector(ident) => {
-                    Atom::from(ident.rust).is_none() && !aliases.contains_key(ident.rust)
-                }
-            };
-            if implicit_impl {
-                match impls.entry(impl_key) {
-                    Entry::Vacant(entry) => {
-                        entry.insert(ConditionalImpl::from(cfg.clone()));
-                    }
-                    Entry::Occupied(mut entry) => entry.get_mut().cfg.merge_or(cfg.clone()),
-                }
-            }
-        }
-
         // All these APIs may contain types passed by value. We need to ensure
         // we check that this is permissible. We do this _after_ scanning all
         // the APIs above, in case some function or struct references a type
@@ -269,6 +245,21 @@ impl<'a> Types<'a> {
 
         types.toposorted_structs = toposort::sort(cx, apis, &types);
 
+        let implicit_impls = types
+            .all
+            .iter()
+            .filter_map(|(ty, cfg)| Type::impl_key(ty).map(|impl_key| (impl_key, cfg)))
+            .filter(|(impl_key, _cfg)| impl_key.is_implicit_impl_ok(&types))
+            .collect::<Vec<_>>();
+        for (impl_key, cfg) in implicit_impls {
+            match types.impls.entry(impl_key) {
+                Entry::Vacant(entry) => {
+                    entry.insert(ConditionalImpl::from(cfg.clone()));
+                }
+                Entry::Occupied(mut entry) => entry.get_mut().cfg.merge_or(cfg.clone()),
+            }
+        }
+
         let mut unresolved_structs = types.structs.keys();
         let mut new_information = true;
         while new_information {
@@ -353,6 +344,11 @@ impl<'a> Types<'a> {
             Type::Fn(_) | Type::Void(_) => false,
         }
     }
+
+    /// Returns `true` if `ident` is defined or declared within the current `#[cxx::bridge]`.
+    pub(crate) fn is_local(&self, ident: &Ident) -> bool {
+        Atom::from(ident).is_none() && !self.aliases.contains_key(ident)
+    }
 }
 
 impl<'t, 'a> IntoIterator for &'t Types<'a> {