rs_bindings_from_cc: graduate [[deprecated]] and [[nodiscard]] to supported.

Note that we do not currently do anything with [[deprecated]] as applied
to bitfields, we still do not support binding class templates, and we do
nothing special with existing Rust types. Rust does not allow us to mark particular trait methods in impl blocks as #[deprecated] or #[must_use]; we will still create bindings for these, but they will not be marked. For example, a [[deprecated]] copy constructor may be projected into Rust without a deprecation tag.

We will remove the _experimental variants of the golden tests for
deprecated/nodiscard in a followup change.

PiperOrigin-RevId: 901020946

Author: zrlk

bazel/llvm.bzl

@@ -53,7 +53,7 @@ def _llvm_loader_repository(repository_ctx):
             executable = False,
         )
 
-LLVM_COMMIT_SHA = "815edc3ff646392bfee2b381d37dd35e4b04f9c5"
+LLVM_COMMIT_SHA = "2cf353b5e8560723409f3f9164bddec76f499963"
 
 def llvm_loader_repository_dependencies():
     # This *declares* the dependency, but it won't actually be *downloaded* unless it's used.

rs_bindings_from_cc/generate_bindings/database/code_snippet.rs

@@ -216,24 +216,8 @@ pub fn required_crubit_features(
         );
     }
     match item {
-        Item::Constant(c) => {
-            if c.deprecated.is_some() {
-                require_any_feature(
-                    &mut missing_features,
-                    crubit_feature::CrubitFeature::Experimental.into(),
-                    &|| "[[deprecated]] attribute".into(),
-                );
-            }
-        }
-        Item::GlobalVar(g) => {
-            if g.deprecated.is_some() {
-                require_any_feature(
-                    &mut missing_features,
-                    crubit_feature::CrubitFeature::Experimental.into(),
-                    &|| "[[deprecated]] attribute".into(),
-                );
-            }
-        }
+        Item::Constant(_) => {}
+        Item::GlobalVar(_) => {}
         Item::Comment { .. } | Item::UnsupportedItem(..) | Item::UseMod { .. } => {}
 
         Item::Func(func) => {
@@ -278,20 +262,6 @@ pub fn required_crubit_features(
                         &|| "[[noreturn]] attribute".into(),
                     );
                 }
-                if func.nodiscard.is_some() {
-                    require_any_feature(
-                        &mut missing_features,
-                        crubit_feature::CrubitFeature::Experimental.into(),
-                        &|| "[[nodiscard]] attribute".into(),
-                    );
-                }
-                if func.deprecated.is_some() {
-                    require_any_feature(
-                        &mut missing_features,
-                        crubit_feature::CrubitFeature::Experimental.into(),
-                        &|| "[[deprecated]] attribute".into(),
-                    );
-                }
                 for param in &func.params {
                     if let Some(unknown_attr) = &param.unknown_attr {
                         require_any_feature(
@@ -324,39 +294,8 @@ pub fn required_crubit_features(
                 )?,
                 &|| "".into(),
             );
-            let deprecated = match item {
-                Item::Record(r) => r.deprecated.clone(),
-                Item::TypeAlias(t) => t.deprecated.clone(),
-                Item::Enum(e) => {
-                    if e.nodiscard.is_some() {
-                        require_any_feature(
-                            &mut missing_features,
-                            crubit_feature::CrubitFeature::Experimental.into(),
-                            &|| "[[nodiscard]] attribute".into(),
-                        );
-                    };
-                    e.deprecated.clone()
-                }
-                Item::ExistingRustType(_) => None,
-                _ => unreachable!(),
-            };
-            if deprecated.is_some() {
-                require_any_feature(
-                    &mut missing_features,
-                    crubit_feature::CrubitFeature::Experimental.into(),
-                    &|| "[[deprecated]] attribute".into(),
-                );
-            }
-        }
-        Item::Namespace(n) => {
-            if n.deprecated.is_some() {
-                require_any_feature(
-                    &mut missing_features,
-                    crubit_feature::CrubitFeature::Experimental.into(),
-                    &|| "[[deprecated]] attribute".into(),
-                );
-            }
         }
+        Item::Namespace(_) => {}
         Item::IncompleteRecord(_) => {
             require_any_feature(
                 &mut missing_features,

rs_bindings_from_cc/generate_bindings/generate_enum.rs

@@ -42,16 +42,6 @@ pub fn generate_enum(db: &BindingsGenerator, enum_: Rc<Enum>) -> Result<ApiSnipp
                     __COMMENT__ #comment
                 }
             };
-            if enumerator.deprecated.is_some()
-                && !db
-                    .ir()
-                    .target_crubit_features(&enum_.owning_target)
-                    .contains(CrubitFeature::Experimental)
-            {
-                return omitting_bindings_comment(format!(
-                    "marked as deprecated; requires experimental"
-                ));
-            }
             if let Some(unknown_attr) = &enumerator.unknown_attr {
                 return omitting_bindings_comment(format!("unknown attribute(s): {unknown_attr}"));
             }

rs_bindings_from_cc/generate_bindings/generate_struct_and_union.rs

@@ -128,17 +128,6 @@ fn get_field_rs_type_kind_for_layout(
             }
         }
     }
