Rollup of 10 pull requests

compiler/rustc_driver_impl/src/lib.rs

@@ -231,28 +231,21 @@ pub fn run_compiler(at_args: &[String], callbacks: &mut (dyn Callbacks + Send))
         let sess = &compiler.sess;
         let codegen_backend = &*compiler.codegen_backend;
 
-        // This is used for early exits unrelated to errors. E.g. when just
-        // printing some information without compiling, or exiting immediately
-        // after parsing, etc.
-        let early_exit = || {
-            sess.dcx().abort_if_errors();
-        };
-
         // This implements `-Whelp`. It should be handled very early, like
         // `--help`/`-Zhelp`/`-Chelp`. This is the earliest it can run, because
         // it must happen after lints are registered, during session creation.
         if sess.opts.describe_lints {
             describe_lints(sess, registered_lints);
-            return early_exit();
+            return;
         }
 
         // We have now handled all help options, exit
         if help_only {
-            return early_exit();
+            return;
         }
 
         if print_crate_info(codegen_backend, sess, has_input) == Compilation::Stop {
-            return early_exit();
+            return;
         }
 
         if !has_input {
@@ -261,12 +254,12 @@ pub fn run_compiler(at_args: &[String], callbacks: &mut (dyn Callbacks + Send))
 
         if !sess.opts.unstable_opts.ls.is_empty() {
             list_metadata(sess, &*codegen_backend.metadata_loader());
-            return early_exit();
+            return;
         }
 
         if sess.opts.unstable_opts.link_only {
             process_rlink(sess, compiler);
-            return early_exit();
+            return;
         }
 
         // Parse the crate root source code (doesn't parse submodules yet)
@@ -285,28 +278,23 @@ pub fn run_compiler(at_args: &[String], callbacks: &mut (dyn Callbacks + Send))
                 pretty::print(sess, pp_mode, pretty::PrintExtra::AfterParsing { krate: &krate });
             }
             trace!("finished pretty-printing");
-            return early_exit();
+            return;
         }
 
         if callbacks.after_crate_root_parsing(compiler, &mut krate) == Compilation::Stop {
-            return early_exit();
+            return;
         }
 
         if sess.opts.unstable_opts.parse_crate_root_only {
-            return early_exit();
+            return;
         }
 
         let linker = create_and_enter_global_ctxt(compiler, krate, |tcx| {
-            let early_exit = || {
-                sess.dcx().abort_if_errors();
-                None
-            };
-
             // Make sure name resolution and macro expansion is run.
             let _ = tcx.resolver_for_lowering();
 
             if callbacks.after_expansion(compiler, tcx) == Compilation::Stop {
-                return early_exit();
+                return None;
             }
 
             passes::write_dep_info(tcx);
@@ -316,11 +304,11 @@ pub fn run_compiler(at_args: &[String], callbacks: &mut (dyn Callbacks + Send))
             if sess.opts.output_types.contains_key(&OutputType::DepInfo)
                 && sess.opts.output_types.len() == 1
             {
-                return early_exit();
+                return None;
             }
 
             if sess.opts.unstable_opts.no_analysis {
-                return early_exit();
+                return None;
             }
 
             tcx.ensure_ok().analysis(());
@@ -330,16 +318,16 @@ pub fn run_compiler(at_args: &[String], callbacks: &mut (dyn Callbacks + Send))
             }
 
             if callbacks.after_analysis(compiler, tcx) == Compilation::Stop {
-                return early_exit();
+                return None;
             }
 
-            if tcx.sess.opts.output_types.contains_key(&OutputType::Mir) {
+            if sess.opts.output_types.contains_key(&OutputType::Mir) {
                 if let Err(error) = pretty::emit_mir(tcx) {
                     tcx.dcx().emit_fatal(CantEmitMIR { error });
                 }
             }
 
-            let linker = Linker::codegen_and_build_linker(tcx, &*compiler.codegen_backend);
+            let linker = Linker::codegen_and_build_linker(tcx, codegen_backend);
 
             tcx.report_unused_features();
 

compiler/rustc_lint/src/lints.rs

@@ -846,7 +846,7 @@ pub(crate) enum RedefiningRuntimeSymbolsDiag<'tcx> {
     #[help(
         "either fix the signature or remove any attributes like `#[unsafe(no_mangle)]`, `#[unsafe(export_name = \"{$symbol_name}\")]`, or `#[link_name = \"{$symbol_name}\"]`"
     )]
