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

Author: anforowicz

compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs

@@ -1,4 +1,6 @@
-use rustc_hir::attrs::{CoverageAttrKind, OptimizeAttr, RtsanSetting, SanitizerSet, UsedBy};
+use rustc_hir::attrs::{
+    CoverageAttrKind, ExportVisibilityAttrValue, OptimizeAttr, RtsanSetting, SanitizerSet, UsedBy,
+};
 use rustc_session::parse::feature_err;
 
 use super::prelude::*;
@@ -153,6 +155,43 @@ 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::AllowList(&[Allow(Target::Fn), Allow(Target::Static)]);
+    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 str_to_visibility = [("target_default", ExportVisibilityAttrValue::TargetDefault)];
+        for &(s, visibility) in str_to_visibility.iter() {
+            if s == sv.as_str() {
+                return Some(AttributeKind::ExportVisibility { visibility, span: cx.attr_span });
+            }
+        }
+
+        let allowed_str_values = str_to_visibility
+            .into_iter()
+            .map(|(s, _visibility)| s)
+            .map(Symbol::intern)
+            .collect::<Vec<_>>();
+        cx.expected_specific_argument_strings(nv.value_span, &allowed_str_values);
+        None
+    }
+}
+
 pub(crate) struct ObjcClassParser;
 
 impl<S: Stage> SingleAttributeParser<S> for ObjcClassParser {

compiler/rustc_attr_parsing/src/context.rs

@@ -171,6 +171,7 @@ attribute_parsers!(
         Single<DoNotRecommendParser>,
         Single<DummyParser>,
         Single<ExportNameParser>,
+        Single<ExportVisibilityParser>,
         Single<IgnoreParser>,
         Single<InlineParser>,
         Single<InstructionSetParser>,

compiler/rustc_codegen_ssa/src/codegen_attrs.rs

@@ -4,7 +4,8 @@ use rustc_abi::{Align, ExternAbi};
 use rustc_ast::expand::autodiff_attrs::{AutoDiffAttrs, DiffActivity, DiffMode};
 use rustc_ast::{LitKind, MetaItem, MetaItemInner};
 use rustc_hir::attrs::{
-    AttributeKind, EiiImplResolution, InlineAttr, Linkage, RtsanSetting, UsedBy,
+    AttributeKind, EiiImplResolution, ExportVisibilityAttrValue, InlineAttr, Linkage, RtsanSetting,
+    UsedBy,
 };
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::{DefId, LOCAL_CRATE, LocalDefId};
@@ -75,6 +76,13 @@ fn process_builtin_attrs(
         match attr {
             AttributeKind::Cold(_) => codegen_fn_attrs.flags |= CodegenFnAttrFlags::COLD,
             AttributeKind::ExportName { name, .. } => codegen_fn_attrs.symbol_name = Some(*name),
+            AttributeKind::ExportVisibility { visibility, .. } => {
+                codegen_fn_attrs.export_visibility = Some(match visibility {
+                    ExportVisibilityAttrValue::TargetDefault => {
+                        tcx.sess.default_visibility().into()
+                    }
+                });
+            }
             AttributeKind::Inline(inline, span) => {
                 codegen_fn_attrs.inline = *inline;
                 interesting_spans.inline = Some(*span);
@@ -542,6 +550,17 @@ fn handle_lang_items(
         }
         err.emit();
     }
+
+    if codegen_fn_attrs.export_visibility.is_some() {
+        let span = find_attr!(attrs, AttributeKind::ExportVisibility{span, ..} => *span)
+            .unwrap_or_default();
+        if codegen_fn_attrs.flags.contains(CodegenFnAttrFlags::RUSTC_STD_INTERNAL_SYMBOL) {
+            tcx.dcx().emit_err(errors::ExportVisibilityWithRustcStdInternalSymbol { span });
+        }
+        if !codegen_fn_attrs.contains_extern_indicator() {
+            tcx.dcx().emit_err(errors::ExportVisibilityWithoutNoMangleNorExportName { span });
+        }
+    }
 }
 
 /// Generate the [`CodegenFnAttrs`] for an item (identified by the [`LocalDefId`]).

compiler/rustc_codegen_ssa/src/errors.rs

@@ -1299,3 +1299,20 @@ pub(crate) struct LtoProcMacro;
 #[diag("cannot prefer dynamic linking when performing LTO")]
 #[note("only 'staticlib', 'bin', and 'cdylib' outputs are supported with LTO")]
 pub(crate) struct DynamicLinkingWithLTO;
+
+#[derive(Diagnostic)]
+#[diag("`#[export_visibility = ...]` cannot be used on internal language items")]
+pub(crate) struct ExportVisibilityWithRustcStdInternalSymbol {
+    #[primary_span]
+    pub span: Span,
+}
+
+#[derive(Diagnostic)]
+#[diag(
+    "`#[export_visibility = ...]` will be ignored \
+     without `export_name`, `no_mangle`, or similar attribute"
+)]
+pub(crate) struct ExportVisibilityWithoutNoMangleNorExportName {
+    #[primary_span]
+    pub span: Span,
+}

compiler/rustc_feature/src/builtin_attrs.rs

@@ -649,6 +649,7 @@ pub static BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
         template!(NameValueStr: "name", "https://doc.rust-lang.org/reference/abi.html#the-export_name-attribute"),
         FutureWarnPreceding, EncodeCrossCrate::No
     ),
+    gated!(export_visibility, Normal, template!(NameValueStr: "visibility"), ErrorPreceding, EncodeCrossCrate::No, experimental!(export_visibility)),
     ungated!(
         unsafe(Edition2024) link_section, Normal,
         template!(NameValueStr: "name", "https://doc.rust-lang.org/reference/abi.html#the-link_section-attribute"),

compiler/rustc_feature/src/unstable.rs

@@ -478,6 +478,8 @@ 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.
+    (unstable, export_visibility, "CURRENT_RUSTC_VERSION", Some(151425)),
     /// Externally implementable items
     (unstable, extern_item_impls, "1.94.0", Some(125418)),
     /// Allows defining `extern type`s.

compiler/rustc_hir/src/attrs/data_structures.rs

@@ -187,6 +187,15 @@ 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,
+}
+
 /// 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)]`
@@ -872,6 +881,9 @@ pub enum AttributeKind {
     /// Represents `#[export_stable]`.
     ExportStable,
 
+    /// Represents [`#[export_visibility = ...]`](https://github.com/rust-lang/rust/issues/151425)
+    ExportVisibility { visibility: ExportVisibilityAttrValue, span: Span },
+
     /// Represents `#[ffi_const]`.
     FfiConst(Span),
 

compiler/rustc_hir/src/attrs/encode_cross_crate.rs

@@ -44,6 +44,7 @@ impl AttributeKind {
             EiiImpls(..) => No,
             ExportName { .. } => Yes,
             ExportStable => No,
+            ExportVisibility { .. } => Yes,
             FfiConst(..) => No,
             FfiPure(..) => No,
             Fundamental { .. } => Yes,

compiler/rustc_middle/src/middle/codegen_fn_attrs.rs

@@ -79,6 +79,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.
@@ -224,6 +230,7 @@ impl CodegenFnAttrs {
             optimize: OptimizeAttr::Default,
             symbol_name: None,
             link_ordinal: None,
+            export_visibility: None,
             target_features: vec![],
             foreign_item_symbol_aliases: vec![],
             safe_target_features: false,

compiler/rustc_monomorphize/src/partitioning.rs

@@ -931,6 +931,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;