Rollup of 10 pull requests

compiler/rustc_abi/src/layout/ty.rs

@@ -342,7 +342,7 @@ impl<'a, Ty> TyAndLayout<'a, Ty> {
             Primitive::Float(float @ (Float::F16 | Float::F32 | Float::F64 | Float::F128)) => {
                 Some(Numeric::Float(float))
             }
-            Primitive::Pointer(..) => None,
+            Primitive::Pointer(..) | Primitive::Float(Float::F16B) => None,
         }
     }
 

compiler/rustc_abi/src/lib.rs

@@ -399,8 +399,8 @@ pub enum TargetDataLayoutError<'a> {
 }
 
 #[cfg(feature = "nightly")]
-impl<G> Diagnostic<'_, G> for TargetDataLayoutError<'_> {
-    fn into_diag(self, dcx: DiagCtxtHandle<'_>, level: Level) -> Diag<'_, G> {
+impl Diagnostic<'_> for TargetDataLayoutError<'_> {
+    fn into_diag(self, dcx: DiagCtxtHandle<'_>, level: Level) -> Diag<'_> {
         match self {
             TargetDataLayoutError::InvalidAddressSpace { addr_space, err, cause } => {
                 Diag::new(dcx, level, msg!("invalid address space `{$addr_space}` for `{$cause}` in \"data-layout\": {$err}"))
@@ -1420,6 +1420,10 @@ impl Integer {
 #[cfg_attr(feature = "nightly", derive(StableHash))]
 pub enum Float {
     F16,
+    /// `f16b`. This is not a builtin type in Rust (it is exposed as a lang item),
+    /// but it is a builtin type in LLVM so needs to be explicitly represented
+    /// in the backend.
+    F16B,
     F32,
     F64,
     F128,
@@ -1431,6 +1435,7 @@ impl Float {
 
         match self {
             F16 => Size::from_bits(16),
+            F16B => Size::from_bits(16),
             F32 => Size::from_bits(32),
             F64 => Size::from_bits(64),
             F128 => Size::from_bits(128),
@@ -1442,7 +1447,7 @@ impl Float {
         let dl = cx.data_layout();
 
         AbiAlign::new(match self {
-            F16 => dl.f16_align,
+            F16 | F16B => dl.f16_align,
             F32 => dl.f32_align,
             F64 => dl.f64_align,
             F128 => dl.f128_align,
@@ -1454,6 +1459,7 @@ impl Float {
 
         match self {
             F16 => "f16",
+            F16B => "f16b",
             F32 => "f32",
             F64 => "f64",
             F128 => "f128",

compiler/rustc_ast_lowering/src/item.rs

@@ -1759,12 +1759,10 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     if !self.tcx.is_descendant_of(parent_module, did) {
                         // If the restriction path is not an ancestor of the item,
                         // emit an error and recover by lowering the restriction to `Unrestricted`.
-                        self.dcx()
-                            .create_err(RestrictionAncestorOnly {
-                                span: path.span,
-                                kind: resolving_kind,
-                            })
-                            .emit();
+                        self.dcx().emit_err(RestrictionAncestorOnly {
+                            span: path.span,
+                            kind: resolving_kind,
+                        });
                         hir::RestrictionKind::Unrestricted
                     } else {
                         hir::RestrictionKind::Restricted(self.arena.alloc(hir::Path {

compiler/rustc_ast_lowering/src/lib.rs

@@ -1751,7 +1751,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                                 },
                                 feature,
                             )
-                            .emit();
+                            .emit_err();
                         hir::TyKind::Err(guar)
                     }
                     ImplTraitContext::Disallowed(position) => {

compiler/rustc_ast_passes/src/diagnostics.rs

@@ -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>(self, diag: &mut Diag<'_, G>) {
+    fn add_to_diag(self, diag: &mut Diag<'_>) {
         diag.span_labels(self.0, "");
     }
 }

compiler/rustc_attr_ir/src/lang_items.rs

@@ -281,6 +281,7 @@ language_item_table! {
     PartialEq,               sym::eq,                  eq_trait,                   Target::Trait,          GenericRequirement::Exact(1);
     PartialOrd,              sym::partial_ord,         partial_ord_trait,          Target::Trait,          GenericRequirement::Exact(1);
     CVoid,                   sym::c_void,              c_void,                     Target::Enum,           GenericRequirement::None;
+    F16B,                    sym::f16b,                f16b,                       Target::Struct,         GenericRequirement::Exact(0);
 
     Type,                    sym::type_info,           type_struct,                Target::Struct,         GenericRequirement::None;
     TypeGeneric,             sym::type_info_generic,   type_generic,               Target::Enum,         GenericRequirement::None;

compiler/rustc_attr_parsing/src/attributes/cfg_select.rs

@@ -89,13 +89,13 @@ pub fn parse_cfg_select(
     let mut branches = CfgSelectBranches::default();
 
     while p.token != token::Eof {
-        p.recover_from_outer_attributes("`cfg_select` branches").map_err(|e| e.emit())?;
+        p.recover_from_outer_attributes("`cfg_select` branches").map_err(|e| e.emit_err())?;
 
         if p.eat_keyword(exp!(Underscore)) {
             let underscore = p.prev_token;
-            p.expect(exp!(FatArrow)).map_err(|e| e.emit())?;
+            p.expect(exp!(FatArrow)).map_err(|e| e.emit_err())?;
 
-            let tts = p.parse_cfg_select_branch_rhs().map_err(|e| e.emit())?;
+            let tts = p.parse_cfg_select_branch_rhs().map_err(|e| e.emit_err())?;
             let span = underscore.span.to(p.token.span);
 
             match branches.wildcard {
@@ -110,7 +110,7 @@ pub fn parse_cfg_select(
                 ShouldEmit::ErrorsAndLints { recovery: Recovery::Allowed },
                 AllowExprMetavar::Yes,
             )
-            .map_err(|diag| diag.emit())?;
+            .map_err(|diag| diag.emit_err())?;
             let cfg_span = meta.span();
             let cfg = AttributeParser::parse_single_args(
                 sess,
@@ -132,9 +132,9 @@ pub fn parse_cfg_select(
                 &AttributeTemplate::default(),
             )?;
 
-            p.expect(exp!(FatArrow)).map_err(|e| e.emit())?;
+            p.expect(exp!(FatArrow)).map_err(|e| e.emit_err())?;
 
-            let tts = p.parse_cfg_select_branch_rhs().map_err(|e| e.emit())?;
+            let tts = p.parse_cfg_select_branch_rhs().map_err(|e| e.emit_err())?;
             let span = cfg_span.to(p.token.span);
 
             match branches.wildcard {

compiler/rustc_attr_parsing/src/context.rs

@@ -418,7 +418,7 @@ impl<'f, 'sess: 'f> SharedContext<'f, 'sess> {
     pub(crate) fn emit_lint(
         &mut self,
         lint: &'static Lint,
-        diagnostic: impl for<'x> Diagnostic<'x, ()> + DynSend + DynSync + 'static,
+        diagnostic: impl for<'x> Diagnostic<'x> + DynSend + DynSync + 'static,
         span: impl Into<MultiSpan>,
     ) {
         self.emit_lint_inner(
@@ -429,7 +429,7 @@ impl<'f, 'sess: 'f> SharedContext<'f, 'sess> {
     }
 
     pub(crate) fn emit_lint_with_sess<
-        F: for<'a> FnOnce(DiagCtxtHandle<'a>, Level, &Session) -> Diag<'a, ()>
+        F: for<'a> FnOnce(DiagCtxtHandle<'a>, Level, &Session) -> Diag<'a>
             + DynSend
             + DynSync
             + 'static,
@@ -895,9 +895,9 @@ pub enum ShouldEmit {
 impl ShouldEmit {
     pub(crate) fn emit_err(self, diag: Diag<'_>) -> ErrorGuaranteed {
         match self {
-            ShouldEmit::EarlyFatal { .. } if diag.level() == Level::DelayedBug => diag.emit(),
-            ShouldEmit::EarlyFatal { .. } => diag.upgrade_to_fatal().emit(),
-            ShouldEmit::ErrorsAndLints { .. } => diag.emit(),
+            ShouldEmit::EarlyFatal { .. } if diag.level() == Level::DelayedBug => diag.emit_err(),
+            ShouldEmit::EarlyFatal { .. } => diag.upgrade_to_fatal().emit_fatal(),
+            ShouldEmit::ErrorsAndLints { .. } => diag.emit_err(),
             ShouldEmit::Nothing => diag.delay_as_bug(),
         }
     }

compiler/rustc_attr_parsing/src/diagnostics.rs

@@ -1476,9 +1476,9 @@ pub(crate) enum AttributeParseErrorSuggestions {
 }
 
 impl<'a> AttributeParseError<'a> {
-    fn render_expected_specific_argument<G>(
+    fn render_expected_specific_argument(
         &self,
-        diag: &mut Diag<'_, G>,
+        diag: &mut Diag<'_>,
         possibilities: &[Symbol],
         strings: bool,
     ) {
@@ -1509,9 +1509,9 @@ impl<'a> AttributeParseError<'a> {
         }
     }
 
-    fn render_expected_specific_argument_list<G>(
+    fn render_expected_specific_argument_list(
         &self,
-        diag: &mut Diag<'_, G>,
+        diag: &mut Diag<'_>,
         possibilities: &[Symbol],
         strings: bool,
     ) {
@@ -1543,7 +1543,7 @@ impl<'a> AttributeParseError<'a> {
         }
     }
 
-    fn render_suggestions<G>(&self, diag: &mut Diag<'_, G>) {
+    fn render_suggestions(&self, diag: &mut Diag<'_>) {
         let description = self.description();
 
         match &self.suggestions {
@@ -1592,8 +1592,8 @@ impl AttributeParseErrorSuggestions {
     }
 }
 
-impl<'a, G> Diagnostic<'a, G> for AttributeParseError<'_> {
-    fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, G> {
+impl<'a> Diagnostic<'a> for AttributeParseError<'_> {
+    fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a> {
         let name = self.path.to_string();
 
         let description = self.description();

compiler/rustc_attr_parsing/src/interface.rs

@@ -27,7 +27,7 @@ use crate::{AttributeTemplate, ShouldEmit};
 
 pub struct EmitAttribute(
     pub  Box<
-        dyn for<'a> FnOnce(DiagCtxtHandle<'a>, Level, &Session) -> Diag<'a, ()>
+        dyn for<'a> FnOnce(DiagCtxtHandle<'a>, Level, &Session) -> Diag<'a>
             + DynSend
             + DynSync
             + 'static,

compiler/rustc_attr_parsing/src/parser.rs

@@ -434,7 +434,7 @@ fn expr_to_lit<'sess>(
                     let lit = MetaItemLit {
                         symbol: token_lit.symbol,
                         suffix: token_lit.suffix,
-                        kind: LitKind::Err(err.emit()),
+                        kind: LitKind::Err(err.emit_err()),
                         span: expr.span,
                     };
                     Ok(Some(lit))

compiler/rustc_borrowck/src/diagnostics/explain_borrow.rs

@@ -55,10 +55,10 @@ impl<'tcx> BorrowExplanation<'tcx> {
     pub(crate) fn is_explained(&self) -> bool {
         !matches!(self, BorrowExplanation::Unexplained)
     }
-    pub(crate) fn add_explanation_to_diagnostic<G>(
+    pub(crate) fn add_explanation_to_diagnostic(
         &self,
         cx: &MirBorrowckCtxt<'_, '_, 'tcx>,
-        err: &mut Diag<'_, G>,
+        err: &mut Diag<'_>,
         borrow_desc: &str,
         borrow_span: Option<Span>,
         multiple_borrow_span: Option<(Span, Span)>,
@@ -437,10 +437,10 @@ impl<'tcx> BorrowExplanation<'tcx> {
         }
     }
 
-    fn add_object_lifetime_default_note<G>(
+    fn add_object_lifetime_default_note(
         &self,
         tcx: TyCtxt<'tcx>,
-        err: &mut Diag<'_, G>,
+        err: &mut Diag<'_>,
         unsize_ty: Ty<'tcx>,
     ) {
         if let ty::Adt(def, args) = unsize_ty.kind() {
@@ -494,9 +494,9 @@ impl<'tcx> BorrowExplanation<'tcx> {
         }
     }
 
-    fn add_lifetime_bound_suggestion_to_diagnostic<G>(
+    fn add_lifetime_bound_suggestion_to_diagnostic(
         &self,
-        err: &mut Diag<'_, G>,
+        err: &mut Diag<'_>,
         category: &ConstraintCategory<'tcx>,
         span: Span,
         region_name: &RegionName,
@@ -523,14 +523,14 @@ impl<'tcx> BorrowExplanation<'tcx> {
     }
 }
 
-fn suggest_rewrite_if_let<G>(
+fn suggest_rewrite_if_let(
     tcx: TyCtxt<'_>,
     expr: &hir::Expr<'_>,
     pat: &str,
     init: &hir::Expr<'_>,
     conseq: &hir::Expr<'_>,
     alt: Option<&hir::Expr<'_>>,
-    err: &mut Diag<'_, G>,
+    err: &mut Diag<'_>,
 ) {
     let source_map = tcx.sess.source_map();
     err.span_note(

compiler/rustc_borrowck/src/diagnostics/mod.rs

@@ -642,9 +642,9 @@ 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>(
+    fn add_placeholder_from_predicate_note(
         &self,
-        diag: &mut Diag<'_, G>,
+        diag: &mut Diag<'_>,
         path: &[OutlivesConstraint<'tcx>],
     ) {
         let tcx = self.infcx.tcx;
@@ -704,9 +704,9 @@ 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>(
+    fn add_sized_or_copy_bound_info(
         &self,
-        err: &mut Diag<'_, G>,
+        err: &mut Diag<'_>,
         blamed_category: ConstraintCategory<'tcx>,
         path: &[OutlivesConstraint<'tcx>],
     ) {

compiler/rustc_borrowck/src/diagnostics/opaque_types.rs

@@ -61,7 +61,7 @@ impl<'diag, 'tcx> MirBorrowckCtxt<'_, 'diag, 'tcx> {
                     {
                         last_unexpected_hidden_region =
                             Some((hidden_type.span, named_ty, named_key));
-                        diag.emit()
+                        diag.emit_err()
                     } else {
                         diag.delay_as_bug()
                     }

compiler/rustc_borrowck/src/diagnostics/region_name.rs

@@ -104,7 +104,7 @@ impl RegionName {
         }
     }
 
-    pub(crate) fn highlight_region_name<G>(&self, diag: &mut Diag<'_, G>) {
+    pub(crate) fn highlight_region_name(&self, diag: &mut Diag<'_>) {
         match &self.source {
             RegionNameSource::NamedLateParamRegion(span)
             | RegionNameSource::NamedEarlyParamRegion(span) => {

compiler/rustc_borrowck/src/region_infer/mod.rs

@@ -430,7 +430,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
     }
 
     /// Adds annotations for `#[rustc_regions]`; see `UniversalRegions::annotate`.
-    pub(crate) fn annotate(&self, tcx: TyCtxt<'tcx>, err: &mut Diag<'_, ()>) {
+    pub(crate) fn annotate(&self, tcx: TyCtxt<'tcx>, err: &mut Diag<'_>) {
         self.universal_regions().annotate(tcx, err)
     }
 

compiler/rustc_borrowck/src/region_infer/opaque_types/mod.rs

@@ -171,7 +171,7 @@ fn add_hidden_type<'tcx>(
             prev.span = prev.span.substitute_dummy(hidden_ty.span);
         } else {
             let (Ok(guar) | Err(guar)) =
-                prev.build_mismatch_error(&hidden_ty, tcx).map(|d| d.emit());
+                prev.build_mismatch_error(&hidden_ty, tcx).map(|d| d.emit_err());
             *prev = ty::DefinitionSiteHiddenType::new_error(tcx, guar);
         }
     } else {

compiler/rustc_borrowck/src/session_diagnostics.rs

@@ -659,13 +659,13 @@ pub(crate) struct SimdIntrinsicArgConst {
     pub intrinsic: String,
 }
 
-pub(crate) struct TailExprDropOrder<F: FnOnce(&mut Diag<'_, ()>)> {
+pub(crate) struct TailExprDropOrder<F: FnOnce(&mut Diag<'_>)> {
     pub borrowed: Span,
     pub callback: F,
 }
 
-impl<'a, F: FnOnce(&mut Diag<'_, ()>)> Diagnostic<'a, ()> for TailExprDropOrder<F> {
-    fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, ()> {
+impl<'a, F: FnOnce(&mut Diag<'_>)> Diagnostic<'a> for TailExprDropOrder<F> {
+    fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a> {
         let Self { borrowed, callback } = self;
         let mut diag = Diag::new(dcx, level, "relative drop order changing in Rust 2024")
             .with_span_label(

compiler/rustc_borrowck/src/universal_regions.rs

@@ -614,7 +614,7 @@ impl<'tcx> UniversalRegions<'tcx> {
     /// that this region imposes on others. The methods in this file
     /// handle the part about dumping the inference context internal
     /// state.
-    pub(crate) fn annotate(&self, tcx: TyCtxt<'tcx>, err: &mut Diag<'_, ()>) {
+    pub(crate) fn annotate(&self, tcx: TyCtxt<'tcx>, err: &mut Diag<'_>) {
         match self.defining_ty {
             DefiningTy::Closure(def_id, args) => {
                 let v = with_no_trimmed_paths!(