-    FnDefInvalid { symbol_name: String, expected_fn_sig: Ty<'tcx>, found_fn_sig: Ty<'tcx> },
+    Invalid { symbol_name: String, expected_fn_sig: Ty<'tcx>, found_fn_sig: Ty<'tcx> },
     #[diag(
         "suspicious definition of the runtime `{$symbol_name}` symbol used by the standard library"
     )]
@@ -858,18 +858,7 @@ pub(crate) enum RedefiningRuntimeSymbolsDiag<'tcx> {
         "either fix the signature or remove any attributes like `#[unsafe(no_mangle)]`, `#[unsafe(export_name = \"{$symbol_name}\")]`, or `#[link_name = \"{$symbol_name}\"]`"
     )]
     #[help("allow this lint if the signature is compatible")]
-    FnDefSuspicious { symbol_name: String, expected_fn_sig: Ty<'tcx>, found_fn_sig: Ty<'tcx> },
-    #[diag(
-        "invalid definition of the runtime `{$symbol_name}` symbol used by the standard library"
-    )]
-    #[note(
-        "expected `{$expected_fn_sig}`
-    found    `static {$symbol_name}: {$static_ty}`"
-    )]
-    #[help(
-        "either fix the signature or remove any attributes `#[unsafe(no_mangle)]` or `#[unsafe(export_name = \"{$symbol_name}\")]`"
-    )]
-    Static { symbol_name: String, static_ty: Ty<'tcx>, expected_fn_sig: Ty<'tcx> },
+    Suspicious { symbol_name: String, expected_fn_sig: Ty<'tcx>, found_fn_sig: Ty<'tcx> },
 }
 
 // drop_forget_useless.rs

compiler/rustc_lint/src/runtime_symbols.rs

@@ -1,7 +1,7 @@
 use rustc_hir::def_id::LocalDefId;
 use rustc_hir::{self as hir, CanonicalSymbol, FnSig, ForeignItemKind};
 use rustc_infer::infer::DefineOpaqueTypes;
-use rustc_middle::ty::{self, Instance, Ty};
+use rustc_middle::ty::{self, Instance, PolyFnSig, Ty};
 use rustc_session::{declare_lint, declare_lint_pass};
 use rustc_span::{Span, Symbol};
 use rustc_trait_selection::infer::TyCtxtInferExt;
@@ -125,7 +125,10 @@ impl<'tcx> LateLintPass<'tcx> for RuntimeSymbols {
                             check_fn(cx, &symbol_name.name, fn_sig, did);
                         }
                         ForeignItemKind::Static(..) => {
-                            check_static(cx, &symbol_name.name, did, item.span);
+                            // We only check static with #[linkage = "..."] attribute (see std weak! macro)
+                            if cx.tcx.codegen_fn_attrs(did).import_linkage.is_some() {
+                                check_static(cx, &symbol_name.name, did, item.span);
+                            }
                         }
                         ForeignItemKind::Type => return,
                     }
