Rollup of 10 pull requests

compiler/rustc_ast_lowering/src/lib.rs

@@ -1670,7 +1670,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         let output = match coro {
             Some(coro) => {
                 let fn_def_id = self.local_def_id(fn_node_id);
-                self.lower_coroutine_fn_ret_ty(&decl.output, fn_def_id, coro, kind, fn_span)
+                self.lower_coroutine_fn_ret_ty(&decl.output, fn_def_id, coro, kind)
             }
             None => match &decl.output {
                 FnRetTy::Ty(ty) => {
@@ -1755,9 +1755,8 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         fn_def_id: LocalDefId,
         coro: CoroutineKind,
         fn_kind: FnDeclKind,
-        fn_span: Span,
     ) -> hir::FnRetTy<'hir> {
-        let span = self.lower_span(fn_span);
+        let span = self.lower_span(output.span());
 
         let (opaque_ty_node_id, allowed_features) = match coro {
             CoroutineKind::Async { return_impl_trait_id, .. } => (return_impl_trait_id, None),

compiler/rustc_attr_parsing/src/safety.rs

@@ -62,16 +62,28 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
                     Some(unsafe_since) => path_span.edition() >= unsafe_since,
                 };
 
+                let mut not_from_proc_macro = true;
+                if diag_span.from_expansion()
+                    && let Ok(mut snippet) = self.sess.source_map().span_to_snippet(diag_span)
+                {
+                    snippet.retain(|c| !c.is_whitespace());
+                    if snippet.contains("!(") || snippet.starts_with("#[") && snippet.ends_with("]")
+                    {
+                        not_from_proc_macro = false;
+                    }
+                }
+
                 if emit_error {
                     self.stage.emit_err(
                         self.sess,
                         crate::session_diagnostics::UnsafeAttrOutsideUnsafe {
                             span: path_span,
-                            suggestion:
+                            suggestion: not_from_proc_macro.then(|| {
                                 crate::session_diagnostics::UnsafeAttrOutsideUnsafeSuggestion {
                                     left: diag_span.shrink_to_lo(),
                                     right: diag_span.shrink_to_hi(),
-                                },
+                                }
+                            }),
                         },
                     );
                 } else {
@@ -81,7 +93,8 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
                         span: path_span,
                         kind: AttributeLintKind::UnsafeAttrOutsideUnsafe {
                             attribute_name_span: path_span,
-                            sugg_spans: (diag_span.shrink_to_lo(), diag_span.shrink_to_hi()),
+                            sugg_spans: not_from_proc_macro
+                                .then(|| (diag_span.shrink_to_lo(), diag_span.shrink_to_hi())),
                         },
                     })
                 }

compiler/rustc_attr_parsing/src/session_diagnostics.rs

@@ -758,7 +758,7 @@ pub(crate) struct UnsafeAttrOutsideUnsafe {
     #[label]
     pub span: Span,
     #[subdiagnostic]
-    pub suggestion: UnsafeAttrOutsideUnsafeSuggestion,
+    pub suggestion: Option<UnsafeAttrOutsideUnsafeSuggestion>,
 }
 
 #[derive(Subdiagnostic)]

compiler/rustc_codegen_cranelift/src/allocator.rs

@@ -6,7 +6,6 @@ use rustc_ast::expand::allocator::{
     AllocatorMethod, AllocatorTy, NO_ALLOC_SHIM_IS_UNSTABLE, default_fn_name, global_fn_name,
 };
 use rustc_codegen_ssa::base::{allocator_kind_for_codegen, allocator_shim_contents};
-use rustc_session::config::OomStrategy;
 use rustc_symbol_mangling::mangle_internal_symbol;
 
 use crate::prelude::*;
@@ -15,16 +14,11 @@ use crate::prelude::*;
 pub(crate) fn codegen(tcx: TyCtxt<'_>, module: &mut dyn Module) -> bool {
     let Some(kind) = allocator_kind_for_codegen(tcx) else { return false };
     let methods = allocator_shim_contents(tcx, kind);
-    codegen_inner(tcx, module, &methods, tcx.sess.opts.unstable_opts.oom);
+    codegen_inner(tcx, module, &methods);
     true
 }
 
