Add new unstable attribute: #[export_visibility = ...].

anforowicz · anforowicz · commit 1e1924bdac60 · 2025-10-16T17:23:39.000Z
diff --git a/compiler/rustc_attr_parsing/messages.ftl b/compiler/rustc_attr_parsing/messages.ftl
@@ -83,6 +83,9 @@ attr_parsing_invalid_attr_unsafe = `{$name}` is not an unsafe attribute
     .suggestion = remove the `unsafe(...)`
     .note = extraneous unsafe is not allowed in attributes
 
+attr_parsing_invalid_export_visibility =
+    invalid export visibility: {$unrecognized_visibility}
+
 attr_parsing_invalid_issue_string =
     `issue` must be a non-zero numeric string or "none"
     .must_not_be_zero = `issue` must not be "0", use "none" instead
diff --git a/compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs b/compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs
@@ -1,10 +1,15 @@
-use rustc_hir::attrs::{CoverageAttrKind, OptimizeAttr, SanitizerSet, UsedBy};
+use std::str::FromStr;
+
+use rustc_feature::{AttributeTemplate, template};
+use rustc_hir::attrs::{
+    CoverageAttrKind, ExportVisibilityAttrValue, OptimizeAttr, SanitizerSet, UsedBy,
+};
 use rustc_session::parse::feature_err;
 
 use super::prelude::*;
 use crate::session_diagnostics::{
-    NakedFunctionIncompatibleAttribute, NullOnExport, NullOnObjcClass, NullOnObjcSelector,
-    ObjcClassExpectedStringLiteral, ObjcSelectorExpectedStringLiteral,
+    InvalidExportVisibility, NakedFunctionIncompatibleAttribute, NullOnExport, NullOnObjcClass,
+    NullOnObjcSelector, ObjcClassExpectedStringLiteral, ObjcSelectorExpectedStringLiteral,
 };
 use crate::target_checking::Policy::AllowSilent;
 
@@ -154,6 +159,39 @@ impl<S: Stage> SingleAttributeParser<S> for ExportNameParser {
     }
 }
 