@@ -154,13 +157,72 @@ fn check_fn(cx: &LateContext<'_>, symbol_name: &str, sig: FnSig<'_>, did: LocalD
         .tcx
         .normalize_erasing_regions(cx.typing_env(), cx.tcx.fn_sig(did).instantiate_identity());
 
+    check(cx, symbol_name, did, sig.span, lang_sig, user_sig);
+}
+
+fn check_static<'tcx>(cx: &LateContext<'tcx>, symbol_name: &str, did: LocalDefId, sp: Span) {
+    let s = Symbol::intern(symbol_name);
+    let Some(CanonicalSymbol { symbol: _, def_id: expected_def_id }) =
+        cx.tcx.all_canonical_symbols(()).iter().find(|cs| cs.symbol == s)
+    else {
+        // The symbol name does not correspond to a runtime symbols, bail out
+        return;
+    };
+
+    // Get the expected symbol function signature
+    let lang_sig = cx.tcx.normalize_erasing_regions(
+        cx.typing_env(),
+        cx.tcx.fn_sig(expected_def_id).instantiate_identity(),
+    );
+
+    // Get the static type
+    let outer_user_sig = cx.tcx.type_of(did).instantiate_identity().skip_norm_wip();
+
+    // Peel Option<...> and get the inner type (see std weak! macro with #[linkage = "extern_weak"])
+    let user_sig: Ty<'_> = match outer_user_sig.kind() {
+        ty::Adt(def, args) if Some(def.did()) == cx.tcx.lang_items().option_type() => {
+            args.type_at(0)
+        }
+        _ => outer_user_sig,
+    };
+
+    let user_sig = if let ty::FnPtr(sig_tys, hdr) = user_sig.kind() {
+        sig_tys.with(*hdr)
+    } else {
+        // not a function pointer, report an error
+
+        let lang_sig = Ty::new_fn_ptr(cx.tcx, lang_sig);
+        cx.emit_span_lint(
+            INVALID_RUNTIME_SYMBOL_DEFINITIONS,
+            sp,
+            RedefiningRuntimeSymbolsDiag::Invalid {
+                symbol_name: symbol_name.to_string(),
+                found_fn_sig: user_sig,
+                expected_fn_sig: lang_sig,
+            },
+        );
+        return;
+    };
+
+    // Compare the signatures and report a warning/error depending on the mismatch
+    check(cx, symbol_name, did, sp, lang_sig, user_sig);
+}
+
+fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    symbol_name: &str,
+    did: LocalDefId,
+    sp: Span,
+    lang_sig: PolyFnSig<'tcx>,
+    user_sig: PolyFnSig<'tcx>,
+) {
     // Compare the two signatures with an inference context
     let infcx = cx.tcx.infer_ctxt().build(cx.typing_mode());
-    let cause = rustc_middle::traits::ObligationCause::misc(sig.span, did);
+    let cause = rustc_middle::traits::ObligationCause::misc(sp, did);
     let result = infcx.at(&cause, cx.param_env).eq(DefineOpaqueTypes::No, lang_sig, user_sig);
 
     // If they don't match, emit our own mismatch signatures
-    if let Err(_terr) = result {
+    if result.is_err() {
         // Create fn pointers for diagnostics purpose
         let expected = Ty::new_fn_ptr(cx.tcx, lang_sig);
         let actual = Ty::new_fn_ptr(cx.tcx, user_sig);
@@ -173,8 +235,8 @@ fn check_fn(cx: &LateContext<'_>, symbol_name: &str, sig: FnSig<'_>, did: LocalD
         {
             cx.emit_span_lint(
                 INVALID_RUNTIME_SYMBOL_DEFINITIONS,
-                sig.span,
-                RedefiningRuntimeSymbolsDiag::FnDefInvalid {
+                sp,
+                RedefiningRuntimeSymbolsDiag::Invalid {
                     symbol_name: symbol_name.to_string(),
                     found_fn_sig: actual,
                     expected_fn_sig: expected,
@@ -183,8 +245,8 @@ fn check_fn(cx: &LateContext<'_>, symbol_name: &str, sig: FnSig<'_>, did: LocalD
         } else {
             cx.emit_span_lint(
                 SUSPICIOUS_RUNTIME_SYMBOL_DEFINITIONS,
-                sig.span,
-                RedefiningRuntimeSymbolsDiag::FnDefSuspicious {
+                sp,
+                RedefiningRuntimeSymbolsDiag::Suspicious {
                     symbol_name: symbol_name.to_string(),
                     found_fn_sig: actual,
                     expected_fn_sig: expected,
@@ -193,45 +255,3 @@ fn check_fn(cx: &LateContext<'_>, symbol_name: &str, sig: FnSig<'_>, did: LocalD
         };
     }
 }
-
-fn check_static<'tcx>(cx: &LateContext<'tcx>, symbol_name: &str, did: LocalDefId, sp: Span) {
-    let s = Symbol::intern(symbol_name);
-    let Some(CanonicalSymbol { symbol: _, def_id: expected_def_id }) =
-        cx.tcx.all_canonical_symbols(()).iter().find(|cs| cs.symbol == s)
-    else {
-        // The symbol name does not correspond to a runtime symbols, bail out
-        return;
-    };
-
-    // Get the static type
-    let static_ty = cx.tcx.type_of(did).instantiate_identity().skip_norm_wip();
-
-    // Peel Option<...> and get the inner type (see std weak! macro with #[linkage = "extern_weak"])
-    let inner_static_ty: Ty<'_> = match static_ty.kind() {
-        ty::Adt(def, args) if Some(def.did()) == cx.tcx.lang_items().option_type() => {
-            args.type_at(0)
-        }
-        _ => static_ty,
-    };
-
-    // Get the expected symbol function signature
-    let lang_sig = cx.tcx.normalize_erasing_regions(
-        cx.typing_env(),
-        cx.tcx.fn_sig(expected_def_id).instantiate_identity(),
-    );
-
-    let expected = Ty::new_fn_ptr(cx.tcx, lang_sig);
-
-    // Compare the expected function signature with the static type, report an error if they don't match
-    if expected != inner_static_ty {
-        cx.emit_span_lint(
-            INVALID_RUNTIME_SYMBOL_DEFINITIONS,
-            sp,
-            RedefiningRuntimeSymbolsDiag::Static {
-                static_ty,
-                symbol_name: symbol_name.to_string(),
-                expected_fn_sig: expected,
-            },
-        );
-    }
-}