-    if field.deprecated.is_some() {
-        for target in
-            db.defining_target(record.id()).as_ref().into_iter().chain([&record.owning_target])
-        {
-            let enabled_features = ir.target_crubit_features(target);
-            ensure!(
-                enabled_features.contains(crubit_feature::CrubitFeature::Experimental),
-                "field is marked as deprecated; requires experimental features on {target}"
-            );
-        }
-    }
     let type_kind = db.rs_type_kind(field.type_.clone())?;
 
     if let RsTypeKind::Error { error, .. } = type_kind {
@@ -311,18 +300,7 @@ fn field_definition(
         });
     };
 
-    let mut deprecated_attr: Option<DeprecatedAttr> = None;
-    if let Some(deprecated) = &field.deprecated {
-        for target in
-            db.defining_target(record.id()).as_ref().into_iter().chain([&record.owning_target])
-        {
-            let enabled_features = db.ir().target_crubit_features(target);
-            if enabled_features.contains(crubit_feature::CrubitFeature::Experimental) {
-                deprecated_attr = Some(DeprecatedAttr(deprecated.clone()));
-                break;
-            }
-        }
-    };
+    let deprecated_attr = field.deprecated.clone().map(DeprecatedAttr);
     let ident = make_rs_field_ident(field, field_index);
     let field_rs_type_kind = get_field_rs_type_kind_for_layout(db, record, field);
     let doc_comment = match &field_rs_type_kind {

rs_bindings_from_cc/test/golden/deprecated_rs_api.rs

@@ -14,31 +14,121 @@
 #![allow(deprecated)]
 #![deny(warnings)]
 
-// error: function `deprecated_function` could not be bound
-//   [[deprecated]] attribute
+#[deprecated]
+#[inline(always)]
+pub fn deprecated_function() {
+    unsafe { crate::detail::__rust_thunk___Z19deprecated_functionv() }
+}
+
+#[deprecated = "old"]
+#[inline(always)]
+pub fn deprecated_function_with_message() {
+    unsafe { crate::detail::__rust_thunk___Z32deprecated_function_with_messagev() }
+}
+
+#[derive(Clone, Copy, ::ctor::MoveAndAssignViaCopy)]
+#[deprecated]
+#[repr(C)]
+///CRUBIT_ANNOTATE: cpp_type=DeprecatedStruct
+pub struct DeprecatedStruct {
+    __non_field_data: [::core::mem::MaybeUninit<u8>; 1],
+}
+impl !Send for DeprecatedStruct {}
+impl !Sync for DeprecatedStruct {}
+unsafe impl ::cxx::ExternType for DeprecatedStruct {
+    type Id = ::cxx::type_id!("DeprecatedStruct");
+    type Kind = ::cxx::kind::Trivial;
+}
 
-// error: function `deprecated_function_with_message` could not be bound
-//   [[deprecated]] attribute
+impl Default for DeprecatedStruct {
+    #[inline(always)]
+    fn default() -> Self {
+        let mut tmp = ::core::mem::MaybeUninit::<Self>::zeroed();
+        unsafe {
+            crate::detail::__rust_thunk___ZN16DeprecatedStructC1Ev(&raw mut tmp as *mut _);
+            tmp.assume_init()
+        }
+    }
+}
 
-// error: struct `DeprecatedStruct` could not be bound
-//   [[deprecated]] attribute
+#[derive(Clone, Copy, ::ctor::MoveAndAssignViaCopy)]
+#[deprecated = "old"]
+#[repr(C)]
+///CRUBIT_ANNOTATE: cpp_type=DeprecatedStructWithMessage
+pub struct DeprecatedStructWithMessage {
+    __non_field_data: [::core::mem::MaybeUninit<u8>; 1],
+}
+impl !Send for DeprecatedStructWithMessage {}
+impl !Sync for DeprecatedStructWithMessage {}
+unsafe impl ::cxx::ExternType for DeprecatedStructWithMessage {
+    type Id = ::cxx::type_id!("DeprecatedStructWithMessage");
+    type Kind = ::cxx::kind::Trivial;
+}
 
-// error: struct `DeprecatedStructWithMessage` could not be bound
-//   [[deprecated]] attribute
+impl Default for DeprecatedStructWithMessage {
+    #[inline(always)]
+    fn default() -> Self {
+        let mut tmp = ::core::mem::MaybeUninit::<Self>::zeroed();
+        unsafe {
+            crate::detail::__rust_thunk___ZN27DeprecatedStructWithMessageC1Ev(
+                &raw mut tmp as *mut _,
+            );
+            tmp.assume_init()
+        }
+    }
+}
 
-// error: enum `DeprecatedEnum` could not be bound
-//   [[deprecated]] attribute
+#[repr(transparent)]
+#[derive(Debug, PartialEq, Eq, Copy, Clone, Hash, PartialOrd, Ord)]
+#[deprecated]
+///CRUBIT_ANNOTATE: cpp_type=DeprecatedEnum
+pub struct DeprecatedEnum(::ffi_11::c_uint);
+impl DeprecatedEnum {}
+impl From<::ffi_11::c_uint> for DeprecatedEnum {
+    fn from(value: ::ffi_11::c_uint) -> DeprecatedEnum {
+        DeprecatedEnum(value)
+    }
+}
+impl From<DeprecatedEnum> for ::ffi_11::c_uint {
+    fn from(value: DeprecatedEnum) -> ::ffi_11::c_uint {
+        value.0
+    }
+}
 
-// error: enum `DeprecatedEnumWithMessage` could not be bound
-//   [[deprecated]] attribute
+#[repr(transparent)]
+#[derive(Debug, PartialEq, Eq, Copy, Clone, Hash, PartialOrd, Ord)]
+#[deprecated = "old"]
+///CRUBIT_ANNOTATE: cpp_type=DeprecatedEnumWithMessage
+pub struct DeprecatedEnumWithMessage(::ffi_11::c_uint);
+impl DeprecatedEnumWithMessage {}
+impl From<::ffi_11::c_uint> for DeprecatedEnumWithMessage {
+    fn from(value: ::ffi_11::c_uint) -> DeprecatedEnumWithMessage {
+        DeprecatedEnumWithMessage(value)
+    }
+}
+impl From<DeprecatedEnumWithMessage> for ::ffi_11::c_uint {
+    fn from(value: DeprecatedEnumWithMessage) -> ::ffi_11::c_uint {
+        value.0
+    }
+}
 
-// error: namespace `DeprecatedNamespace` could not be bound
-//   [[deprecated]] attribute
+#[deprecated]
+pub mod DeprecatedNamespace {
+    #[inline(always)]
+    pub fn f() {
+        unsafe { crate::detail::__rust_thunk___ZN19DeprecatedNamespace1fEv() }
+    }
+}
 
 // namespace DeprecatedNamespace
 
-// error: namespace `DeprecatedNamespaceWithMessage` could not be bound
-//   [[deprecated]] attribute
+#[deprecated = "old"]
+pub mod DeprecatedNamespaceWithMessage {
+    #[inline(always)]
+    pub fn f() {
+        unsafe { crate::detail::__rust_thunk___ZN30DeprecatedNamespaceWithMessage1fEv() }
+    }
+}
 
 // namespace DeprecatedNamespaceWithMessage
 
@@ -47,10 +137,12 @@
 ///CRUBIT_ANNOTATE: cpp_type=DeprecatedEnumerators
 pub struct DeprecatedEnumerators(::ffi_11::c_uint);
 impl DeprecatedEnumerators {
-    // Omitting bindings for kDeprecatedEnumerator
-    // reason: marked as deprecated; requires experimental
-    // Omitting bindings for kDeprecatedEnumeratorWithMessage
-    // reason: marked as deprecated; requires experimental
+    #[deprecated]
+    pub const kDeprecatedEnumerator: DeprecatedEnumerators =
+        DeprecatedEnumerators(::ffi_11::new_c_uint(0));
+    #[deprecated = "old"]
+    pub const kDeprecatedEnumeratorWithMessage: DeprecatedEnumerators =
+        DeprecatedEnumerators(::ffi_11::new_c_uint(1));
 }
 impl From<::ffi_11::c_uint> for DeprecatedEnumerators {
     fn from(value: ::ffi_11::c_uint) -> DeprecatedEnumerators {
@@ -63,22 +155,20 @@ impl From<DeprecatedEnumerators> for ::ffi_11::c_uint {
     }
 }
 
-// error: type alias `DeprecatedUsing` could not be bound
-//   [[deprecated]] attribute
+#[deprecated]
+pub type DeprecatedUsing = ::ffi_11::c_int;
 
-// error: type alias `DeprecatedUsingWithMessage` could not be bound
-//   [[deprecated]] attribute
+#[deprecated = "old"]
+pub type DeprecatedUsingWithMessage = ::ffi_11::c_int;
 
 #[derive(Clone, Copy, ::ctor::MoveAndAssignViaCopy)]
-#[repr(C, align(4))]
+#[repr(C)]
 ///CRUBIT_ANNOTATE: cpp_type=DeprecatedFields
 pub struct DeprecatedFields {
-    /// Reason for representing this field as a blob of bytes:
-    /// field is marked as deprecated; requires experimental features on //rs_bindings_from_cc/test/golden:deprecated_cc
-    pub(crate) no_message: [::core::mem::MaybeUninit<u8>; 4],
-    /// Reason for representing this field as a blob of bytes:
-    /// field is marked as deprecated; requires experimental features on //rs_bindings_from_cc/test/golden:deprecated_cc
-    pub(crate) message: [::core::mem::MaybeUninit<u8>; 4],
+    #[deprecated]
+    pub no_message: ::ffi_11::c_int,
+    #[deprecated = "old"]
+    pub message: ::ffi_11::c_int,
 }
 impl !Send for DeprecatedFields {}
 impl !Sync for DeprecatedFields {}
@@ -98,11 +188,15 @@ impl Default for DeprecatedFields {
     }
 }
 
-// error: global variable `global_var` could not be bound
-//   [[deprecated]] attribute
+unsafe extern "C" {
+    #[deprecated]
+    pub static mut global_var: ::ffi_11::c_int;
+}
 
-// error: global variable `global_var_with_message` could not be bound
-//   [[deprecated]] attribute
+unsafe extern "C" {
+    #[deprecated = "old"]
+    pub static mut global_var_with_message: ::ffi_11::c_int;
+}
 
 // error: class `SomeTotalSpecialization` could not be bound
 //   Class templates are not yet supported
@@ -120,13 +214,33 @@ mod detail {
     #[allow(unused_imports)]
     use super::*;
     unsafe extern "C" {
+        pub(crate) unsafe fn __rust_thunk___Z19deprecated_functionv();
+        pub(crate) unsafe fn __rust_thunk___Z32deprecated_function_with_messagev();
+        pub(crate) unsafe fn __rust_thunk___ZN16DeprecatedStructC1Ev(
+            __this: *mut ::core::ffi::c_void,
+        );
+        pub(crate) unsafe fn __rust_thunk___ZN27DeprecatedStructWithMessageC1Ev(
+            __this: *mut ::core::ffi::c_void,
+        );
+        pub(crate) unsafe fn __rust_thunk___ZN19DeprecatedNamespace1fEv();
+        pub(crate) unsafe fn __rust_thunk___ZN30DeprecatedNamespaceWithMessage1fEv();
         pub(crate) unsafe fn __rust_thunk___ZN16DeprecatedFieldsC1Ev(
             __this: *mut ::core::ffi::c_void,
         );
     }
 }
 
 const _: () = {
+    assert!(::core::mem::size_of::<crate::DeprecatedStruct>() == 1);
+    assert!(::core::mem::align_of::<crate::DeprecatedStruct>() == 1);
+    static_assertions::assert_impl_all!(crate::DeprecatedStruct: Copy,Clone);
+    static_assertions::assert_not_impl_any!(crate::DeprecatedStruct: Drop);
+
+    assert!(::core::mem::size_of::<crate::DeprecatedStructWithMessage>() == 1);
+    assert!(::core::mem::align_of::<crate::DeprecatedStructWithMessage>() == 1);
+    static_assertions::assert_impl_all!(crate::DeprecatedStructWithMessage: Copy,Clone);
+    static_assertions::assert_not_impl_any!(crate::DeprecatedStructWithMessage: Drop);
+
     assert!(::core::mem::size_of::<crate::DeprecatedFields>() == 8);
     assert!(::core::mem::align_of::<crate::DeprecatedFields>() == 4);
     static_assertions::assert_impl_all!(crate::DeprecatedFields: Copy,Clone);