Rollup of 9 pull requests

compiler/rustc/src/main.rs

@@ -1,7 +1,5 @@
 // We need this feature as it changes `dylib` linking behavior and allows us to link to `rustc_driver`.
 #![feature(rustc_private)]
-// Several crates are depended upon but unused so that they are present in the sysroot
-#![expect(unused_crate_dependencies)]
 
 use std::process::ExitCode;
 

compiler/rustc_arena/src/lib.rs

@@ -10,7 +10,6 @@
 // tidy-alphabetical-start
 #![allow(clippy::mut_from_ref)] // Arena allocators are one place where this pattern is fine.
 #![allow(internal_features)]
-#![cfg_attr(bootstrap, feature(never_type))]
 #![cfg_attr(bootstrap, feature(unwrap_infallible))]
 #![cfg_attr(test, feature(test))]
 #![deny(unsafe_op_in_unsafe_fn)]

compiler/rustc_ast_ir/src/lib.rs

@@ -7,7 +7,6 @@
 
 // tidy-alphabetical-start
 #![cfg_attr(feature = "nightly", allow(internal_features))]
-#![cfg_attr(feature = "nightly", cfg_attr(bootstrap, feature(never_type)))]
 #![cfg_attr(feature = "nightly", feature(rustc_attrs))]
 // tidy-alphabetical-end
 

compiler/rustc_attr_ir/src/attribute_docs.rs

@@ -12,7 +12,7 @@ macro_rules! include_example {
     };
 }
 
-#[cfg_attr(not(bootstrap), doc(attribute = "rustc_dump_clauses"))]
+#[doc(attribute = "rustc_dump_clauses")]
 /// Dumps the list of [`ty::Clause`]s as computed by the [`clauses_of`] query.
 ///
 /// See [`AttributeKind::RustcDumpClauses`] for the internal representation of this attribute.

compiler/rustc_attr_ir/src/data_structures.rs