+pub(crate) struct ExportVisibilityParser;
+
+impl<S: Stage> SingleAttributeParser<S> for ExportVisibilityParser {
+    const PATH: &[rustc_span::Symbol] = &[sym::export_visibility];
+    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepInnermost;
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowListWarnRest(&[
+        Allow(Target::Fn),
+        Allow(Target::Static),
+        Error(Target::Closure),
+    ]);
+    const TEMPLATE: AttributeTemplate = template!(NameValueStr: "visibility");
+
+    fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser<'_>) -> Option<AttributeKind> {
+        let Some(nv) = args.name_value() else {
+            cx.expected_name_value(cx.attr_span, None);
+            return None;
+        };
+        let Some(sv) = nv.value_as_str() else {
+            cx.expected_string_literal(nv.value_span, Some(nv.value_as_lit()));
+            return None;
+        };
+        let Ok(visibility) = ExportVisibilityAttrValue::from_str(sv.as_str()) else {
+            cx.emit_err(InvalidExportVisibility {
+                span: nv.value_span,
+                unrecognized_visibility: sv.to_string(),
+            });
+            return None;
+        };
+        Some(AttributeKind::ExportVisibility { visibility, span: cx.attr_span })
+    }
+}
+
 pub(crate) struct ObjcClassParser;
 
 impl<S: Stage> SingleAttributeParser<S> for ObjcClassParser {
diff --git a/compiler/rustc_attr_parsing/src/context.rs b/compiler/rustc_attr_parsing/src/context.rs
@@ -19,9 +19,9 @@ use crate::attributes::allow_unstable::{
 };
 use crate::attributes::body::CoroutineParser;
 use crate::attributes::codegen_attrs::{
-    ColdParser, CoverageParser, ExportNameParser, ForceTargetFeatureParser, NakedParser,
-    NoMangleParser, ObjcClassParser, ObjcSelectorParser, OptimizeParser, SanitizeParser,
-    TargetFeatureParser, TrackCallerParser, UsedParser,
+    ColdParser, CoverageParser, ExportNameParser, ExportVisibilityParser, ForceTargetFeatureParser,
+    NakedParser, NoMangleParser, ObjcClassParser, ObjcSelectorParser, OptimizeParser,
+    SanitizeParser, TargetFeatureParser, TrackCallerParser, UsedParser,
 };
 use crate::attributes::confusables::ConfusablesParser;
 use crate::attributes::crate_level::{
@@ -179,6 +179,7 @@ attribute_parsers!(
         Single<DeprecationParser>,
         Single<DummyParser>,
         Single<ExportNameParser>,
+        Single<ExportVisibilityParser>,
         Single<IgnoreParser>,
         Single<InlineParser>,
         Single<LinkNameParser>,
diff --git a/compiler/rustc_attr_parsing/src/session_diagnostics.rs b/compiler/rustc_attr_parsing/src/session_diagnostics.rs
@@ -445,6 +445,14 @@ pub(crate) struct IllFormedAttributeInputLint {
     pub suggestions: DiagArgValue,
 }
 
+#[derive(Diagnostic)]
+#[diag(attr_parsing_invalid_export_visibility, code = E0648)] // DO NOT SUBMIT: fix error number?
+pub(crate) struct InvalidExportVisibility {
+    #[primary_span]
+    pub span: Span,
+    pub unrecognized_visibility: String,
+}
+
 #[derive(Diagnostic)]
 #[diag(attr_parsing_null_on_export, code = E0648)]
 pub(crate) struct NullOnExport {
diff --git a/compiler/rustc_codegen_ssa/src/codegen_attrs.rs b/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
@@ -3,7 +3,9 @@ use std::str::FromStr;
 use rustc_abi::{Align, ExternAbi};
 use rustc_ast::expand::autodiff_attrs::{AutoDiffAttrs, DiffActivity, DiffMode};
 use rustc_ast::{LitKind, MetaItem, MetaItemInner, attr};
-use rustc_hir::attrs::{AttributeKind, InlineAttr, InstructionSetAttr, UsedBy};
+use rustc_hir::attrs::{
+    AttributeKind, ExportVisibilityAttrValue, InlineAttr, InstructionSetAttr, UsedBy,
+};
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::{DefId, LOCAL_CRATE, LocalDefId};
 use rustc_hir::{self as hir, Attribute, LangItem, find_attr, lang_items};
@@ -160,6 +162,22 @@ fn process_builtin_attrs(
                     codegen_fn_attrs.inline = *inline;
                     interesting_spans.inline = Some(*span);
                 }
+                AttributeKind::ExportVisibility { visibility, span } => {
+                    if !tcx.features().export_visibility() {
+                        feature_err(
+                            &tcx.sess,
+                            sym::export_visibility,
+                            *span,
+                            "`#[export_visibility = ...]` is currently unstable",
+                        )
+                        .emit();
+                    }
+                    codegen_fn_attrs.export_visibility = Some(match visibility {
+                        ExportVisibilityAttrValue::TargetDefault => {
+                            tcx.sess.default_visibility().into()
+                        }
+                    });
+                }
                 AttributeKind::Naked(_) => codegen_fn_attrs.flags |= CodegenFnAttrFlags::NAKED,
                 AttributeKind::Align { align, .. } => codegen_fn_attrs.alignment = Some(*align),
                 AttributeKind::LinkName { name, .. } => {
@@ -546,6 +564,17 @@ fn handle_lang_items(
         }
         err.emit();
     }
+
+    if codegen_fn_attrs.export_visibility.is_some() && !codegen_fn_attrs.contains_extern_indicator()
+    {
+        let export_visibility_span =
+            find_attr!(attrs, AttributeKind::ExportVisibility{span, ..} => *span)
+                .unwrap_or_default();
+        tcx.dcx().span_err(
+            export_visibility_span,
+            "export visibility will be ignored without `export_name`, `no_mangle`, or similar attribute",
+        );
+    }
 }
 
 /// Generate the [`CodegenFnAttrs`] for an item (identified by the [`LocalDefId`]).
diff --git a/compiler/rustc_feature/src/builtin_attrs.rs b/compiler/rustc_feature/src/builtin_attrs.rs
@@ -627,6 +627,7 @@ pub static BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
         template!(NameValueStr: "name", "https://doc.rust-lang.org/reference/abi.html#the-export_name-attribute"),
         FutureWarnPreceding, EncodeCrossCrate::No
     ),
+    ungated!(export_visibility, Normal, template!(NameValueStr: "visibility"), ErrorPreceding, EncodeCrossCrate::No),
     ungated!(
         unsafe(Edition2024) link_section, Normal,
         template!(NameValueStr: "name", "https://doc.rust-lang.org/reference/abi.html#the-link_section-attribute"),
diff --git a/compiler/rustc_feature/src/unstable.rs b/compiler/rustc_feature/src/unstable.rs
@@ -498,6 +498,9 @@ declare_features! (
     (incomplete, explicit_tail_calls, "1.72.0", Some(112788)),
     /// Allows using `#[export_stable]` which indicates that an item is exportable.
     (incomplete, export_stable, "1.88.0", Some(139939)),
+    /// Allows `#[export_visibility]` on definitions of statics and/or functions.
+    /* FIXME / DO NOT SUBMIT - use actual bug number */
+    (unstable, export_visibility, "CURRENT_RUSTC_VERSION", Some(123456)),
     /// Allows using `system` as a calling convention with varargs.
     (unstable, extern_system_varargs, "1.86.0", Some(136946)),
     /// Allows defining `extern type`s.
diff --git a/compiler/rustc_hir/src/attrs/data_structures.rs b/compiler/rustc_hir/src/attrs/data_structures.rs
@@ -1,5 +1,6 @@
 use std::borrow::Cow;
 use std::path::PathBuf;
+use std::str::FromStr;
 
 pub use ReprAttr::*;
 use rustc_abi::Align;
@@ -145,6 +146,26 @@ impl Deprecation {
     }
 }
 
+/// Pre-parsed value of `#[export_visibility = ...]` attribute.
+///
+/// In a future RFC we may consider adding support for `Hidden`, `Protected`, and/or
+/// `Interposable`.
+#[derive(Clone, Copy, Debug, HashStable_Generic, Encodable, Decodable, PrintAttribute)]
+pub enum ExportVisibilityAttrValue {
+    TargetDefault,
+}
+
+impl FromStr for ExportVisibilityAttrValue {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<ExportVisibilityAttrValue, Self::Err> {
+        match s {
+            "target_default" => Ok(ExportVisibilityAttrValue::TargetDefault),
+            _ => Err(format!("'{s}' is not a valid value for #[export_visibility = ...]",)),
+        }
+    }
+}
+
 /// There are three valid forms of the attribute:
 /// `#[used]`, which is equivalent to `#[used(linker)]` on targets that support it, but `#[used(compiler)]` if not.
 /// `#[used(compiler)]`
@@ -533,6 +554,9 @@ pub enum AttributeKind {
     /// Represents `#[export_stable]`.
     ExportStable,
 
+    /// Represents [`#[export_visibility = ...]`](https://github.com/rust-lang/rfcs/pull/3834)
+    ExportVisibility { visibility: ExportVisibilityAttrValue, span: Span },
+
     /// Represents `#[ffi_const]`.
     FfiConst(Span),
 
diff --git a/compiler/rustc_hir/src/attrs/encode_cross_crate.rs b/compiler/rustc_hir/src/attrs/encode_cross_crate.rs
@@ -45,6 +45,7 @@ impl AttributeKind {
             Dummy => No,
             ExportName { .. } => Yes,
             ExportStable => No,
+            ExportVisibility { .. } => Yes,
             FfiConst(..) => No,
             FfiPure(..) => No,
             Fundamental { .. } => Yes,
diff --git a/compiler/rustc_middle/src/middle/codegen_fn_attrs.rs b/compiler/rustc_middle/src/middle/codegen_fn_attrs.rs
@@ -6,6 +6,7 @@ use rustc_macros::{HashStable, TyDecodable, TyEncodable};
 use rustc_span::Symbol;
 use rustc_target::spec::SanitizerSet;
 
+use crate::mir::mono::Visibility;
 use crate::ty::{InstanceKind, TyCtxt};
 
 impl<'tcx> TyCtxt<'tcx> {
@@ -43,6 +44,12 @@ pub struct CodegenFnAttrs {
     /// be set when `link_name` is set. This is for foreign items with the
     /// "raw-dylib" kind.
     pub link_ordinal: Option<u16>,
+    /// The `#[export_visibility = "..."]` attribute, with values interpreted
+    /// as follows:
+    /// * `None` - use the "inherent" visibility (either based on the target platform, or provided via
+    ///   `-Zdefault-visibility=...` command-line flag)
+    /// * `Some(...)` - use the item/symbol-specific visibility
+    pub export_visibility: Option<Visibility>,
     /// The `#[target_feature(enable = "...")]` attribute and the enabled
     /// features (only enabled features are supported right now).
     /// Implied target features have already been applied.
@@ -180,6 +187,7 @@ impl CodegenFnAttrs {
             optimize: OptimizeAttr::Default,
             symbol_name: None,
             link_ordinal: None,
+            export_visibility: None,
             target_features: vec![],
             safe_target_features: false,
             linkage: None,
diff --git a/compiler/rustc_middle/src/mir/mono.rs b/compiler/rustc_middle/src/mir/mono.rs
@@ -374,7 +374,7 @@ pub struct MonoItemData {
 /// Visibility doesn't have any effect when linkage is internal.
 ///
 /// DSO means dynamic shared object, that is a dynamically linked executable or dylib.
-#[derive(Copy, Clone, PartialEq, Debug, HashStable)]
+#[derive(Copy, Clone, PartialEq, Debug, HashStable, TyDecodable, TyEncodable)]
 pub enum Visibility {
     /// Export the symbol from the DSO and apply overrides of the symbol by outside DSOs to within
     /// the DSO if the object file format supports this.
diff --git a/compiler/rustc_monomorphize/src/partitioning.rs b/compiler/rustc_monomorphize/src/partitioning.rs
@@ -912,6 +912,11 @@ fn mono_item_visibility<'tcx>(
 }
 
 fn default_visibility(tcx: TyCtxt<'_>, id: DefId, is_generic: bool) -> Visibility {
+    // If present, then symbol-specific `#[export_visibility = ...]` "wins".
+    if let Some(visibility) = tcx.codegen_fn_attrs(id).export_visibility {
+        return visibility;
+    }
+
     // Fast-path to avoid expensive query call below
     if tcx.sess.default_visibility() == SymbolVisibility::Interposable {
         return Visibility::Default;
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
@@ -249,6 +249,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                     | AttributeKind::Repr { .. }
                     | AttributeKind::Cold(..)
                     | AttributeKind::ExportName { .. }
+                    | AttributeKind::ExportVisibility { .. }
                     | AttributeKind::Fundamental
                     | AttributeKind::Optimize(..)
                     | AttributeKind::LinkSection { .. }
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
@@ -964,6 +964,7 @@ symbols! {
         explicit_tail_calls,
         export_name,
         export_stable,
+        export_visibility,
         expr,
         expr_2021,
         expr_fragment_specifier_2024,
diff --git a/tests/codegen-llvm/export-visibility.rs b/tests/codegen-llvm/export-visibility.rs
@@ -0,0 +1,92 @@
+// Verifies that `#[export_visibility = ...]` can override the visibility
+// that is normally implied by `#[export_name]` or `#[no_mangle]`.
+//
+// High-level test expectations for items with `#[export_name = ...]`
+// (or with `#[no_mangle]`) and:
+//
+// * Without `#[export_visibility = ...]` => public
+// * `#[export_visibility = "target_default"]` => value inherited from the target
+//   platform or from the `-Zdefault-visibility=...` command-line flag
+//   (this expectation depends on whether the `HIDDEN` vs `PROTECTED`
+//   test revision is used).
+//
+// Note that what we call "public" in the expectations above is also referred
+// to as "default" in LLVM docs - see
+// https://llvm.org/docs/LangRef.html#visibility-styles
+
+//@ revisions:HIDDEN PROTECTED
+//@[HIDDEN] compile-flags: -Zdefault-visibility=hidden
+//@[PROTECTED] compile-flags: -Zdefault-visibility=protected
+
+// This test focuses on rlib to exercise the scenario described in
+// https://github.com/rust-lang/rust/issues/73958#issuecomment-2891711649
+#![crate_type = "rlib"]
+#![feature(export_visibility)]
+
+// Exact LLVM IR differs depending on the target triple (e.g. `hidden constant`
+// vs `internal constant` vs `constant`).  Because of this, we only apply the
+// specific test expectations below to one specific target triple.  If needed,
+// additional targets can be covered by adding copies of this test file with
+// a different `only-X` directive.
+//
+//@     only-x86_64-unknown-linux-gnu
+
+///////////////////////////////////////////////////////////////////////
+// The tests below focus on how `#[export_visibility = ...]` works for
+// a `static`.  The tests are based on similar tests in
+// `tests/codegen/default-visibility.rs`
+
+#[unsafe(export_name = "test_static_no_attr")]
+pub static TEST_STATIC_NO_ATTR: [u8; 7] = *b"static1";
+
+#[unsafe(export_name = "test_static_target_default")]
+#[export_visibility = "target_default"]
+pub static TESTED_STATIC_ATTR_ASKS_TO_TARGET_DEFAULT: [u8; 7] = *b"static2";
+
+#[unsafe(no_mangle)]
+pub static test_static_no_mangle_no_attr: [u8; 10] = *b"no_mangle1";
+
+#[unsafe(no_mangle)]
+#[export_visibility = "target_default"]
+pub static test_static_no_mangle_target_default: [u8; 10] = *b"no_mangle2";
+
+// HIDDEN: @test_static_no_attr = local_unnamed_addr constant
+// HIDDEN: @test_static_target_default = hidden local_unnamed_addr constant
+// HIDDEN: @test_static_no_mangle_no_attr = local_unnamed_addr constant
+// HIDDEN: @test_static_no_mangle_target_default = hidden local_unnamed_addr constant
+
+// PROTECTED: @test_static_no_attr = local_unnamed_addr constant
+// PROTECTED: @test_static_target_default = protected local_unnamed_addr constant
+// PROTECTED: @test_static_no_mangle_no_attr = local_unnamed_addr constant
+// PROTECTED: @test_static_no_mangle_target_default = protected local_unnamed_addr constant
+
+///////////////////////////////////////////////////////////////////////
+// The tests below focus on how `#[export_visibility = ...]` works for
+// a `fn`.
+//
+// The tests below try to mimics how `cxx` exports known/hardcoded helpers (e.g.
+// `cxxbridge1$string$drop` [1]) as well as build-time-generated thunks (e.g.
+// `serde_json_lenient$cxxbridge1$decode_json` from https://crbug.com/418073233#comment7).
+//
+// We use `line!()` to ensure that each function has a unique body
+// (and therefore that the functions won't get folded together).
+//
+// [1]
+// https://github.com/dtolnay/cxx/blob/ebdd6a0c63ae10dc5224ed21970b7a0504657434/src/symbols/rust_string.rs#L83-L86
+
+#[unsafe(export_name = "test_fn_no_attr")]
+unsafe extern "C" fn test_fn_no_attr() -> u32 {
+    line!()
+}
+
+#[unsafe(export_name = "test_fn_target_default")]
+#[export_visibility = "target_default"]
+unsafe extern "C" fn test_fn_asks_for_target_default() -> u32 {
+    line!()
+}
+
+// HIDDEN: define noundef i32 @test_fn_no_attr
+// HIDDEN: define hidden noundef i32 @test_fn_target_default
+
+// PROTECTED: define noundef i32 @test_fn_no_attr
+// PROTECTED: define protected noundef i32 @test_fn_target_default
diff --git a/tests/ui/attributes/export-visibility-with-unrecognized-arg.rs b/tests/ui/attributes/export-visibility-with-unrecognized-arg.rs
diff --git a/tests/ui/attributes/export-visibility-with-unrecognized-arg.stderr b/tests/ui/attributes/export-visibility-with-unrecognized-arg.stderr
diff --git a/tests/ui/attributes/export-visibility-without-export-name.rs b/tests/ui/attributes/export-visibility-without-export-name.rs
diff --git a/tests/ui/attributes/export-visibility-without-export-name.stderr b/tests/ui/attributes/export-visibility-without-export-name.stderr
diff --git a/tests/ui/feature-gates/feature-gate-export-visibility.rs b/tests/ui/feature-gates/feature-gate-export-visibility.rs
diff --git a/tests/ui/feature-gates/feature-gate-export-visibility.stderr b/tests/ui/feature-gates/feature-gate-export-visibility.stderr