-fn codegen_inner(
-    tcx: TyCtxt<'_>,
-    module: &mut dyn Module,
-    methods: &[AllocatorMethod],
-    oom_strategy: OomStrategy,
-) {
+fn codegen_inner(tcx: TyCtxt<'_>, module: &mut dyn Module, methods: &[AllocatorMethod]) {
     let usize_ty = module.target_config().pointer_type();
 
     for method in methods {
@@ -65,35 +59,6 @@ fn codegen_inner(
         );
     }
 
-    {
-        let sig = Signature {
-            call_conv: module.target_config().default_call_conv,
-            params: vec![],
-            returns: vec![AbiParam::new(types::I8)],
-        };
-        let func_id = module
-            .declare_function(
-                &mangle_internal_symbol(tcx, OomStrategy::SYMBOL),
-                Linkage::Export,
-                &sig,
-            )
-            .unwrap();
-        let mut ctx = Context::new();
-        ctx.func.signature = sig;
-        {
-            let mut func_ctx = FunctionBuilderContext::new();
-            let mut bcx = FunctionBuilder::new(&mut ctx.func, &mut func_ctx);
-
-            let block = bcx.create_block();
-            bcx.switch_to_block(block);
-            let value = bcx.ins().iconst(types::I8, oom_strategy.should_panic() as i64);
-            bcx.ins().return_(&[value]);
-            bcx.seal_all_blocks();
-            bcx.finalize();
-        }
-        module.define_function(func_id, &mut ctx).unwrap();
-    }
-
     {
         let sig = Signature {
             call_conv: module.target_config().default_call_conv,

compiler/rustc_codegen_gcc/src/allocator.rs

@@ -1,12 +1,11 @@
 #[cfg(feature = "master")]
 use gccjit::FnAttribute;
-use gccjit::{Context, FunctionType, RValue, ToRValue, Type};
+use gccjit::{Context, FunctionType, ToRValue, Type};
 use rustc_ast::expand::allocator::{
     AllocatorMethod, AllocatorTy, NO_ALLOC_SHIM_IS_UNSTABLE, default_fn_name, global_fn_name,
 };
 use rustc_middle::bug;
 use rustc_middle::ty::TyCtxt;
-use rustc_session::config::OomStrategy;
 use rustc_symbol_mangling::mangle_internal_symbol;
 
 use crate::GccContext;
@@ -59,14 +58,6 @@ pub(crate) unsafe fn codegen(
         create_wrapper_function(tcx, context, &from_name, Some(&to_name), &types, output);
     }
 
-    create_const_value_function(
-        tcx,
-        context,
-        &mangle_internal_symbol(tcx, OomStrategy::SYMBOL),
-        i8,
-        context.new_rvalue_from_int(i8, tcx.sess.opts.unstable_opts.oom.should_panic() as i32),
-    );
-
     create_wrapper_function(
         tcx,
         context,
@@ -77,34 +68,6 @@ pub(crate) unsafe fn codegen(
     );
 }
 
-fn create_const_value_function(
-    tcx: TyCtxt<'_>,
-    context: &Context<'_>,
-    name: &str,
-    output: Type<'_>,
-    value: RValue<'_>,
-) {
-    let func = context.new_function(None, FunctionType::Exported, output, &[], name, false);
-
-    #[cfg(feature = "master")]
-    {
-        func.add_attribute(FnAttribute::Visibility(symbol_visibility_to_gcc(
-            tcx.sess.default_visibility(),
-        )));
-
-        // FIXME(antoyo): cg_llvm sets AlwaysInline, but AlwaysInline is different in GCC and using
-        // it here will causes linking errors when using LTO.
-        func.add_attribute(FnAttribute::Inline);
-    }
-
-    if tcx.sess.must_emit_unwind_tables() {
-        // TODO(antoyo): emit unwind tables.
-    }
-
-    let block = func.new_block("entry");
-    block.end_with_return(None, value);
-}
-
 fn create_wrapper_function(
     tcx: TyCtxt<'_>,
     context: &Context<'_>,

compiler/rustc_codegen_gcc/src/builder.rs

@@ -500,11 +500,11 @@ impl<'gcc, 'tcx> BackendTypes for Builder<'_, 'gcc, 'tcx> {
 }
 
 fn set_rvalue_location<'a, 'gcc, 'tcx>(
-    bx: &mut Builder<'a, 'gcc, 'tcx>,
+    _bx: &mut Builder<'a, 'gcc, 'tcx>,
     rvalue: RValue<'gcc>,
 ) -> RValue<'gcc> {
-    if let Some(location) = bx.location {
-        #[cfg(feature = "master")]
+    #[cfg(feature = "master")]
+    if let Some(location) = _bx.location {
         rvalue.set_location(location);
     }
     rvalue

compiler/rustc_codegen_llvm/src/allocator.rs

@@ -7,13 +7,13 @@ use rustc_codegen_ssa::traits::BaseTypeCodegenMethods as _;
 use rustc_middle::bug;
 use rustc_middle::middle::codegen_fn_attrs::{CodegenFnAttrFlags, CodegenFnAttrs};
 use rustc_middle::ty::TyCtxt;
-use rustc_session::config::{DebugInfo, OomStrategy};
+use rustc_session::config::DebugInfo;
 use rustc_symbol_mangling::mangle_internal_symbol;
 
 use crate::attributes::llfn_attrs_from_instance;
 use crate::builder::SBuilder;
 use crate::declare::declare_simple_fn;
-use crate::llvm::{self, FALSE, FromGeneric, TRUE, Type, Value};
+use crate::llvm::{self, FromGeneric, TRUE, Type};
 use crate::{SimpleCx, attributes, debuginfo};
 
 pub(crate) unsafe fn codegen(
@@ -28,7 +28,6 @@ pub(crate) unsafe fn codegen(
         64 => cx.type_i64(),
         tws => bug!("Unsupported target word size for int: {}", tws),
     };
-    let i8 = cx.type_i8();
     let i8p = cx.type_ptr();
 
     for method in methods {
@@ -87,17 +86,6 @@ pub(crate) unsafe fn codegen(
         );
     }
 
-    // __rust_alloc_error_handler_should_panic_v2
-    create_const_value_function(
-        tcx,
-        &cx,
-        &mangle_internal_symbol(tcx, OomStrategy::SYMBOL),
-        &i8,
-        unsafe {
-            llvm::LLVMConstInt(i8, tcx.sess.opts.unstable_opts.oom.should_panic() as u64, FALSE)
-        },
-    );
-
     // __rust_no_alloc_shim_is_unstable_v2
     create_wrapper_function(
         tcx,
@@ -117,34 +105,6 @@ pub(crate) unsafe fn codegen(
     }
 }
 
-fn create_const_value_function(
-    tcx: TyCtxt<'_>,
-    cx: &SimpleCx<'_>,
-    name: &str,
-    output: &Type,
-    value: &Value,
-) {
-    let ty = cx.type_func(&[], output);
-    let llfn = declare_simple_fn(
-        &cx,
-        name,
-        llvm::CallConv::CCallConv,
-        llvm::UnnamedAddr::Global,
-        llvm::Visibility::from_generic(tcx.sess.default_visibility()),
-        ty,
-    );
-
-    attributes::apply_to_llfn(
-        llfn,
-        llvm::AttributePlace::Function,
-        &[llvm::AttributeKind::AlwaysInline.create_attr(cx.llcx)],
-    );
-
-    let llbb = unsafe { llvm::LLVMAppendBasicBlockInContext(cx.llcx, llfn, c"entry".as_ptr()) };
-    let mut bx = SBuilder::build(&cx, llbb);
-    bx.ret(value);
-}
-
 fn create_wrapper_function(
     tcx: TyCtxt<'_>,
     cx: &SimpleCx<'_>,

compiler/rustc_codegen_ssa/src/back/symbol_export.rs

@@ -15,7 +15,7 @@ use rustc_middle::middle::exported_symbols::{
 use rustc_middle::query::LocalCrate;
 use rustc_middle::ty::{self, GenericArgKind, GenericArgsRef, Instance, SymbolName, Ty, TyCtxt};
 use rustc_middle::util::Providers;
-use rustc_session::config::{CrateType, OomStrategy};
+use rustc_session::config::CrateType;
 use rustc_symbol_mangling::mangle_internal_symbol;
 use rustc_target::spec::{Arch, Os, TlsModel};
 use tracing::debug;
@@ -493,7 +493,6 @@ pub(crate) fn allocator_shim_symbols(
         .map(move |method| mangle_internal_symbol(tcx, global_fn_name(method.name).as_str()))
         .chain([
             mangle_internal_symbol(tcx, global_fn_name(ALLOC_ERROR_HANDLER).as_str()),
-            mangle_internal_symbol(tcx, OomStrategy::SYMBOL),
             mangle_internal_symbol(tcx, NO_ALLOC_SHIM_IS_UNSTABLE),
         ])
         .map(move |symbol_name| {

compiler/rustc_hir_typeck/src/pat.rs

@@ -2296,7 +2296,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 let suggested_name =
                     find_best_match_for_name(&[field.name], pat_field.ident.name, None);
                 if let Some(suggested_name) = suggested_name {
-                    err.span_suggestion(
+                    err.span_suggestion_verbose(
                         pat_field.ident.span,
                         "a field with a similar name exists",
                         suggested_name,

compiler/rustc_interface/src/tests.rs

@@ -14,10 +14,10 @@ use rustc_session::config::{
     CoverageOptions, DebugInfo, DumpMonoStatsFormat, ErrorOutputType, ExternEntry, ExternLocation,
     Externs, FmtDebug, FunctionReturn, InliningThreshold, Input, InstrumentCoverage,
     InstrumentXRay, LinkSelfContained, LinkerPluginLto, LocationDetail, LtoCli, MirIncludeSpans,
-    NextSolverConfig, Offload, OomStrategy, Options, OutFileName, OutputType, OutputTypes,
-    PAuthKey, PacRet, Passes, PatchableFunctionEntry, Polonius, ProcMacroExecutionStrategy, Strip,
-    SwitchWithOptPath, SymbolManglingVersion, WasiExecModel, build_configuration,
-    build_session_options, rustc_optgroups,
+    NextSolverConfig, Offload, Options, OutFileName, OutputType, OutputTypes, PAuthKey, PacRet,
+    Passes, PatchableFunctionEntry, Polonius, ProcMacroExecutionStrategy, Strip, SwitchWithOptPath,
+    SymbolManglingVersion, WasiExecModel, build_configuration, build_session_options,
+    rustc_optgroups,
 };
 use rustc_session::lint::Level;
 use rustc_session::search_paths::SearchPath;
@@ -839,7 +839,6 @@ fn test_unstable_options_tracking_hash() {
     tracked!(no_unique_section_names, true);
     tracked!(offload, vec![Offload::Enable]);
     tracked!(on_broken_pipe, OnBrokenPipe::Kill);
-    tracked!(oom, OomStrategy::Panic);
     tracked!(osx_rpath_install_name, true);
     tracked!(packed_bundled_libs, true);
     tracked!(panic_abort_tests, true);

compiler/rustc_lint/src/early/diagnostics.rs

@@ -353,14 +353,14 @@ pub fn decorate_attribute_lint(
             }
             .decorate_lint(diag)
         }
-        &AttributeLintKind::UnsafeAttrOutsideUnsafe {
-            attribute_name_span,
-            sugg_spans: (left, right),
-        } => lints::UnsafeAttrOutsideUnsafeLint {
-            span: attribute_name_span,
-            suggestion: lints::UnsafeAttrOutsideUnsafeSuggestion { left, right },
+        &AttributeLintKind::UnsafeAttrOutsideUnsafe { attribute_name_span, sugg_spans } => {
+            lints::UnsafeAttrOutsideUnsafeLint {
+                span: attribute_name_span,
+                suggestion: sugg_spans
+                    .map(|(left, right)| lints::UnsafeAttrOutsideUnsafeSuggestion { left, right }),
+            }
+            .decorate_lint(diag)
         }
-        .decorate_lint(diag),
         &AttributeLintKind::UnexpectedCfgName(name, value) => {
             check_cfg::unexpected_cfg_name(sess, tcx, name, value).decorate_lint(diag)
         }

compiler/rustc_lint/src/lints.rs

@@ -3177,7 +3177,7 @@ pub(crate) struct UnsafeAttrOutsideUnsafeLint {
     #[label]
     pub span: Span,
     #[subdiagnostic]
-    pub suggestion: UnsafeAttrOutsideUnsafeSuggestion,
+    pub suggestion: Option<UnsafeAttrOutsideUnsafeSuggestion>,
 }
 
 #[derive(Subdiagnostic)]

compiler/rustc_lint_defs/src/lib.rs

@@ -729,7 +729,7 @@ pub enum AttributeLintKind {
     },
     UnsafeAttrOutsideUnsafe {
         attribute_name_span: Span,
-        sugg_spans: (Span, Span),
+        sugg_spans: Option<(Span, Span)>,
     },
     UnexpectedCfgName((Symbol, Span), Option<(Symbol, Span)>),
     UnexpectedCfgValue((Symbol, Span), Option<(Symbol, Span)>),

compiler/rustc_resolve/src/diagnostics.rs

@@ -1964,7 +1964,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             };
             (span, msg, suggestion.candidate.to_ident_string())
         };
-        err.span_suggestion(span, msg, sugg, Applicability::MaybeIncorrect);
+        err.span_suggestion_verbose(span, msg, sugg, Applicability::MaybeIncorrect);
         true
     }