@@ -283,7 +283,6 @@ impl<ScopeId> StrippedCfgItem<ScopeId> {
 #[derive(StableHash, PrintAttribute)]
 pub enum Linkage {
     AvailableExternally,
-    Common,
     ExternalWeak,
     External,
     Internal,

compiler/rustc_attr_ir/src/encode_cross_crate.rs

@@ -265,7 +265,6 @@ impl AttributeKind {
             Linkage(linkage, _) => match *linkage {
                 crate::Linkage::Internal => false,
                 crate::Linkage::AvailableExternally
-                | crate::Linkage::Common
                 | crate::Linkage::External
                 | crate::Linkage::ExternalWeak
                 | crate::Linkage::LinkOnceAny

compiler/rustc_attr_parsing/src/attributes/link_attrs.rs

@@ -685,10 +685,7 @@ impl SingleAttributeParser for LinkageParser {
     ]);
     const TEMPLATE: AttributeTemplate = template!(NameValueStr: [
         "available_externally",
-        "common",
         "extern_weak",
-        "external",
-        "internal",
         "linkonce",
         "linkonce_odr",
         "weak",
@@ -711,10 +708,7 @@ impl SingleAttributeParser for LinkageParser {
         // and don't have to be, LLVM treats them as no-ops.
         let linkage = match value {
             sym::available_externally => Linkage::AvailableExternally,
-            sym::common => Linkage::Common,
             sym::extern_weak => Linkage::ExternalWeak,
-            sym::external => Linkage::External,
-            sym::internal => Linkage::Internal,
             sym::linkonce => Linkage::LinkOnceAny,
             sym::linkonce_odr => Linkage::LinkOnceODR,
             sym::weak => Linkage::WeakAny,
@@ -725,10 +719,7 @@ impl SingleAttributeParser for LinkageParser {
                     name_value.value_span,
                     &[
                         sym::available_externally,
-                        sym::common,
                         sym::extern_weak,
-                        sym::external,
-                        sym::internal,
                         sym::linkonce,
                         sym::linkonce_odr,
                         sym::weak,

compiler/rustc_attr_parsing/src/attributes/macro_attrs.rs

@@ -1,10 +1,11 @@
+use rustc_ast::ItemKind;
 use rustc_attr_ir::{MacroUseArgs, find_attr};
 use rustc_feature::AttributeStability;
-use rustc_lint_defs::builtin::INVALID_MACRO_EXPORT_ARGUMENTS;
+use rustc_lint_defs::builtin::{INVALID_MACRO_EXPORT_ARGUMENTS, UNUSED_ATTRIBUTES};
 use rustc_structures::CollapseMacroDebuginfo;
 
 use super::prelude::*;
-use crate::diagnostics::MacroOnlyAttribute;
+use crate::diagnostics::{MacroExport, MacroOnlyAttribute};
 
 pub(crate) struct MacroEscapeParser;
 impl NoArgsAttributeParser for MacroEscapeParser {
@@ -175,8 +176,22 @@ impl SingleAttributeParser for MacroExportParser {
                 return None;
             }
         };
+
         Some(AttributeKind::MacroExport { span: cx.attr_span, local_inner_macros })
     }
+
+    fn finalize_check(cx: &mut FinalizeCheckContext<'_, '_>, attr_span: Span) {
+        if cx.target != Target::MacroDef {
+            return;
+        }
+
+        let item = cx.target_item.unwrap();
+        if let ItemKind::MacroDef(_, macro_def) = &item.kind
+            && !macro_def.macro_rules
+        {
+            cx.emit_lint(UNUSED_ATTRIBUTES, MacroExport::OnDeclMacro, attr_span);
+        }
+    }
 }
 
 pub(crate) struct CollapseDebugInfoParser;

compiler/rustc_attr_parsing/src/diagnostics.rs

@@ -2070,3 +2070,10 @@ pub(crate) struct UnusedDuplicate {
     )]
     pub warning: bool,
 }
+
+#[derive(Diagnostic)]
+pub(crate) enum MacroExport {
+    #[diag("`#[macro_export]` has no effect on declarative macro definitions")]
+    #[note("declarative macros follow the same exporting rules as regular items")]
+    OnDeclMacro,
+}

compiler/rustc_attr_parsing/src/interface.rs

@@ -510,23 +510,25 @@ impl<'sess> AttributeParser<'sess> {
 
         // Now that all attributes have been parsed, run the deferred checks. These can
         // inspect the fully parsed attributes via `FinalizeCheckContext::parsed_attrs`.
-        for (check, attr_span) in deferred_checks {
-            check(
-                &mut FinalizeCheckContext {
-                    shared: SharedContext {
-                        cx: self,
-                        target_span,
-                        target,
-                        emit_lint: &mut emit_lint,
-                        #[cfg(debug_assertions)]
-                        has_lint_been_emitted: AtomicBool::new(false),
+        if !matches!(self.should_emit, ShouldEmit::Nothing) {
+            for (check, attr_span) in deferred_checks {
+                check(
+                    &mut FinalizeCheckContext {
+                        shared: SharedContext {
+                            cx: self,
+                            target_span,
+                            target,
+                            emit_lint: &mut emit_lint,
+                            #[cfg(debug_assertions)]
+                            has_lint_been_emitted: AtomicBool::new(false),
+                        },
+                        all_attrs: &attr_paths,
+                        parsed_attrs: &attributes,
+                        target_item,
                     },
-                    all_attrs: &attr_paths,
-                    parsed_attrs: &attributes,
-                    target_item,
-                },
-                attr_span,
-            );
+                    attr_span,
+                );
+            }
         }
 
         if !matches!(self.should_emit, ShouldEmit::Nothing) && target == Target::WherePredicate {

compiler/rustc_borrowck/src/lib.rs

@@ -2,7 +2,6 @@
 
 // tidy-alphabetical-start
 #![allow(internal_features)]
-#![cfg_attr(bootstrap, feature(never_type))]
 #![feature(default_field_values)]
 #![feature(deref_patterns)]
 #![feature(file_buffered)]

compiler/rustc_codegen_gcc/src/base.rs

@@ -55,19 +55,14 @@ pub fn global_linkage_to_gcc(linkage: Linkage) -> GlobalKind {
         | Linkage::LinkOnceODR
         | Linkage::WeakAny
         | Linkage::WeakODR
-        | Linkage::ExternalWeak
-        | Linkage::Common => GlobalKind::Exported,
+        | Linkage::ExternalWeak => GlobalKind::Exported,
     }
 }
 
 /// The attribute a global *definition* needs on top of its [`GlobalKind`] to get this linkage.
 #[cfg(feature = "master")]
 pub fn global_linkage_attribute<'gcc>(linkage: Linkage) -> Option<VarAttribute<'gcc>> {
-    match linkage {
-        Linkage::Common => Some(VarAttribute::Common),
-        _ if linkage_needs_weak_attribute(linkage) => Some(VarAttribute::Weak),
-        _ => None,
-    }
+    if linkage_needs_weak_attribute(linkage) { Some(VarAttribute::Weak) } else { None }
 }
 
 /// The type of a function *definition* with an explicit `#[linkage]`.
@@ -85,26 +80,20 @@ pub fn linkage_to_gcc(linkage: Linkage) -> FunctionType {
         | Linkage::LinkOnceODR
         | Linkage::WeakAny
         | Linkage::WeakODR
-        | Linkage::ExternalWeak
-        | Linkage::Common => FunctionType::Exported,
+        | Linkage::ExternalWeak => FunctionType::Exported,
     }
 }
 
 /// Whether a definition with this linkage must carry the `weak` attribute, so that a strong
 /// definition in another object file wins over it instead of clashing with it.
-///
-/// `common` is in here for functions only: GCC honours that attribute on a variable, but drops it
-/// on a function, so a common function falls back to weak. Globals go through
-/// `global_linkage_attribute` instead.
 #[cfg(feature = "master")]
 pub fn linkage_needs_weak_attribute(linkage: Linkage) -> bool {
     match linkage {
         Linkage::LinkOnceAny
         | Linkage::LinkOnceODR
         | Linkage::WeakAny
         | Linkage::WeakODR
-        | Linkage::ExternalWeak
-        | Linkage::Common => true,
+        | Linkage::ExternalWeak => true,
         Linkage::External | Linkage::AvailableExternally | Linkage::Internal => false,
     }
 }

compiler/rustc_codegen_gcc/src/consts.rs

@@ -13,8 +13,7 @@ use rustc_hir::def_id::LOCAL_CRATE;
 use rustc_log::tracing::trace;
 use rustc_middle::middle::codegen_fn_attrs::{CodegenFnAttrFlags, CodegenFnAttrs};
 use rustc_middle::mir::interpret::{
-    self, Allocation, ConstAllocation, CtfeProvenance, ErrorHandled, Scalar as InterpScalar,
-    read_target_uint,
+    self, ConstAllocation, CtfeProvenance, ErrorHandled, Scalar as InterpScalar, read_target_uint,
 };
 use rustc_middle::mono::MonoItem;
 use rustc_middle::ty::layout::LayoutOf;
@@ -113,12 +112,7 @@ impl<'gcc, 'tcx> StaticCodegenMethods for CodegenCx<'gcc, 'tcx> {
         // NOTE: Alignment from attributes has already been applied to the allocation.
         set_global_alignment(self, global, alloc.align);
 
-        // A common symbol is storage the linker allocates and zero-fills, so giving the definition
-        // an initializer — even an all-zero one — takes it back out of `.comm`. A non-zero one is
-        // kept: the symbol is then an ordinary definition, which is what GCC does with it too.
-        if attrs.linkage != Some(Linkage::Common) || !is_zero_initializer(alloc) {
-            global.global_set_initializer_rvalue(value);
-        }
+        global.global_set_initializer_rvalue(value);
 
         // As an optimization, all shared statics which do not have interior
         // mutability are placed into read-only memory.
@@ -458,17 +452,6 @@ pub(crate) fn const_alloc_to_gcc_uncached<'gcc>(
     cx.const_struct(&llvals, true)
 }
 
-/// Whether this allocation is all zeroes, and so needs no initializer to be spelled out.
-fn is_zero_initializer(alloc: &Allocation) -> bool {
-    alloc.provenance().ptrs().is_empty()
-        // This `inspect` is okay: it is within the bounds of the allocation, there is no provenance
-        // to misread, and it does not affect interpreter execution.
-        && alloc
-            .inspect_with_uninit_and_ptr_outside_interpreter(0..alloc.size().bytes_usize())
-            .iter()
-            .all(|&byte| byte == 0)
-}
-
 fn codegen_static_initializer<'gcc, 'tcx>(
     cx: &CodegenCx<'gcc, 'tcx>,
     def_id: DefId,

compiler/rustc_codegen_gcc/tests/c/import_linkage.c

@@ -6,12 +6,9 @@
 
 #include <stdint.h>
 
-int32_t external_value = 1;
 int32_t available_externally_value = 2;
 int32_t linkonce_value = 3;
 int32_t linkonce_odr_value = 4;
 int32_t weak_value = 5;
 int32_t weak_odr_value = 6;
-int32_t common_value = 7;
 int32_t extern_weak_value = 8;
-int32_t internal_value = 9;

compiler/rustc_codegen_gcc/tests/c/static_linkage.c

@@ -1,18 +1,13 @@
 /* Strong definitions of the statics that `tests/run/static_linkage.rs` also defines, but weakly.
  * The linker has to keep these and drop the Rust ones; a backend that emits the Rust definitions
- * as ordinary global symbols fails the link with a duplicate definition instead.
- *
- * `internal_static` is the opposite case: the Rust side keeps its own, and the two definitions
- * coexist because the Rust one is local. */
+ * as ordinary global symbols fails the link with a duplicate definition instead. */
 
 #include <stdint.h>
 
 int32_t weak_static = 1;
 int32_t weak_odr_static = 2;
 int32_t linkonce_static = 3;
 int32_t linkonce_odr_static = 4;
-int32_t common_static = 5;
-int32_t internal_static = 200;
 
 /* `available_externally` promises the real definition lives elsewhere: a backend may read this one
  * or emit an equivalent copy of the Rust initializer, so the two have to hold the same value. */
@@ -29,9 +24,5 @@ int32_t c_read_all(void)
         return 13;
     if (linkonce_odr_static != 4)
         return 14;
-    if (common_static != 5)
-        return 15;
-    if (internal_static != 200)
-        return 16;
     return 0;
 }

compiler/rustc_codegen_gcc/tests/run/import_linkage.rs

@@ -19,8 +19,6 @@ extern crate mini_core;
 use mini_core::*;
 
 extern "C" {
-    #[linkage = "external"]
-    static external_value: *const i32;
     #[linkage = "available_externally"]
     static available_externally_value: *const i32;
     #[linkage = "linkonce"]
@@ -31,15 +29,8 @@ extern "C" {
     static weak_value: *const i32;
     #[linkage = "weak_odr"]
     static weak_odr_value: *const i32;
-    #[linkage = "common"]
-    static common_value: *const i32;
     #[linkage = "extern_weak"]
     static extern_weak_value: *const i32;
-    // An import is an undefined reference whatever the flavour says. Upstream bug: rustc lowers
-    // this one to an internal declaration, which LLVM's verifier rejects ("Global is external, but
-    // doesn't have external or weak linkage!") and which crashes cg_llvm at -O3.
-    #[linkage = "internal"]
-    static internal_value: *const i32;
 
     // Nothing defines this one, so it stays null instead of breaking the link.
     #[linkage = "extern_weak"]
@@ -49,9 +40,6 @@ extern "C" {
 #[no_mangle]
 extern "C" fn main(_argc: i32, _argv: *const *const u8) -> i32 {
     unsafe {
-        if *external_value != 1 {
-            return 1;
-        }
         if *available_externally_value != 2 {
             return 2;
         }
@@ -67,15 +55,9 @@ extern "C" fn main(_argc: i32, _argv: *const *const u8) -> i32 {
         if *weak_odr_value != 6 {
             return 6;
         }
-        if *common_value != 7 {
-            return 7;
-        }
         if *extern_weak_value != 8 {
             return 8;
         }
-        if *internal_value != 9 {
-            return 9;
-        }
         if undefined_value as usize != 0 {
             return 10;
         }