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

Author: mu001999

compiler/rustc_feature/src/builtin_attrs.rs

@@ -428,6 +428,7 @@ 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),
+    ungated!(externally_constructed, Normal, template!(Word), WarnFollowing, EncodeCrossCrate::Yes),
 
     // Limits:
     ungated!(

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,7 @@ symbols! {
         extern_types,
         external,
         external_doc,
+        externally_constructed,
         f,
         f128,
         f128_nan,

tests/ui/lint/dead-code/externally-constructed.rs

@@ -0,0 +1,40 @@
+//@ check-pass
+
+#[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() {}