Generate bindings to trait implementations of C++ types.

Previously, we needlessly excluded these implementations that referenced
a type with a `cpp_type` annotation due to the `adt_needs_bindings`
check. This adds a specific carve out for that when considering
implementations.

PiperOrigin-RevId: 885623459

Author: thunderseethe

cc_bindings_from_rs/generate_bindings/lib.rs

@@ -935,7 +935,7 @@ fn generate_trait<'tcx>(
         (quote! { template <#(#template_params),*> }, quote! { #trait_name<#(#template_args),*> })
     };
 
-    let main_api = CcSnippet::with_include(
+    let mut main_api = CcSnippet::with_include(
         quote! {
             __NEWLINE__ #doc_comment
             #template_prefix
@@ -947,6 +947,7 @@ fn generate_trait<'tcx>(
         },
         db.support_header("rs_std/traits.h"),
     );
+    main_api.prereqs.includes.insert(db.support_header("annotations_internal.h"));
     Ok(ApiSnippets { main_api, ..Default::default() })
 }
 
@@ -1673,7 +1674,11 @@ fn generate_trait_impls<'a, 'tcx>(
                 .filter_map(move |(simple_ty, impl_def_ids)| match simple_ty {
                     SimplifiedType::Adt(did) => {
                         // Only bind implementations for supported ADTs.
-                        if db.adt_needs_bindings(*did).is_err() {
+                        let canonical_name = db.symbol_canonical_name(*did)?;
+                        // We explicitly want to allow ADTs that specify cpp_type.
+                        // These are typically C++ types that have generated Rust bindings.
+                        if canonical_name.unqualified.cpp_type.is_none()
+                            && db.adt_needs_bindings(*did).is_err() {
                             return None;
                         }
                         let crate_name = tcx.crate_name(did.krate);
@@ -1682,7 +1687,7 @@ fn generate_trait_impls<'a, 'tcx>(
                         if ["std", "core", "alloc"].contains(&crate_name.as_str()) {
                             return None;
                         }
-                        let adt_cc_name = db.symbol_canonical_name(*did)?.format_for_cc(db).ok()?;
+                        let adt_cc_name = canonical_name.format_for_cc(db).ok()?;
                         Some((adt_cc_name, trait_def_id, impl_def_ids))
                     }
                     // TODO: b/457803426 - Support trait implementations for non-adt types.

cc_bindings_from_rs/test/traits/for_cc_type/BUILD

@@ -0,0 +1,59 @@
+load(
+    "@rules_cc//cc:cc_library.bzl",
+    "cc_library",
+)
+load(
+    "@rules_rust//rust:defs.bzl",
+    "rust_library",
+)
+load(
+    "//cc_bindings_from_rs/bazel_support:cc_bindings_from_rust_rule.bzl",
+    "cc_bindings_from_rust",
+)
+load(
+    "//cc_bindings_from_rs/test/golden:golden_test.bzl",
+    "golden_test",
+)
+load(
+    "//common:crubit_wrapper_macros_oss.bzl",
+    "crubit_cc_test",
+)
+
+package(default_applicable_licenses = ["//:license"])
+
+cc_library(
+    name = "cc_type",
+    hdrs = ["cc_type.h"],
+    aspect_hints = ["//features:supported"],
+)
+
+rust_library(
+    name = "trait",
+    testonly = 1,
+    srcs = ["trait.rs"],
+    cc_deps = [":cc_type"],
+)
+
+cc_bindings_from_rust(
+    name = "trait_cc_api",
+    testonly = 1,
+    crate = ":trait",
+)
+
+golden_test(
+    name = "trait_golden_test",
+    basename = "trait",
+    golden_h = "trait_cc_api.h",
+    golden_rs = "trait_cc_api_impl.rs",
+    rust_library = "trait",
+)
+
+crubit_cc_test(
+    name = "trait_test",
+    srcs = ["trait_test.cc"],
+    deps = [
+        ":cc_type",
+        ":trait_cc_api",
+        "//testing/base/public:gunit_main",
+    ],
+)

cc_bindings_from_rs/test/traits/for_cc_type/cc_type.h

@@ -0,0 +1,11 @@
+// Part of the Crubit project, under the Apache License v2.0 with LLVM
+// Exceptions. See /LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+#ifndef THIRD_PARTY_CRUBIT_CC_BINDINGS_FROM_RS_TEST_TRAITS_FOR_CC_TYPE_CC_TYPE_H_
+#define THIRD_PARTY_CRUBIT_CC_BINDINGS_FROM_RS_TEST_TRAITS_FOR_CC_TYPE_CC_TYPE_H_
+
+struct CcType {
+  int value;
+};
+
+#endif  // THIRD_PARTY_CRUBIT_CC_BINDINGS_FROM_RS_TEST_TRAITS_FOR_CC_TYPE_CC_TYPE_H_

cc_bindings_from_rs/test/traits/for_cc_type/trait.rs

@@ -0,0 +1,13 @@
+// Part of the Crubit project, under the Apache License v2.0 with LLVM
+// Exceptions. See /LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+pub trait Trait {
+    fn get_value(&self) -> i32;
+}
+
+impl Trait for cc_type::CcType {
+    fn get_value(&self) -> i32 {
+        self.value
+    }
+}

cc_bindings_from_rs/test/traits/for_cc_type/trait_cc_api.h

@@ -0,0 +1,55 @@
+// Part of the Crubit project, under the Apache License v2.0 with LLVM
+// Exceptions. See /LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// Automatically @generated C++ bindings for the following Rust crate:
+// trait_golden
+// Features: supported, types
+
+// clang-format off
+#ifndef THIRD_PARTY_CRUBIT_CC_BINDINGS_FROM_RS_TEST_TRAITS_FOR_CC_TYPE_TRAIT_GOLDEN
+#define THIRD_PARTY_CRUBIT_CC_BINDINGS_FROM_RS_TEST_TRAITS_FOR_CC_TYPE_TRAIT_GOLDEN
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wreturn-type-c-linkage"
+#pragma clang diagnostic ignored "-Wunused-private-field"
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+#include "support/annotations_internal.h"
+#include "support/rs_std/traits.h"
+
+#include <cstdint>
+
+#include "cc_bindings_from_rs/test/traits/for_cc_type/cc_type.h"
+
+namespace trait {
+
+// Generated from:
+// cc_bindings_from_rs/test/traits/for_cc_type/trait.rs;l=5
+struct CRUBIT_INTERNAL_RUST_TYPE(":: trait_golden :: Trait") Trait {
+  template <typename T>
+  using impl = rs_std::impl<T, Trait>;
+};
+
+}  // namespace trait
+
+template <>
+struct rs_std::impl<CcType, ::trait::Trait> {
+  static constexpr bool kIsImplemented = true;
+
+  // Generated from:
+  // cc_bindings_from_rs/test/traits/for_cc_type/trait.rs;l=10
+  static std::int32_t get_value(CcType const& self);
+};
+
+namespace trait {
+namespace __crubit_internal {
+extern "C" std::int32_t __crubit_thunk_Trait_uget_uvalue(CcType const&);
+}
+}  // namespace trait
+inline std::int32_t rs_std::impl<CcType, ::trait::Trait>::get_value(
+    CcType const& self) {
+  return trait::__crubit_internal::__crubit_thunk_Trait_uget_uvalue(self);
+}
+
+#pragma clang diagnostic pop
+#endif  // THIRD_PARTY_CRUBIT_CC_BINDINGS_FROM_RS_TEST_TRAITS_FOR_CC_TYPE_TRAIT_GOLDEN

cc_bindings_from_rs/test/traits/for_cc_type/trait_cc_api_impl.rs

@@ -0,0 +1,18 @@
+// Part of the Crubit project, under the Apache License v2.0 with LLVM
+// Exceptions. See /LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// Automatically @generated C++ bindings for the following Rust crate:
+// trait_golden
+// Features: supported, types
+
+#![allow(unused_unsafe, deprecated, non_snake_case, unreachable_code)]
+#![allow(improper_ctypes_definitions)]
+#![deny(warnings)]
+
+extern crate alloc;
+extern crate core;
+#[unsafe(no_mangle)]
+unsafe extern "C" fn __crubit_thunk_Trait_uget_uvalue(__self: &'static ::cc_type::CcType) -> i32 {
+    unsafe { <::cc_type::CcType as ::trait_golden::Trait>::get_value(__self) }
+}

cc_bindings_from_rs/test/traits/for_cc_type/trait_test.cc

@@ -0,0 +1,19 @@
+// Part of the Crubit project, under the Apache License v2.0 with LLVM
+// Exceptions. See /LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include "cc_bindings_from_rs/test/traits/for_cc_type/trait.h"
+
+#include "gtest/gtest.h"
+#include "cc_bindings_from_rs/test/traits/for_cc_type/cc_type.h"
+
+namespace crubit {
+namespace {
+
+TEST(ForCcTypeTraitTest, CcTypeImpl) {
+  CcType cc_val = {123};
+  EXPECT_EQ(trait::Trait::impl<CcType>::get_value(cc_val), 123);
+}
+
+}  // namespace
+}  // namespace crubit