Rollup of 11 pull requests

compiler/rustc_abi/src/lib.rs

@@ -51,7 +51,7 @@ use rustc_data_structures::stable_hash::StableOrd;
 #[cfg(feature = "nightly")]
 use rustc_error_messages::{DiagArgValue, IntoDiagArg};
 #[cfg(feature = "nightly")]
-use rustc_errors::{Diag, DiagCtxtHandle, Diagnostic, EmissionGuarantee, Level, msg};
+use rustc_errors::{Diag, DiagCtxtHandle, Diagnostic, Level, msg};
 use rustc_hashes::Hash64;
 use rustc_index::{Idx, IndexSlice, IndexVec};
 #[cfg(feature = "nightly")]
@@ -399,7 +399,7 @@ pub enum TargetDataLayoutError<'a> {
 }
 
 #[cfg(feature = "nightly")]
-impl<G: EmissionGuarantee> Diagnostic<'_, G> for TargetDataLayoutError<'_> {
+impl<G> Diagnostic<'_, G> for TargetDataLayoutError<'_> {
     fn into_diag(self, dcx: DiagCtxtHandle<'_>, level: Level) -> Diag<'_, G> {
         match self {
             TargetDataLayoutError::InvalidAddressSpace { addr_space, err, cause } => {

compiler/rustc_ast_lowering/src/item.rs

@@ -800,9 +800,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
     fn lower_variant(&mut self, item_kind: &ItemKind, v: &Variant) -> hir::Variant<'hir> {
         if v.ident.name == kw::Underscore && self.tcx.features().unnamed_enum_variants() {
             // FIXME(#156628): lower unnamed enum variants to HIR.
-            self.dcx()
-                .struct_span_fatal(v.span, "unnamed enum variants are not yet implemented")
-                .emit()
+            self.dcx().span_fatal(v.span, "unnamed enum variants are not yet implemented");
         }
         let hir_id = self.lower_node_id(v.id);
         self.lower_attrs(hir_id, &v.attrs, v.span, Target::Variant);

compiler/rustc_ast_lowering/src/lib.rs

@@ -1798,9 +1798,9 @@ impl<'hir> LoweringContext<'_, 'hir> {
         if expr::WillCreateDefIdsVisitor.visit_expr(expr).is_break() {
             // FIXME(mgca): make this non-fatal once we have a better way to handle
             // nested items in invalid `direct_const_arg!()` arguments.
-            self.dcx().struct_span_fatal(span, msg).emit()
+            self.dcx().span_fatal(span, msg)
         } else {
-            self.dcx().struct_span_err(span, msg).emit()
+            self.dcx().span_err(span, msg)
         }
     }
 
@@ -2960,9 +2960,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 let literal = self.lower_lit(literal, span);
 
                 let kind = if !matches!(literal.node, LitKind::Int(..)) {
-                    let err =
-                        self.dcx().struct_span_err(expr.span, "negated literal must be an integer");
-                    hir::ConstArgKind::Error(err.emit())
+                    let err = self.dcx().span_err(expr.span, "negated literal must be an integer");
+                    hir::ConstArgKind::Error(err)
                 } else {
                     hir::ConstArgKind::Literal { lit: literal.node, negated: true }
                 };
@@ -3366,9 +3365,9 @@ impl UnrepresentableConstArgError {
             // FIXME(mgca): make this non-fatal once we have a better way to handle
             // nested items in const args
             // Issue: https://github.com/rust-lang/rust/issues/154539
-            lowering_context.dcx().struct_span_fatal(self.span, msg).emit()
+            lowering_context.dcx().span_fatal(self.span, msg)
         } else {
-            lowering_context.dcx().struct_span_err(self.span, msg).emit()
+            lowering_context.dcx().span_err(self.span, msg)
         };
 
         ConstArg {

compiler/rustc_ast_passes/src/diagnostics.rs

@@ -2,7 +2,7 @@
 
 use rustc_abi::ExternAbi;
 use rustc_errors::codes::*;
-use rustc_errors::{Applicability, Diag, EmissionGuarantee, Subdiagnostic};
+use rustc_errors::{Applicability, Diag, Subdiagnostic};
 use rustc_macros::{Diagnostic, Subdiagnostic};
 use rustc_span::{Ident, Span, Symbol};
 
@@ -663,7 +663,7 @@ pub(crate) struct EmptyLabelManySpans(pub Vec<Span>);
 
 // The derive for `Vec<Span>` does multiple calls to `span_label`, adding commas between each
 impl Subdiagnostic for EmptyLabelManySpans {
-    fn add_to_diag<G: EmissionGuarantee>(self, diag: &mut Diag<'_, G>) {
+    fn add_to_diag<G>(self, diag: &mut Diag<'_, G>) {
         diag.span_labels(self.0, "");
     }
 }

compiler/rustc_attr_parsing/src/diagnostics.rs

@@ -3,8 +3,7 @@ use std::num::IntErrorKind;
 use rustc_attr_ir::{AttrPath, MirDialect, MirPhase};
 use rustc_errors::codes::*;
 use rustc_errors::{
-    Applicability, Diag, DiagArgValue, DiagCtxtHandle, Diagnostic, E0264, EmissionGuarantee, Level,
-    MultiSpan,
+    Applicability, Diag, DiagArgValue, DiagCtxtHandle, Diagnostic, E0264, Level, MultiSpan,
 };
 use rustc_macros::{Diagnostic, Subdiagnostic};
 use rustc_span::{Ident, Span, Symbol};
@@ -1482,9 +1481,7 @@ impl<'a> AttributeParseError<'a> {
         diag: &mut Diag<'_, G>,
         possibilities: &[Symbol],
         strings: bool,
-    ) where
-        G: EmissionGuarantee,
-    {
+    ) {
         let quote = if strings { '"' } else { '`' };
         match possibilities {
             &[] => {}
@@ -1517,9 +1514,7 @@ impl<'a> AttributeParseError<'a> {
         diag: &mut Diag<'_, G>,
         possibilities: &[Symbol],
         strings: bool,
-    ) where
-        G: EmissionGuarantee,
-    {
+    ) {
         let description = self.description();
 
         let quote = if strings { '"' } else { '`' };
@@ -1548,10 +1543,7 @@ impl<'a> AttributeParseError<'a> {
         }
     }
 
-    fn render_suggestions<G>(&self, diag: &mut Diag<'_, G>)
-    where
-        G: EmissionGuarantee,
-    {
+    fn render_suggestions<G>(&self, diag: &mut Diag<'_, G>) {
         let description = self.description();
 
         match &self.suggestions {
@@ -1600,7 +1592,7 @@ impl AttributeParseErrorSuggestions {
     }
 }
 
-impl<'a, G: EmissionGuarantee> Diagnostic<'a, G> for AttributeParseError<'_> {
+impl<'a, G> Diagnostic<'a, G> for AttributeParseError<'_> {
     fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, G> {
         let name = self.path.to_string();
 

compiler/rustc_borrowck/src/diagnostics/explain_borrow.rs

@@ -2,7 +2,7 @@
 
 use std::assert_matches;
 
-use rustc_errors::{Applicability, Diag, EmissionGuarantee};
+use rustc_errors::{Applicability, Diag};
 use rustc_hir as hir;
 use rustc_hir::intravisit::Visitor;
 use rustc_infer::infer::NllRegionVariableOrigin;
@@ -55,7 +55,7 @@ impl<'tcx> BorrowExplanation<'tcx> {
     pub(crate) fn is_explained(&self) -> bool {
         !matches!(self, BorrowExplanation::Unexplained)
     }
-    pub(crate) fn add_explanation_to_diagnostic<G: EmissionGuarantee>(
+    pub(crate) fn add_explanation_to_diagnostic<G>(
         &self,
         cx: &MirBorrowckCtxt<'_, '_, 'tcx>,
         err: &mut Diag<'_, G>,
@@ -437,7 +437,7 @@ impl<'tcx> BorrowExplanation<'tcx> {
         }
     }
 
-    fn add_object_lifetime_default_note<G: EmissionGuarantee>(
+    fn add_object_lifetime_default_note<G>(
         &self,
         tcx: TyCtxt<'tcx>,
         err: &mut Diag<'_, G>,
@@ -494,7 +494,7 @@ impl<'tcx> BorrowExplanation<'tcx> {
         }
     }
 
-    fn add_lifetime_bound_suggestion_to_diagnostic<G: EmissionGuarantee>(
+    fn add_lifetime_bound_suggestion_to_diagnostic<G>(
         &self,
         err: &mut Diag<'_, G>,
         category: &ConstraintCategory<'tcx>,
@@ -523,7 +523,7 @@ impl<'tcx> BorrowExplanation<'tcx> {
     }
 }
 
-fn suggest_rewrite_if_let<G: EmissionGuarantee>(
+fn suggest_rewrite_if_let<G>(
     tcx: TyCtxt<'_>,
     expr: &hir::Expr<'_>,
     pat: &str,

compiler/rustc_borrowck/src/diagnostics/mod.rs

@@ -5,7 +5,7 @@ use std::collections::BTreeMap;
 use rustc_abi::{FieldIdx, VariantIdx};
 use rustc_data_structures::fx::FxIndexMap;
 use rustc_errors::formatting::DiagMessageAddArg;
-use rustc_errors::{Applicability, Diag, DiagMessage, EmissionGuarantee, MultiSpan, listify, msg};
+use rustc_errors::{Applicability, Diag, DiagMessage, MultiSpan, listify, msg};
 use rustc_hir::attrs::lang_items::LangItem;
 use rustc_hir::def::{CtorKind, Namespace};
 use rustc_hir::{
@@ -669,7 +669,7 @@ impl<'tcx> MirBorrowckCtxt<'_, '_, 'tcx> {
     ///
     /// This is very similar to `fn suggest_static_lifetime_for_gat_from_hrtb` which handles this
     /// note for failed type tests instead of outlives errors.
-    fn add_placeholder_from_predicate_note<G: EmissionGuarantee>(
+    fn add_placeholder_from_predicate_note<G>(
         &self,
         diag: &mut Diag<'_, G>,
         path: &[OutlivesConstraint<'tcx>],
@@ -731,7 +731,7 @@ impl<'tcx> MirBorrowckCtxt<'_, '_, 'tcx> {
 
     /// Add a label to region errors and borrow explanations when outlives constraints arise from
     /// proving a type implements `Sized` or `Copy`.
-    fn add_sized_or_copy_bound_info<G: EmissionGuarantee>(
+    fn add_sized_or_copy_bound_info<G>(
         &self,
         err: &mut Diag<'_, G>,
         blamed_category: ConstraintCategory<'tcx>,

compiler/rustc_borrowck/src/diagnostics/region_name.rs

@@ -2,7 +2,7 @@ use std::fmt::{self, Display};
 use std::iter;
 
 use rustc_data_structures::fx::IndexEntry;
-use rustc_errors::{Diag, EmissionGuarantee};
+use rustc_errors::Diag;
 use rustc_hir as hir;
 use rustc_hir::def::{DefKind, Res};
 use rustc_middle::ty::print::RegionHighlightMode;
@@ -105,7 +105,7 @@ impl RegionName {
         }
     }
 
-    pub(crate) fn highlight_region_name<G: EmissionGuarantee>(&self, diag: &mut Diag<'_, G>) {
+    pub(crate) fn highlight_region_name<G>(&self, diag: &mut Diag<'_, G>) {
         match &self.source {
             RegionNameSource::NamedLateParamRegion(span)
             | RegionNameSource::NamedEarlyParamRegion(span) => {

compiler/rustc_builtin_macros/src/diagnostics.rs

@@ -1,8 +1,7 @@
 use rustc_errors::codes::*;
 use rustc_errors::formatting::DiagMessageAddArg;
 use rustc_errors::{
-    Diag, DiagCtxtHandle, Diagnostic, EmissionGuarantee, Level, MultiSpan, SingleLabelManySpans,
-    Subdiagnostic, msg,
+    Diag, DiagCtxtHandle, Diagnostic, Level, MultiSpan, SingleLabelManySpans, Subdiagnostic, msg,
 };
 use rustc_macros::{Diagnostic, Subdiagnostic};
 use rustc_span::{Ident, Span, Symbol};
@@ -543,7 +542,7 @@ pub(crate) struct EnvNotDefinedWithUserMessage {
 }
 
 // Hand-written implementation to support custom user messages.
-impl<'a, G: EmissionGuarantee> Diagnostic<'a, G> for EnvNotDefinedWithUserMessage {
+impl<'a, G> Diagnostic<'a, G> for EnvNotDefinedWithUserMessage {
     #[track_caller]
     fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, G> {
         let mut diag = Diag::new(dcx, level, self.msg_from_user.to_string());
@@ -774,7 +773,7 @@ pub(crate) struct FormatUnusedArg {
 // Allow the singular form to be a subdiagnostic of the multiple-unused
 // form of diagnostic.
 impl Subdiagnostic for FormatUnusedArg {
-    fn add_to_diag<G: EmissionGuarantee>(self, diag: &mut Diag<'_, G>) {
+    fn add_to_diag<G>(self, diag: &mut Diag<'_, G>) {
         diag.span_label(
             self.span,
             msg!(
@@ -958,7 +957,7 @@ pub(crate) struct AsmClobberNoReg {
     pub(crate) clobbers: Vec<Span>,
 }
 
-impl<'a, G: EmissionGuarantee> Diagnostic<'a, G> for AsmClobberNoReg {
+impl<'a, G> Diagnostic<'a, G> for AsmClobberNoReg {
     fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, G> {
         Diag::new(
             dcx,

compiler/rustc_builtin_macros/src/test.rs

@@ -3,7 +3,7 @@
 
 use std::{assert_matches, iter};
 
-use rustc_ast::{self as ast, GenericParamKind, attr, join_path_idents};
+use rustc_ast::{self as ast, GenericParamKind, Mutability, Safety, attr, join_path_idents};
 use rustc_ast_pretty::pprust;
 use rustc_attr_ir::{Attribute, AttributeKind};
 use rustc_attr_parsing::AttributeParser;
@@ -274,16 +274,21 @@ pub(crate) fn expand_test_or_bench(
                 // #[doc(hidden)]
                 cx.attr_nested_word(sym::doc, sym::hidden, attr_sp),
             ],
-            // const $ident: test::TestDescAndFn =
-            ast::ItemKind::Const(
-                ast::ConstItem {
-                    defaultness: ast::Defaultness::Implicit,
+            // static $ident: test::TestDescAndFn =
+            // We use a static because these things only exist to have references taken
+            // to them for the test case array. No reason to introduce tons of promoteds for that.
+            // Promoteds have the advantage that they can be merged to save space, but every one
+            // of these points to a different function so that will not happen.
+            ast::ItemKind::Static(
+                ast::StaticItem {
                     ident: Ident::new(fn_.ident.name, sp),
-                    generics: ast::Generics::default(),
                     ty: cx.ty(sp, ast::TyKind::Path(None, test_path("TestDescAndFn"))),
+                    safety: Safety::Default,
+                    mutability: Mutability::Not,
                     define_opaque: None,
+                    eii_impl: None,
                     // test::TestDescAndFn {
-                    body: Some(
+                    expr: Some(
                         cx.expr_struct(
                             sp,
                             test_path("TestDescAndFn"),

compiler/rustc_builtin_macros/src/test_harness.rs

@@ -266,7 +266,7 @@ fn generate_test_harness(
 /// #[rustc_main]
 /// pub fn main() {
 ///     extern crate test;
-///     test::test_main_static(&[
+///     test::test_main_env_args(&[
 ///         &test_const1,
 ///         &test_const2,
 ///         &test_const3,
@@ -286,16 +286,16 @@ fn generate_test_harness(
 ///
 /// [`TestCtxt::reexport_test_harness_main`] provides a different name for the `main`
 /// function and [`TestCtxt::test_runner`] provides a path that replaces
-/// `test::test_main_static`.
+/// `test::test_main_env_args`.
 fn mk_main(cx: &mut TestCtxt<'_>) -> Box<ast::Item> {
     let sp = cx.def_site;
     let ecx = &cx.ext_cx;
     let test_ident = Ident::new(sym::test, sp);
 
     let runner_name =
-        if cx.panic_strategy.unwinds() { "test_main_static" } else { "test_main_static_abort" };
+        if cx.panic_strategy.unwinds() { "test_main_env_args" } else { "test_main_env_args_abort" };
 
-    // test::test_main_static(...)
+    // test::test_main_env_args(...)
     let mut test_runner = cx.test_runner.clone().unwrap_or_else(|| {
         ecx.path(sp, vec![test_ident, Ident::from_str_and_span(runner_name, sp)])
     });

compiler/rustc_codegen_llvm/src/back/mod.rs

@@ -1,5 +1,6 @@
 pub(crate) mod archive;
 pub(crate) mod lto;
+pub(crate) mod owned_mc_subtarget_info;
 pub(crate) mod owned_target_machine;
 mod profiling;
 pub(crate) mod write;

compiler/rustc_codegen_llvm/src/back/owned_mc_subtarget_info.rs

@@ -0,0 +1,49 @@
+use std::ffi::CStr;
+use std::ptr::NonNull;
+
+use rustc_data_structures::small_c_str::SmallCStr;
+
+use crate::diagnostics::LlvmError;
+use crate::llvm;
+
+/// Responsible for safely creating and disposing llvm::MCSubtargetInfo via ffi functions.
+/// Not cloneable as there is no clone function for llvm::MCSubtargetInfo.
+pub(crate) struct OwnedMCSubtargetInfo {
+    info_unique: NonNull<llvm::MCSubtargetInfo>,
+}
+
+impl OwnedMCSubtargetInfo {
+    pub(crate) fn new(
+        triple: &CStr,
+        cpu: &CStr,
+        features: &CStr,
+    ) -> Result<Self, LlvmError<'static>> {
+        // SAFETY: llvm::LLVMRustCreateMCSubtargetInfo copies pointed-to data.
+        let info_ptr = unsafe {
+            llvm::LLVMRustCreateMCSubtargetInfo(triple.as_ptr(), cpu.as_ptr(), features.as_ptr())
+        };
+
+        NonNull::new(info_ptr)
+            .map(|info_unique| Self { info_unique })
+            .ok_or_else(|| LlvmError::CreateMCSubtargetInfo { triple: SmallCStr::from(triple) })
+    }
+
+    pub(crate) fn has_feature(&self, feature: &CStr) -> bool {
+        // SAFETY: `new` ensures we have a valid pointer created by
+        // `llvm::LLVMRustCreateMCSubtargetInfo`.
+        unsafe {
+            llvm::LLVMRustMCSubtargetInfoHasFeature(self.info_unique.as_ref(), feature.as_ptr())
+        }
+    }
+}
+
+impl Drop for OwnedMCSubtargetInfo {
+    fn drop(&mut self) {
+        // SAFETY: `new` ensures we have a valid pointer created by
+        // `llvm::LLVMRustCreateMCSubtargetInfo` and `OwnedMCSubtargetInfo` is not copyable so
+        // there is no double free or use after free.
+        unsafe {
+            llvm::LLVMRustDisposeMCSubtargetInfo(self.info_unique);
+        }
+    }
+}