Add new unstable attribute: #[rust_symbol_export_level].

anforowicz · anforowicz · commit 9dd4d3f6b2be · 2025-07-30T21:20:26.000Z
diff --git a/compiler/rustc_attr_data_structures/src/attributes.rs b/compiler/rustc_attr_data_structures/src/attributes.rs
@@ -431,6 +431,10 @@ pub enum AttributeKind {
     /// Represents [`#[repr]`](https://doc.rust-lang.org/stable/reference/type-layout.html#representations).
     Repr { reprs: ThinVec<(ReprAttr, Span)>, first_span: Span },
 
+    /// Represents `#[rust_symbol_export_level]` which is one of alternatives discussed
+    /// in <https://github.com/rust-lang/rfcs/pull/3834>.
+    RustSymbolExportLevel(Span),
+
     /// Represents `#[rustc_builtin_macro]`.
     RustcBuiltinMacro { builtin_name: Option<Symbol>, helper_attrs: ThinVec<Symbol>, span: Span },
 
diff --git a/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs b/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
@@ -66,6 +66,7 @@ impl AttributeKind {
             ProcMacroDerive { .. } => No,
             PubTransparent(..) => Yes,
             Repr { .. } => No,
+            RustSymbolExportLevel { .. } => No,
             RustcBuiltinMacro { .. } => Yes,
             RustcLayoutScalarValidRangeEnd(..) => Yes,
             RustcLayoutScalarValidRangeStart(..) => Yes,
diff --git a/compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs b/compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs
@@ -118,6 +118,13 @@ impl<S: Stage> SingleAttributeParser<S> for ExportNameParser {
     }
 }
 
+pub(crate) struct RustSymbolExportLevelParser;
+impl<S: Stage> NoArgsAttributeParser<S> for RustSymbolExportLevelParser {
+    const PATH: &[Symbol] = &[sym::rust_symbol_export_level];
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
+    const CREATE: fn(Span) -> AttributeKind = AttributeKind::RustSymbolExportLevel;
+}
+
 #[derive(Default)]
 pub(crate) struct NakedParser {
     span: Option<Span>,
diff --git a/compiler/rustc_attr_parsing/src/context.rs b/compiler/rustc_attr_parsing/src/context.rs
@@ -18,8 +18,8 @@ use crate::attributes::allow_unstable::{
 };
 use crate::attributes::codegen_attrs::{
     ColdParser, CoverageParser, ExportNameParser, NakedParser, NoMangleParser,
-    OmitGdbPrettyPrinterSectionParser, OptimizeParser, TargetFeatureParser, TrackCallerParser,
-    UsedParser,
+    OmitGdbPrettyPrinterSectionParser, OptimizeParser, RustSymbolExportLevelParser,
+    TargetFeatureParser, TrackCallerParser, UsedParser,
 };
 use crate::attributes::confusables::ConfusablesParser;
 use crate::attributes::deprecation::DeprecationParser;
@@ -194,6 +194,7 @@ attribute_parsers!(
         Single<WithoutArgs<ProcMacroAttributeParser>>,
         Single<WithoutArgs<ProcMacroParser>>,
         Single<WithoutArgs<PubTransparentParser>>,
+        Single<WithoutArgs<RustSymbolExportLevelParser>>,
         Single<WithoutArgs<SpecializationTraitParser>>,
         Single<WithoutArgs<StdInternalSymbolParser>>,
         Single<WithoutArgs<TrackCallerParser>>,
diff --git a/compiler/rustc_codegen_ssa/src/codegen_attrs.rs b/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
@@ -13,6 +13,7 @@ use rustc_hir::{self as hir, LangItem, lang_items};
 use rustc_middle::middle::codegen_fn_attrs::{
     CodegenFnAttrFlags, CodegenFnAttrs, PatchableFunctionEntry,
 };
+use rustc_middle::middle::exported_symbols::SymbolExportLevel;
 use rustc_middle::mir::mono::Linkage;
 use rustc_middle::query::Providers;
 use rustc_middle::span_bug;
@@ -113,6 +114,18 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
                 AttributeKind::ExportName { name, .. } => {
                     codegen_fn_attrs.export_name = Some(*name);
                 }
+                AttributeKind::RustSymbolExportLevel(span) => {
+                    if !tcx.features().rust_symbol_export_level() {
+                        feature_err(
+                            &tcx.sess,
+                            sym::rust_symbol_export_level,
+                            *span,
+                            "`#[rust_symbol_export_level]` is currently unstable",
+                        )
+                        .emit();
+                    }
+                    codegen_fn_attrs.export_level = Some(SymbolExportLevel::Rust);
+                }
                 AttributeKind::Naked(_) => codegen_fn_attrs.flags |= CodegenFnAttrFlags::NAKED,
                 AttributeKind::Align { align, .. } => codegen_fn_attrs.alignment = Some(*align),
                 AttributeKind::LinkName { name, .. } => codegen_fn_attrs.link_name = Some(*name),
@@ -509,6 +522,17 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
         err.emit();
     }
 
+    if codegen_fn_attrs.export_level.is_some() && !codegen_fn_attrs.contains_extern_indicator() {
+        let rust_symbol_export_level_span =
+            find_attr!(attrs, AttributeKind::RustSymbolExportLevel(span) => *span)
+                .unwrap_or_default();
+        tcx.dcx().span_err(
+            rust_symbol_export_level_span,
+            "`#[rust_symbol_export_level]` will be ignored \
+             without `export_name`, `no_mangle`, or similar attribute",
+        );
+    }
+
     if let Some(features) = check_tied_features(
         tcx.sess,
         &codegen_fn_attrs
diff --git a/compiler/rustc_feature/src/builtin_attrs.rs b/compiler/rustc_feature/src/builtin_attrs.rs
@@ -495,6 +495,7 @@ pub static BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
     ungated!(unsafe(Edition2024) export_name, Normal, template!(NameValueStr: "name"), FutureWarnPreceding, EncodeCrossCrate::No),
     ungated!(unsafe(Edition2024) link_section, Normal, template!(NameValueStr: "name"), FutureWarnPreceding, EncodeCrossCrate::No),
     ungated!(unsafe(Edition2024) no_mangle, Normal, template!(Word), WarnFollowing, EncodeCrossCrate::No),
+    ungated!(rust_symbol_export_level, Normal, template!(Word), ErrorPreceding, EncodeCrossCrate::No),
     ungated!(used, Normal, template!(Word, List: "compiler|linker"), WarnFollowing, EncodeCrossCrate::No),
     ungated!(link_ordinal, Normal, template!(List: "ordinal"), ErrorPreceding, EncodeCrossCrate::Yes),
     ungated!(unsafe naked, Normal, template!(Word), WarnFollowing, EncodeCrossCrate::No),
diff --git a/compiler/rustc_feature/src/unstable.rs b/compiler/rustc_feature/src/unstable.rs
@@ -625,6 +625,9 @@ declare_features! (
     (unstable, return_type_notation, "1.70.0", Some(109417)),
     /// Allows `extern "rust-cold"`.
     (unstable, rust_cold_cc, "1.63.0", Some(97544)),
+    /// Allows `#[rust_symbol_export_level]` on definitions of statics and/or functions.
+    /* FIXME / DO NOT SUBMIT - use actual bug number */
+    (unstable, rust_symbol_export_level, "CURRENT_RUSTC_VERSION", Some(123456)),
     /// Allows the use of SIMD types in functions declared in `extern` blocks.
     (unstable, simd_ffi, "1.0.0", Some(27731)),
     /// Allows specialization of implementations (RFC 1210).
diff --git a/compiler/rustc_middle/src/middle/codegen_fn_attrs.rs b/compiler/rustc_middle/src/middle/codegen_fn_attrs.rs
@@ -7,6 +7,7 @@ use rustc_macros::{HashStable, TyDecodable, TyEncodable};
 use rustc_span::Symbol;
 use rustc_target::spec::SanitizerSet;
 
+use crate::middle::exported_symbols::SymbolExportLevel;
 use crate::mir::mono::Linkage;
 use crate::ty::{InstanceKind, TyCtxt};
 
@@ -49,6 +50,10 @@ 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>,
+    /// `None` means to use the default value.  `Some(level)` means that this specific
+    /// level should be used. Typically set to `Some(level)` when
+    /// `#[rust_symbol_export_level]` attribute has been used.
+    pub export_level: Option<SymbolExportLevel>,
     /// The `#[target_feature(enable = "...")]` attribute and the enabled
     /// features (only enabled features are supported right now).
     /// Implied target features have already been applied.
@@ -173,6 +178,7 @@ impl CodegenFnAttrs {
             export_name: None,
             link_name: None,
             link_ordinal: None,
+            export_level: None,
             target_features: vec![],
             safe_target_features: false,
             linkage: None,
diff --git a/compiler/rustc_monomorphize/src/partitioning.rs b/compiler/rustc_monomorphize/src/partitioning.rs
@@ -928,15 +928,17 @@ fn default_visibility(tcx: TyCtxt<'_>, id: DefId, is_generic: bool) -> Visibilit
         return Visibility::Default;
     }
 
-    let export_level = if is_generic {
-        // Generic functions never have export-level C.
-        SymbolExportLevel::Rust
-    } else {
-        match tcx.reachable_non_generics(id.krate).get(&id) {
-            Some(SymbolExportInfo { level: SymbolExportLevel::C, .. }) => SymbolExportLevel::C,
-            _ => SymbolExportLevel::Rust,
+    let export_level = tcx.codegen_fn_attrs(id).export_level.unwrap_or_else(|| {
+        if is_generic {
+            // Generic functions never have export-level C.
+            SymbolExportLevel::Rust
+        } else {
+            match tcx.reachable_non_generics(id.krate).get(&id) {
+                Some(SymbolExportInfo { level: SymbolExportLevel::C, .. }) => SymbolExportLevel::C,
+                _ => SymbolExportLevel::Rust,
+            }
         }
-    };
+    });
 
     match export_level {
         // C-export level items remain at `Default` to allow C code to
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
@@ -237,6 +237,9 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                 Attribute::Parsed(AttributeKind::ExportName { span: attr_span, .. }) => {
                     self.check_export_name(hir_id, *attr_span, span, target)
                 }
+                Attribute::Parsed(AttributeKind::RustSymbolExportLevel { .. }) => {
+                    /* verified in compiler/rustc_codegen_ssa/src/codegen_attrs.rs */
+                }
                 Attribute::Parsed(AttributeKind::Align { align, span: attr_span }) => {
                     self.check_align(span, hir_id, target, *align, *attr_span)
                 }
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
@@ -1806,6 +1806,7 @@ symbols! {
         rust_future,
         rust_logo,
         rust_out,
+        rust_symbol_export_level,
         rustc,
         rustc_abi,
         // FIXME(#82232, #143834): temporary name to mitigate `#[align]` nameres ambiguity
diff --git a/tests/codegen-llvm/rust-symbol-export-level.rs b/tests/codegen-llvm/rust-symbol-export-level.rs
@@ -0,0 +1,90 @@
+// Verifies that `#[rust_symbol_export_level = ...]` can be used to 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 `#[rust_symbol_export_level]` => public
+// * With `#[rust_symbol_export_level]` => 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(rust_symbol_export_level)]
+
+// 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 `#[rust_symbol_export_level]` 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_rust_level")]
+#[rust_symbol_export_level]
+pub static TESTED_STATIC_ATTR_RUST_LEVEL: [u8; 7] = *b"static2";
+
+#[unsafe(no_mangle)]
+pub static test_static_no_mangle_no_attr: [u8; 10] = *b"no_mangle1";
+
+#[unsafe(no_mangle)]
+#[rust_symbol_export_level]
+pub static test_static_no_mangle_rust_level: [u8; 10] = *b"no_mangle2";
+
+// HIDDEN: @test_static_no_attr = local_unnamed_addr constant
+// HIDDEN: @test_static_rust_level = hidden local_unnamed_addr constant
+// HIDDEN: @test_static_no_mangle_no_attr = local_unnamed_addr constant
+// HIDDEN: @test_static_no_mangle_rust_level = hidden local_unnamed_addr constant
+
+// PROTECTED: @test_static_no_attr = local_unnamed_addr constant
+// PROTECTED: @test_static_rust_level = protected local_unnamed_addr constant
+
+///////////////////////////////////////////////////////////////////////
+// The tests below focus on how `#[rust_symbol_export_level]` 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_rust_level")]
+#[rust_symbol_export_level]
+unsafe extern "C" fn test_fn_rust_level() -> u32 {
+    line!()
+}
+
+// HIDDEN: define noundef i32 @test_fn_no_attr
+// HIDDEN: define hidden noundef i32 @test_fn_rust_level
+
+// PROTECTED: define noundef i32 @test_fn_no_attr
+// PROTECTED: define protected noundef i32 @test_fn_rust_level
diff --git a/tests/ui/attributes/rust-symbol-export-level-without-export-name.rs b/tests/ui/attributes/rust-symbol-export-level-without-export-name.rs
@@ -0,0 +1,8 @@
+// This test verfies that `#[rust_symbol_export_level]` cannot be used without
+// either `#[export_name = ...]` or `#[no_mangle]`.
+#![feature(rust_symbol_export_level)]
+#[rust_symbol_export_level]
+//~^ ERROR: `#[rust_symbol_export_level]` will be ignored
+pub static TESTED_STATIC: [u8; 6] = *b"foobar";
+
+fn main() {}
diff --git a/tests/ui/attributes/rust-symbol-export-level-without-export-name.stderr b/tests/ui/attributes/rust-symbol-export-level-without-export-name.stderr
@@ -0,0 +1,8 @@
+error: `#[rust_symbol_export_level]` will be ignored without `export_name`, `no_mangle`, or similar attribute
+  --> $DIR/rust-symbol-export-level-without-export-name.rs:4:1
+   |
+LL | #[rust_symbol_export_level]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/feature-gates/feature-gate-rust-symbol-export-level.rs b/tests/ui/feature-gates/feature-gate-rust-symbol-export-level.rs
@@ -0,0 +1,10 @@
+// This test verfies that `#[rust_symbol_export_level]` cannot be used without
+// opting into the corresponding unstable feature via
+// `#![feature(rust_symbol_export_level)]`.
+#[rust_symbol_export_level] //~ ERROR: `#[rust_symbol_export_level]` is currently unstable
+// `#[export_name = ...]` is present to avoid hitting the following error:
+// ... will be ignored without `export_name`, `no_mangle`, or similar attribute
+#[unsafe(export_name = "exported_static")]
+pub static TESTED_STATIC: [u8; 6] = *b"foobar";
+
+fn main() {}
diff --git a/tests/ui/feature-gates/feature-gate-rust-symbol-export-level.stderr b/tests/ui/feature-gates/feature-gate-rust-symbol-export-level.stderr
@@ -0,0 +1,13 @@
+error[E0658]: `#[rust_symbol_export_level]` is currently unstable
+  --> $DIR/feature-gate-rust-symbol-export-level.rs:4:1
+   |
+LL | #[rust_symbol_export_level]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #123456 <https://github.com/rust-lang/rust/issues/123456> for more information
+   = help: add `#![feature(rust_symbol_export_level)]` 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`.

Original file line number	Diff line number	Diff line change
`@@ -118,6 +118,13 @@ impl<S: Stage> SingleAttributeParser<S> for ExportNameParser {`
`118`	`118`	`}`
`119`	`119`	`}`
`120`	`120`
	`121`	`+pub(crate) struct RustSymbolExportLevelParser;`
	`122`	`+impl<S: Stage> NoArgsAttributeParser<S> for RustSymbolExportLevelParser {`
	`123`	`+ const PATH: &[Symbol] = &[sym::rust_symbol_export_level];`
	`124`	`+ const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;`
	`125`	`+ const CREATE: fn(Span) -> AttributeKind = AttributeKind::RustSymbolExportLevel;`
	`126`	`+}`
	`127`	`+`
`121`	`128`	`#[derive(Default)]`
`122`	`129`	`pub(crate) struct NakedParser {`
`123`	`130`	`span: Option<Span>,`
Original file line number	Diff line number	Diff line change
`@@ -237,6 +237,9 @@ impl<'tcx> CheckAttrVisitor<'tcx> {`
`237`	`237`	`Attribute::Parsed(AttributeKind::ExportName { span: attr_span, .. }) => {`
`238`	`238`	`self.check_export_name(hir_id, *attr_span, span, target)`
`239`	`239`	`}`
	`240`	`+ Attribute::Parsed(AttributeKind::RustSymbolExportLevel { .. }) => {`
	`241`	`+ /* verified in compiler/rustc_codegen_ssa/src/codegen_attrs.rs */`
	`242`	`+ }`
`240`	`243`	`Attribute::Parsed(AttributeKind::Align { align, span: attr_span }) => {`
`241`	`244`	`self.check_align(span, hir_id, target, align, attr_span)`
`242`	`245`	`}`