Add attr externally_constructed indicates pub struct with private fields could be constructed externally

Author: mu001999

compiler/rustc_feature/src/builtin_attrs.rs

@@ -428,6 +428,10 @@ pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
     ungated!(unsafe no_mangle, Normal, template!(Word), WarnFollowing, EncodeCrossCrate::No),
     ungated!(used, Normal, template!(Word, List: "compiler|linker"), WarnFollowing, EncodeCrossCrate::No),
     ungated!(link_ordinal, Normal, template!(List: "ordinal"), ErrorPreceding, EncodeCrossCrate::Yes),
+    gated!(
+        externally_constructed, Normal, template!(Word), WarnFollowing,
+        EncodeCrossCrate::Yes, externally_constructed_attr, experimental!(mark_externally_constructed)
+    ),
 
     // Limits:
     ungated!(

compiler/rustc_feature/src/unstable.rs

@@ -463,6 +463,9 @@ declare_features! (
     (unstable, extended_varargs_abi_support, "1.65.0", Some(100189)),
     /// Allows defining `extern type`s.
     (unstable, extern_types, "1.23.0", Some(43467)),
+    /// Allows `#[externally_constructed]` on pub structs with private fields,
+    /// indicates they will be contructed externally during dead code analysis.
+    (unstable, externally_constructed_attr, "CURRENT_RUSTC_VERSION", Some(126634)),
     /// Allow using 128-bit (quad precision) floating point numbers.
     (unstable, f128, "1.78.0", Some(116909)),
     /// Allow using 16-bit (half precision) floating point numbers.

compiler/rustc_passes/src/dead.rs

@@ -59,21 +59,22 @@ fn struct_all_fields_are_public(tcx: TyCtxt<'_>, id: DefId) -> bool {
     // treat PhantomData and positional ZST as public,
     // we don't want to lint types which only have them,
     // cause it's a common way to use such types to check things like well-formedness
-    tcx.adt_def(id).all_fields().all(|field| {
-        let field_type = tcx.type_of(field.did).instantiate_identity();
-        if field_type.is_phantom_data() {
-            return true;
-        }
-        let is_positional = field.name.as_str().starts_with(|c: char| c.is_ascii_digit());
-        if is_positional
-            && tcx
-                .layout_of(tcx.param_env(field.did).and(field_type))
-                .map_or(true, |layout| layout.is_zst())
-        {
-            return true;
-        }
-        field.vis.is_public()
-    })
+    tcx.has_attr(id, sym::externally_constructed)
+        || tcx.adt_def(id).all_fields().all(|field| {
+            let field_type = tcx.type_of(field.did).instantiate_identity();
+            if field_type.is_phantom_data() {
+                return true;
+            }
+            let is_positional = field.name.as_str().starts_with(|c: char| c.is_ascii_digit());
+            if is_positional
+                && tcx
+                    .layout_of(tcx.param_env(field.did).and(field_type))
+                    .map_or(true, |layout| layout.is_zst())
+            {
+                return true;
+            }
+            field.vis.is_public()
+        })
 }
 
 /// check struct and its fields are public or not,

compiler/rustc_span/src/symbol.rs

@@ -799,6 +799,8 @@ symbols! {
         extern_types,
         external,
         external_doc,
+        externally_constructed,
+        externally_constructed_attr,
         f,
         f128,
         f128_nan,

tests/ui/externally_constructed_attr/not-lint-structs-constructed-externally.rs

@@ -0,0 +1,41 @@
+//@ check-pass
+#![feature(externally_constructed_attr)]
+
+#[repr(C)]
+#[externally_constructed]
+pub struct Foo {
+    pub i: i16,
+    align: i16
+}
+
+mod ffi {
+    use super::*;
+
+    extern "C" {
+        pub fn DomPromise_AddRef(promise: *const Promise);
+        pub fn DomPromise_Release(promise: *const Promise);
+    }
+}
+
+#[repr(C)]
+#[externally_constructed]
+pub struct Promise {
+    private: [u8; 0],
+    __nosync: ::std::marker::PhantomData<::std::rc::Rc<u8>>,
+}
+
+pub unsafe trait RefCounted {
+    unsafe fn addref(&self);
+    unsafe fn release(&self);
+}
+
+unsafe impl RefCounted for Promise {
+    unsafe fn addref(&self) {
+        ffi::DomPromise_AddRef(self)
+    }
+    unsafe fn release(&self) {
+        ffi::DomPromise_Release(self)
+    }
+}
+
+fn main() {}

tests/ui/feature-gates/feature-gate-externally_constructed_attr.rs

@@ -0,0 +1,8 @@
+#[repr(C)]
+#[externally_constructed] //~ ERROR the `#[mark_externally_constructed]` attribute is an experimental feature
+pub struct Foo {
+    pub i: i16,
+    align: i16
+}
+
+fn main() {}

tests/ui/feature-gates/feature-gate-externally_constructed_attr.stderr

@@ -0,0 +1,13 @@
+error[E0658]: the `#[mark_externally_constructed]` attribute is an experimental feature
+  --> $DIR/feature-gate-externally_constructed_attr.rs:2:1
+   |
+LL | #[externally_constructed]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #126634 <https://github.com/rust-lang/rust/issues/126634> for more information
+   = help: add `#![feature(externally_constructed_attr)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0658`.