diff --git a/compiler/rustc_hir/src/lang_items.rs b/compiler/rustc_hir/src/lang_items.rs
index 8f91a96f964ab..e1c030d3e198a 100644
--- a/compiler/rustc_hir/src/lang_items.rs
+++ b/compiler/rustc_hir/src/lang_items.rs
@@ -293,6 +293,8 @@ language_item_table! {
PointerLike, sym::pointer_like, pointer_like, Target::Trait, GenericRequirement::Exact(0);
+ ConstParamTy, sym::const_param_ty, const_param_ty_trait, Target::Trait, GenericRequirement::Exact(0);
+
Poll, sym::Poll, poll, Target::Enum, GenericRequirement::None;
PollReady, sym::Ready, poll_ready_variant, Target::Variant, GenericRequirement::None;
PollPending, sym::Pending, poll_pending_variant, Target::Variant, GenericRequirement::None;
diff --git a/compiler/rustc_hir_analysis/messages.ftl b/compiler/rustc_hir_analysis/messages.ftl
index 1d7965ff5f66e..bda9879b5db1a 100644
--- a/compiler/rustc_hir_analysis/messages.ftl
+++ b/compiler/rustc_hir_analysis/messages.ftl
@@ -35,6 +35,10 @@ hir_analysis_field_already_declared =
hir_analysis_expected_used_symbol = expected `used`, `used(compiler)` or `used(linker)`
+hir_analysis_const_param_ty_impl_on_non_adt =
+ the trait `ConstParamTy` may not be implemented for this type
+ .label = type is not a structure or enumeration
+
hir_analysis_ambiguous_lifetime_bound =
ambiguous lifetime bound, explicit lifetime bound required
diff --git a/compiler/rustc_hir_analysis/src/coherence/builtin.rs b/compiler/rustc_hir_analysis/src/coherence/builtin.rs
index 611ce13b739c2..0f450ae67b7a6 100644
--- a/compiler/rustc_hir_analysis/src/coherence/builtin.rs
+++ b/compiler/rustc_hir_analysis/src/coherence/builtin.rs
@@ -1,9 +1,11 @@
//! Check properties that are required by built-in traits and set
//! up data structures required by type-checking/codegen.
-use crate::errors::{CopyImplOnNonAdt, CopyImplOnTypeWithDtor, DropImplOnWrongItem};
+use crate::errors::{
+ ConstParamTyImplOnNonAdt, CopyImplOnNonAdt, CopyImplOnTypeWithDtor, DropImplOnWrongItem,
+};
use rustc_data_structures::fx::FxHashSet;
-use rustc_errors::{struct_span_err, MultiSpan};
+use rustc_errors::{struct_span_err, ErrorGuaranteed, MultiSpan};
use rustc_hir as hir;
use rustc_hir::def_id::{DefId, LocalDefId};
use rustc_hir::lang_items::LangItem;
@@ -14,9 +16,11 @@ use rustc_infer::infer::{DefineOpaqueTypes, TyCtxtInferExt};
use rustc_infer::traits::Obligation;
use rustc_middle::ty::adjustment::CoerceUnsizedInfo;
use rustc_middle::ty::{self, suggest_constraining_type_params, Ty, TyCtxt, TypeVisitableExt};
+use rustc_span::Span;
use rustc_trait_selection::traits::error_reporting::TypeErrCtxtExt;
use rustc_trait_selection::traits::misc::{
- type_allowed_to_implement_copy, CopyImplementationError, InfringingFieldsReason,
+ type_allowed_to_implement_const_param_ty, type_allowed_to_implement_copy,
+ ConstParamTyImplementationError, CopyImplementationError, InfringingFieldsReason,
};
use rustc_trait_selection::traits::ObligationCtxt;
use rustc_trait_selection::traits::{self, ObligationCause};
@@ -27,6 +31,7 @@ pub fn check_trait(tcx: TyCtxt<'_>, trait_def_id: DefId) {
Checker { tcx, trait_def_id }
.check(lang_items.drop_trait(), visit_implementation_of_drop)
.check(lang_items.copy_trait(), visit_implementation_of_copy)
+ .check(lang_items.const_param_ty_trait(), visit_implementation_of_const_param_ty)
.check(lang_items.coerce_unsized_trait(), visit_implementation_of_coerce_unsized)
.check(lang_items.dispatch_from_dyn_trait(), visit_implementation_of_dispatch_from_dyn);
}
@@ -83,110 +88,7 @@ fn visit_implementation_of_copy(tcx: TyCtxt<'_>, impl_did: LocalDefId) {
match type_allowed_to_implement_copy(tcx, param_env, self_type, cause) {
Ok(()) => {}
Err(CopyImplementationError::InfringingFields(fields)) => {
- let mut err = struct_span_err!(
- tcx.sess,
- span,
- E0204,
- "the trait `Copy` cannot be implemented for this type"
- );
-
- // We'll try to suggest constraining type parameters to fulfill the requirements of
- // their `Copy` implementation.
- let mut errors: BTreeMap<_, Vec<_>> = Default::default();
- let mut bounds = vec![];
-
- let mut seen_tys = FxHashSet::default();
-
- for (field, ty, reason) in fields {
- // Only report an error once per type.
- if !seen_tys.insert(ty) {
- continue;
- }
-
- let field_span = tcx.def_span(field.did);
- err.span_label(field_span, "this field does not implement `Copy`");
-
- match reason {
- InfringingFieldsReason::Fulfill(fulfillment_errors) => {
- for error in fulfillment_errors {
- let error_predicate = error.obligation.predicate;
- // Only note if it's not the root obligation, otherwise it's trivial and
- // should be self-explanatory (i.e. a field literally doesn't implement Copy).
-
- // FIXME: This error could be more descriptive, especially if the error_predicate
- // contains a foreign type or if it's a deeply nested type...
- if error_predicate != error.root_obligation.predicate {
- errors
- .entry((ty.to_string(), error_predicate.to_string()))
- .or_default()
- .push(error.obligation.cause.span);
- }
- if let ty::PredicateKind::Clause(ty::Clause::Trait(
- ty::TraitPredicate {
- trait_ref,
- polarity: ty::ImplPolarity::Positive,
- ..
- },
- )) = error_predicate.kind().skip_binder()
- {
- let ty = trait_ref.self_ty();
- if let ty::Param(_) = ty.kind() {
- bounds.push((
- format!("{ty}"),
- trait_ref.print_only_trait_path().to_string(),
- Some(trait_ref.def_id),
- ));
- }
- }
- }
- }
- InfringingFieldsReason::Regions(region_errors) => {
- for error in region_errors {
- let ty = ty.to_string();
- match error {
- RegionResolutionError::ConcreteFailure(origin, a, b) => {
- let predicate = format!("{b}: {a}");
- errors
- .entry((ty.clone(), predicate.clone()))
- .or_default()
- .push(origin.span());
- if let ty::RegionKind::ReEarlyBound(ebr) = *b && ebr.has_name() {
- bounds.push((b.to_string(), a.to_string(), None));
- }
- }
- RegionResolutionError::GenericBoundFailure(origin, a, b) => {
- let predicate = format!("{a}: {b}");
- errors
- .entry((ty.clone(), predicate.clone()))
- .or_default()
- .push(origin.span());
- if let infer::region_constraints::GenericKind::Param(_) = a {
- bounds.push((a.to_string(), b.to_string(), None));
- }
- }
- _ => continue,
- }
- }
- }
- }
- }
- for ((ty, error_predicate), spans) in errors {
- let span: MultiSpan = spans.into();
- err.span_note(
- span,
- &format!("the `Copy` impl for `{}` requires that `{}`", ty, error_predicate),
- );
- }
- suggest_constraining_type_params(
- tcx,
- tcx.hir().get_generics(impl_did).expect("impls always have generics"),
- &mut err,
- bounds.iter().map(|(param, constraint, def_id)| {
- (param.as_str(), constraint.as_str(), *def_id)
- }),
- None,
- );
- err.emit();
+ infringing_fields_error(tcx, fields, LangItem::Copy, impl_did, span);
}
Err(CopyImplementationError::NotAnAdt) => {
tcx.sess.emit_err(CopyImplOnNonAdt { span });
@@ -197,6 +99,29 @@ fn visit_implementation_of_copy(tcx: TyCtxt<'_>, impl_did: LocalDefId) {
}
}
+fn visit_implementation_of_const_param_ty(tcx: TyCtxt<'_>, impl_did: LocalDefId) {
+ let self_type = tcx.type_of(impl_did).subst_identity();
+ assert!(!self_type.has_escaping_bound_vars());
+
+ let param_env = tcx.param_env(impl_did);
+
+ let span = match tcx.hir().expect_item(impl_did).expect_impl() {
+ hir::Impl { polarity: hir::ImplPolarity::Negative(_), .. } => return,
+ impl_ => impl_.self_ty.span,
+ };
+
+ let cause = traits::ObligationCause::misc(span, impl_did);
+ match type_allowed_to_implement_const_param_ty(tcx, param_env, self_type, cause) {
+ Ok(()) => {}
+ Err(ConstParamTyImplementationError::InfrigingFields(fields)) => {
+ infringing_fields_error(tcx, fields, LangItem::ConstParamTy, impl_did, span);
+ }
+ Err(ConstParamTyImplementationError::NotAnAdtOrBuiltinAllowed) => {
+ tcx.sess.emit_err(ConstParamTyImplOnNonAdt { span });
+ }
+ }
+}
+
fn visit_implementation_of_coerce_unsized(tcx: TyCtxt<'_>, impl_did: LocalDefId) {
debug!("visit_implementation_of_coerce_unsized: impl_did={:?}", impl_did);
@@ -593,3 +518,119 @@ pub fn coerce_unsized_info<'tcx>(tcx: TyCtxt<'tcx>, impl_did: LocalDefId) -> Coe
CoerceUnsizedInfo { custom_kind: kind }
}
+
+fn infringing_fields_error(
+ tcx: TyCtxt<'_>,
+ fields: Vec<(&ty::FieldDef, Ty<'_>, InfringingFieldsReason<'_>)>,
+ lang_item: LangItem,
+ impl_did: LocalDefId,
+ impl_span: Span,
+) -> ErrorGuaranteed {
+ let trait_did = tcx.require_lang_item(lang_item, Some(impl_span));
+
+ let trait_name = tcx.def_path_str(trait_did);
+
+ let mut err = struct_span_err!(
+ tcx.sess,
+ impl_span,
+ E0204,
+ "the trait `{trait_name}` cannot be implemented for this type"
+ );
+
+ // We'll try to suggest constraining type parameters to fulfill the requirements of
+ // their `Copy` implementation.
+ let mut errors: BTreeMap<_, Vec<_>> = Default::default();
+ let mut bounds = vec![];
+
+ let mut seen_tys = FxHashSet::default();
+
+ for (field, ty, reason) in fields {
+ // Only report an error once per type.
+ if !seen_tys.insert(ty) {
+ continue;
+ }
+
+ let field_span = tcx.def_span(field.did);
+ err.span_label(field_span, format!("this field does not implement `{trait_name}`"));
+
+ match reason {
+ InfringingFieldsReason::Fulfill(fulfillment_errors) => {
+ for error in fulfillment_errors {
+ let error_predicate = error.obligation.predicate;
+ // Only note if it's not the root obligation, otherwise it's trivial and
+ // should be self-explanatory (i.e. a field literally doesn't implement Copy).
+
+ // FIXME: This error could be more descriptive, especially if the error_predicate
+ // contains a foreign type or if it's a deeply nested type...
+ if error_predicate != error.root_obligation.predicate {
+ errors
+ .entry((ty.to_string(), error_predicate.to_string()))
+ .or_default()
+ .push(error.obligation.cause.span);
+ }
+ if let ty::PredicateKind::Clause(ty::Clause::Trait(ty::TraitPredicate {
+ trait_ref,
+ polarity: ty::ImplPolarity::Positive,
+ ..
+ })) = error_predicate.kind().skip_binder()
+ {
+ let ty = trait_ref.self_ty();
+ if let ty::Param(_) = ty.kind() {
+ bounds.push((
+ format!("{ty}"),
+ trait_ref.print_only_trait_path().to_string(),
+ Some(trait_ref.def_id),
+ ));
+ }
+ }
+ }
+ }
+ InfringingFieldsReason::Regions(region_errors) => {
+ for error in region_errors {
+ let ty = ty.to_string();
+ match error {
+ RegionResolutionError::ConcreteFailure(origin, a, b) => {
+ let predicate = format!("{b}: {a}");
+ errors
+ .entry((ty.clone(), predicate.clone()))
+ .or_default()
+ .push(origin.span());
+ if let ty::RegionKind::ReEarlyBound(ebr) = *b && ebr.has_name() {
+ bounds.push((b.to_string(), a.to_string(), None));
+ }
+ }
+ RegionResolutionError::GenericBoundFailure(origin, a, b) => {
+ let predicate = format!("{a}: {b}");
+ errors
+ .entry((ty.clone(), predicate.clone()))
+ .or_default()
+ .push(origin.span());
+ if let infer::region_constraints::GenericKind::Param(_) = a {
+ bounds.push((a.to_string(), b.to_string(), None));
+ }
+ }
+ _ => continue,
+ }
+ }
+ }
+ }
+ }
+ for ((ty, error_predicate), spans) in errors {
+ let span: MultiSpan = spans.into();
+ err.span_note(
+ span,
+ format!("the `{trait_name}` impl for `{ty}` requires that `{error_predicate}`"),
+ );
+ }
+ suggest_constraining_type_params(
+ tcx,
+ tcx.hir().get_generics(impl_did).expect("impls always have generics"),
+ &mut err,
+ bounds
+ .iter()
+ .map(|(param, constraint, def_id)| (param.as_str(), constraint.as_str(), *def_id)),
+ None,
+ );
+
+ err.emit()
+}
diff --git a/compiler/rustc_hir_analysis/src/errors.rs b/compiler/rustc_hir_analysis/src/errors.rs
index 2a3a683489ddd..8dcf3b1670dc9 100644
--- a/compiler/rustc_hir_analysis/src/errors.rs
+++ b/compiler/rustc_hir_analysis/src/errors.rs
@@ -107,6 +107,14 @@ pub struct CopyImplOnNonAdt {
pub span: Span,
}
+#[derive(Diagnostic)]
+#[diag(hir_analysis_const_param_ty_impl_on_non_adt)]
+pub struct ConstParamTyImplOnNonAdt {
+ #[primary_span]
+ #[label]
+ pub span: Span,
+}
+
#[derive(Diagnostic)]
#[diag(hir_analysis_trait_object_declared_with_no_traits, code = "E0224")]
pub struct TraitObjectDeclaredWithNoTraits {
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index 70b9088de5064..d2e23f845144f 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -531,6 +531,7 @@ symbols! {
const_mut_refs,
const_panic,
const_panic_fmt,
+ const_param_ty,
const_precise_live_drops,
const_raw_ptr_deref,
const_raw_ptr_to_usize_cast,
diff --git a/compiler/rustc_trait_selection/src/traits/misc.rs b/compiler/rustc_trait_selection/src/traits/misc.rs
index 63949843aedcd..2210ef975e6c8 100644
--- a/compiler/rustc_trait_selection/src/traits/misc.rs
+++ b/compiler/rustc_trait_selection/src/traits/misc.rs
@@ -2,13 +2,14 @@
use crate::traits::{self, ObligationCause, ObligationCtxt};
+use hir::LangItem;
use rustc_data_structures::fx::FxIndexSet;
use rustc_hir as hir;
use rustc_infer::infer::canonical::Canonical;
use rustc_infer::infer::{RegionResolutionError, TyCtxtInferExt};
use rustc_infer::traits::query::NoSolution;
use rustc_infer::{infer::outlives::env::OutlivesEnvironment, traits::FulfillmentError};
-use rustc_middle::ty::{self, ParamEnv, Ty, TyCtxt, TypeVisitableExt};
+use rustc_middle::ty::{self, AdtDef, GenericArg, List, ParamEnv, Ty, TyCtxt, TypeVisitableExt};
use rustc_span::DUMMY_SP;
use super::outlives_bounds::InferCtxtExt;
@@ -19,6 +20,11 @@ pub enum CopyImplementationError<'tcx> {
HasDestructor,
}
+pub enum ConstParamTyImplementationError<'tcx> {
+ InfrigingFields(Vec<(&'tcx ty::FieldDef, Ty<'tcx>, InfringingFieldsReason<'tcx>)>),
+ NotAnAdtOrBuiltinAllowed,
+}
+
pub enum InfringingFieldsReason<'tcx> {
Fulfill(Vec<FulfillmentError<'tcx>>),
Regions(Vec<RegionResolutionError<'tcx>>),
@@ -27,7 +33,10 @@ pub enum InfringingFieldsReason<'tcx> {
/// Checks that the fields of the type (an ADT) all implement copy.
///
/// If fields don't implement copy, return an error containing a list of
-/// those violating fields. If it's not an ADT, returns `Err(NotAnAdt)`.
+/// those violating fields.
+///
+/// If it's not an ADT, int ty, `bool`, float ty, `char`, raw pointer, `!`,
+/// a reference or an array returns `Err(NotAnAdt)`.
pub fn type_allowed_to_implement_copy<'tcx>(
tcx: TyCtxt<'tcx>,
param_env: ty::ParamEnv<'tcx>,
@@ -47,12 +56,82 @@ pub fn type_allowed_to_implement_copy<'tcx>(
| ty::Ref(_, _, hir::Mutability::Not)
| ty::Array(..) => return Ok(()),
- ty::Adt(adt, substs) => (adt, substs),
+ &ty::Adt(adt, substs) => (adt, substs),
_ => return Err(CopyImplementationError::NotAnAdt),
};
- let copy_def_id = tcx.require_lang_item(hir::LangItem::Copy, Some(parent_cause.span));
+ all_fields_implement_trait(
+ tcx,
+ param_env,
+ self_type,
+ adt,
+ substs,
+ parent_cause,
+ hir::LangItem::Copy,
+ )
+ .map_err(CopyImplementationError::InfringingFields)?;
+
+ if adt.has_dtor(tcx) {
+ return Err(CopyImplementationError::HasDestructor);
+ }
+
+ Ok(())
+}
+
+/// Checks that the fields of the type (an ADT) all implement `ConstParamTy`.
+///
+/// If fields don't implement `ConstParamTy`, return an error containing a list of
+/// those violating fields.
+///
+/// If it's not an ADT, int ty, `bool` or `char`, returns `Err(NotAnAdtOrBuiltinAllowed)`.
+pub fn type_allowed_to_implement_const_param_ty<'tcx>(
+ tcx: TyCtxt<'tcx>,
+ param_env: ty::ParamEnv<'tcx>,
+ self_type: Ty<'tcx>,
+ parent_cause: ObligationCause<'tcx>,
+) -> Result<(), ConstParamTyImplementationError<'tcx>> {
+ let (adt, substs) = match self_type.kind() {
+ // `core` provides these impls.
+ ty::Uint(_)
+ | ty::Int(_)
+ | ty::Bool
+ | ty::Char
+ | ty::Str
+ | ty::Array(..)
+ | ty::Slice(_)
+ | ty::Ref(.., hir::Mutability::Not) => return Ok(()),
+
+ &ty::Adt(adt, substs) => (adt, substs),
+
+ _ => return Err(ConstParamTyImplementationError::NotAnAdtOrBuiltinAllowed),
+ };
+
+ all_fields_implement_trait(
+ tcx,
+ param_env,
+ self_type,
+ adt,
+ substs,
+ parent_cause,
+ hir::LangItem::ConstParamTy,
+ )
+ .map_err(ConstParamTyImplementationError::InfrigingFields)?;
+
+ Ok(())
+}
+
+/// Check that all fields of a given `adt` implement `lang_item` trait.
+pub fn all_fields_implement_trait<'tcx>(
+ tcx: TyCtxt<'tcx>,
+ param_env: ty::ParamEnv<'tcx>,
+ self_type: Ty<'tcx>,
+ adt: AdtDef<'tcx>,
+ substs: &'tcx List<GenericArg<'tcx>>,
+ parent_cause: ObligationCause<'tcx>,
+ lang_item: LangItem,
+) -> Result<(), Vec<(&'tcx ty::FieldDef, Ty<'tcx>, InfringingFieldsReason<'tcx>)>> {
+ let trait_def_id = tcx.require_lang_item(lang_item, Some(parent_cause.span));
let mut infringing = Vec::new();
for variant in adt.variants() {
@@ -93,7 +172,7 @@ pub fn type_allowed_to_implement_copy<'tcx>(
// between expected and found const-generic types. Don't report an
// additional copy error here, since it's not typically useful.
if !normalization_errors.is_empty() || ty.references_error() {
- tcx.sess.delay_span_bug(field_span, format!("couldn't normalize struct field `{unnormalized_ty}` when checking Copy implementation"));
+ tcx.sess.delay_span_bug(field_span, format!("couldn't normalize struct field `{unnormalized_ty}` when checking {tr} implementation", tr = tcx.def_path_str(trait_def_id)));
continue;
}
@@ -101,7 +180,7 @@ pub fn type_allowed_to_implement_copy<'tcx>(
ObligationCause::dummy_with_span(field_ty_span),
param_env,
ty,
- copy_def_id,
+ trait_def_id,
);
let errors = ocx.select_all_or_error();
if !errors.is_empty() {
@@ -124,15 +203,7 @@ pub fn type_allowed_to_implement_copy<'tcx>(
}
}
- if !infringing.is_empty() {
- return Err(CopyImplementationError::InfringingFields(infringing));
- }
-
- if adt.has_dtor(tcx) {
- return Err(CopyImplementationError::HasDestructor);
- }
-
- Ok(())
+ if infringing.is_empty() { Ok(()) } else { Err(infringing) }
}
pub fn check_tys_might_be_eq<'tcx>(
diff --git a/library/core/src/lib.rs b/library/core/src/lib.rs
index 24a9d81d03784..b269a3bcb000e 100644
--- a/library/core/src/lib.rs
+++ b/library/core/src/lib.rs
@@ -162,6 +162,7 @@
#![feature(const_waker)]
#![feature(core_panic)]
#![feature(duration_consts_float)]
+#![feature(internal_impls_macro)]
#![feature(ip)]
#![feature(is_ascii_octdigit)]
#![feature(maybe_uninit_uninit_array)]
diff --git a/library/core/src/marker.rs b/library/core/src/marker.rs
index e85c0c0a68890..2ebe42aef21d7 100644
--- a/library/core/src/marker.rs
+++ b/library/core/src/marker.rs
@@ -12,6 +12,60 @@ use crate::fmt::Debug;
use crate::hash::Hash;
use crate::hash::Hasher;
+/// Implements a given marker trait for multiple types at the same time.
+///
+/// The basic syntax looks like this:
+/// ```ignore private macro
+/// marker_impls! { MarkerTrait for u8, i8 }
+/// ```
+/// You can also implement `unsafe` traits
+/// ```ignore private macro
+/// marker_impls! { unsafe MarkerTrait for u8, i8 }
+/// ```
+/// Add attributes to all impls:
+/// ```ignore private macro
+/// marker_impls! {
+/// #[allow(lint)]
+/// #[unstable(feature = "marker_trait", issue = "none")]
+/// MarkerTrait for u8, i8
+/// }
+/// ```
+/// And use generics:
+/// ```ignore private macro
+/// marker_impls! {
+/// MarkerTrait for
+/// u8, i8,
+/// {T: ?Sized} *const T,
+/// {T: ?Sized} *mut T,
+/// {T: MarkerTrait} PhantomData<T>,
+/// u32,
+/// }
+/// ```
+#[unstable(feature = "internal_impls_macro", issue = "none")]
+macro marker_impls {
+ ( $(#[$($meta:tt)*])* $Trait:ident for $( $({$($bounds:tt)*})? $T:ty ),+ $(,)?) => {
+ // This inner macro is needed because... idk macros are weird.
+ // It allows repeating `meta` on all impls.
+ #[unstable(feature = "internal_impls_macro", issue = "none")]
+ macro _impl {
+ ( $$({$$($$bounds_:tt)*})? $$T_:ty ) => {
+ $(#[$($meta)*])* impl<$$($$($$bounds_)*)?> $Trait for $$T_ {}
+ }
+ }
+ $( _impl! { $({$($bounds)*})? $T } )+
+ },
+ ( $(#[$($meta:tt)*])* unsafe $Trait:ident for $( $({$($bounds:tt)*})? $T:ty ),+ $(,)?) => {
+ #[unstable(feature = "internal_impls_macro", issue = "none")]
+ macro _impl {
+ ( $$({$$($$bounds_:tt)*})? $$T_:ty ) => {
+ $(#[$($meta)*])* unsafe impl<$$($$($$bounds_)*)?> $Trait for $$T_ {}
+ }
+ }
+
+ $( _impl! { $({$($bounds)*})? $T } )+
+ },
+}
+
/// Types that can be transferred across thread boundaries.
///
/// This trait is automatically implemented when the compiler determines it's
@@ -214,6 +268,20 @@ pub trait StructuralEq {
// Empty.
}
+// FIXME: Remove special cases of these types from the compiler pattern checking code and always check `T: StructuralEq` instead
+marker_impls! {
+ #[unstable(feature = "structural_match", issue = "31434")]
+ StructuralEq for
+ usize, u8, u16, u32, u64, u128,
+ isize, i8, i16, i32, i64, i128,
+ bool,
+ char,
+ str /* Technically requires `[u8]: StructuralEq` */,
+ {T, const N: usize} [T; N],
+ {T} [T],
+ {T: ?Sized} &T,
+}
+
/// Types whose values can be duplicated simply by copying bits.
///
/// By default, variable bindings have 'move semantics.' In other
@@ -401,6 +469,30 @@ pub macro Copy($item:item) {
/* compiler built-in */
}
+// Implementations of `Copy` for primitive types.
+//
+// Implementations that cannot be described in Rust
+// are implemented in `traits::SelectionContext::copy_clone_conditions()`
+// in `rustc_trait_selection`.
+marker_impls! {
+ #[stable(feature = "rust1", since = "1.0.0")]
+ Copy for
+ usize, u8, u16, u32, u64, u128,
+ isize, i8, i16, i32, i64, i128,
+ f32, f64,
+ bool, char,
+ {T: ?Sized} *const T,
+ {T: ?Sized} *mut T,
+
+}
+
+#[unstable(feature = "never_type", issue = "35121")]
+impl Copy for ! {}
+
+/// Shared references can be copied, but mutable references *cannot*!
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<T: ?Sized> Copy for &T {}
+
/// Types for which it is safe to share references between threads.
///
/// This trait is automatically implemented when the compiler determines
@@ -773,11 +865,14 @@ pub trait DiscriminantKind {
pub(crate) unsafe auto trait Freeze {}
impl<T: ?Sized> !Freeze for UnsafeCell<T> {}
-unsafe impl<T: ?Sized> Freeze for PhantomData<T> {}
-unsafe impl<T: ?Sized> Freeze for *const T {}
-unsafe impl<T: ?Sized> Freeze for *mut T {}
-unsafe impl<T: ?Sized> Freeze for &T {}
-unsafe impl<T: ?Sized> Freeze for &mut T {}
+marker_impls! {
+ unsafe Freeze for
+ {T: ?Sized} PhantomData<T>,
+ {T: ?Sized} *const T,
+ {T: ?Sized} *mut T,
+ {T: ?Sized} &T,
+ {T: ?Sized} &mut T,
+}
/// Types that can be safely moved after being pinned.
///
@@ -838,17 +933,19 @@ pub struct PhantomPinned;
#[stable(feature = "pin", since = "1.33.0")]
impl !Unpin for PhantomPinned {}
-#[stable(feature = "pin", since = "1.33.0")]
-impl<'a, T: ?Sized + 'a> Unpin for &'a T {}
-
-#[stable(feature = "pin", since = "1.33.0")]
-impl<'a, T: ?Sized + 'a> Unpin for &'a mut T {}
-
-#[stable(feature = "pin_raw", since = "1.38.0")]
-impl<T: ?Sized> Unpin for *const T {}
+marker_impls! {
+ #[stable(feature = "pin", since = "1.33.0")]
+ Unpin for
+ {T: ?Sized} &T,
+ {T: ?Sized} &mut T,
+}
-#[stable(feature = "pin_raw", since = "1.38.0")]
-impl<T: ?Sized> Unpin for *mut T {}
+marker_impls! {
+ #[stable(feature = "pin_raw", since = "1.38.0")]
+ Unpin for
+ {T: ?Sized} *const T,
+ {T: ?Sized} *mut T,
+}
/// A marker for types that can be dropped.
///
@@ -883,43 +980,25 @@ pub trait Tuple {}
)]
pub trait PointerLike {}
-/// Implementations of `Copy` for primitive types.
-///
-/// Implementations that cannot be described in Rust
-/// are implemented in `traits::SelectionContext::copy_clone_conditions()`
-/// in `rustc_trait_selection`.
-mod copy_impls {
-
- use super::Copy;
-
- macro_rules! impl_copy {
- ($($t:ty)*) => {
- $(
- #[stable(feature = "rust1", since = "1.0.0")]
- impl Copy for $t {}
- )*
- }
- }
-
- impl_copy! {
- usize u8 u16 u32 u64 u128
- isize i8 i16 i32 i64 i128
- f32 f64
- bool char
- }
-
- #[unstable(feature = "never_type", issue = "35121")]
- impl Copy for ! {}
-
- #[stable(feature = "rust1", since = "1.0.0")]
- impl<T: ?Sized> Copy for *const T {}
-
- #[stable(feature = "rust1", since = "1.0.0")]
- impl<T: ?Sized> Copy for *mut T {}
-
- /// Shared references can be copied, but mutable references *cannot*!
- #[stable(feature = "rust1", since = "1.0.0")]
- impl<T: ?Sized> Copy for &T {}
+/// A marker for types which can be used as types of `const` generic parameters.
+#[cfg_attr(not(bootstrap), lang = "const_param_ty")]
+#[unstable(feature = "adt_const_params", issue = "95174")]
+#[rustc_on_unimplemented(message = "`{Self}` can't be used as a const parameter type")]
+pub trait ConstParamTy: StructuralEq {}
+
+// FIXME(generic_const_parameter_types): handle `ty::FnDef`/`ty::Closure`
+// FIXME(generic_const_parameter_types): handle `ty::Tuple`
+marker_impls! {
+ #[unstable(feature = "adt_const_params", issue = "95174")]
+ ConstParamTy for
+ usize, u8, u16, u32, u64, u128,
+ isize, i8, i16, i32, i64, i128,
+ bool,
+ char,
+ str /* Technically requires `[u8]: ConstParamTy` */,
+ {T: ConstParamTy, const N: usize} [T; N],
+ {T: ConstParamTy} [T],
+ {T: ?Sized + ConstParamTy} &T,
}
/// A common trait implemented by all function pointers.
diff --git a/src/tools/compiletest/src/runtest.rs b/src/tools/compiletest/src/runtest.rs
index f6597c729387e..514b96ce85203 100644
--- a/src/tools/compiletest/src/runtest.rs
+++ b/src/tools/compiletest/src/runtest.rs
@@ -1384,7 +1384,9 @@ impl<'test> TestCx<'test> {
let actual_errors = json::parse_output(&diagnostic_file_name, &proc_res.stderr, proc_res);
let mut unexpected = Vec::new();
let mut found = vec![false; expected_errors.len()];
- for actual_error in &actual_errors {
+ for mut actual_error in actual_errors {
+ actual_error.msg = self.normalize_output(&actual_error.msg, &[]);
+
let opt_index =
expected_errors.iter().enumerate().position(|(index, expected_error)| {
!found[index]
@@ -1403,7 +1405,8 @@ impl<'test> TestCx<'test> {
None => {
// If the test is a known bug, don't require that the error is annotated
- if self.is_unexpected_compiler_message(actual_error, expect_help, expect_note) {
+ if self.is_unexpected_compiler_message(&actual_error, expect_help, expect_note)
+ {
self.error(&format!(
"{}:{}: unexpected {}: '{}'",
file_name,
diff --git a/tests/ui/const-generics/adt_const_params/const_param_ty_bad.rs b/tests/ui/const-generics/adt_const_params/const_param_ty_bad.rs
new file mode 100644
index 0000000000000..0da68ae757351
--- /dev/null
+++ b/tests/ui/const-generics/adt_const_params/const_param_ty_bad.rs
@@ -0,0 +1,13 @@
+#![allow(incomplete_features)]
+#![feature(adt_const_params)]
+
+fn check(_: impl std::marker::ConstParamTy) {}
+
+fn main() {
+ check(main); //~ error: `fn() {main}` can't be used as a const parameter type
+ check(|| {}); //~ error: `[closure@$DIR/const_param_ty_bad.rs:8:11: 8:13]` can't be used as a const parameter type
+ check(main as fn()); //~ error: `fn()` can't be used as a const parameter type
+ check(&mut ()); //~ error: `&mut ()` can't be used as a const parameter type
+ check(&mut () as *mut ()); //~ error: `*mut ()` can't be used as a const parameter type
+ check(&() as *const ()); //~ error: `*const ()` can't be used as a const parameter type
+}
diff --git a/tests/ui/const-generics/adt_const_params/const_param_ty_bad.stderr b/tests/ui/const-generics/adt_const_params/const_param_ty_bad.stderr
new file mode 100644
index 0000000000000..de5704ee429ed
--- /dev/null
+++ b/tests/ui/const-generics/adt_const_params/const_param_ty_bad.stderr
@@ -0,0 +1,87 @@
+error[E0277]: `fn() {main}` can't be used as a const parameter type
+ --> $DIR/const_param_ty_bad.rs:7:11
+ |
+LL | check(main);
+ | ----- ^^^^ the trait `ConstParamTy` is not implemented for fn item `fn() {main}`
+ | |
+ | required by a bound introduced by this call
+ |
+note: required by a bound in `check`
+ --> $DIR/const_param_ty_bad.rs:4:18
+ |
+LL | fn check(_: impl std::marker::ConstParamTy) {}
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `check`
+
+error[E0277]: `[closure@$DIR/const_param_ty_bad.rs:8:11: 8:13]` can't be used as a const parameter type
+ --> $DIR/const_param_ty_bad.rs:8:11
+ |
+LL | check(|| {});
+ | ----- ^^^^^ the trait `ConstParamTy` is not implemented for closure `[closure@$DIR/const_param_ty_bad.rs:8:11: 8:13]`
+ | |
+ | required by a bound introduced by this call
+ |
+note: required by a bound in `check`
+ --> $DIR/const_param_ty_bad.rs:4:18
+ |
+LL | fn check(_: impl std::marker::ConstParamTy) {}
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `check`
+
+error[E0277]: `fn()` can't be used as a const parameter type
+ --> $DIR/const_param_ty_bad.rs:9:11
+ |
+LL | check(main as fn());
+ | ----- ^^^^^^^^^^^^ the trait `ConstParamTy` is not implemented for `fn()`
+ | |
+ | required by a bound introduced by this call
+ |
+note: required by a bound in `check`
+ --> $DIR/const_param_ty_bad.rs:4:18
+ |
+LL | fn check(_: impl std::marker::ConstParamTy) {}
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `check`
+
+error[E0277]: `&mut ()` can't be used as a const parameter type
+ --> $DIR/const_param_ty_bad.rs:10:11
+ |
+LL | check(&mut ());
+ | ----- ^^^^^^^ the trait `ConstParamTy` is not implemented for `&mut ()`
+ | |
+ | required by a bound introduced by this call
+ |
+note: required by a bound in `check`
+ --> $DIR/const_param_ty_bad.rs:4:18
+ |
+LL | fn check(_: impl std::marker::ConstParamTy) {}
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `check`
+
+error[E0277]: `*mut ()` can't be used as a const parameter type
+ --> $DIR/const_param_ty_bad.rs:11:11
+ |
+LL | check(&mut () as *mut ());
+ | ----- ^^^^^^^^^^^^^^^^^^ the trait `ConstParamTy` is not implemented for `*mut ()`
+ | |
+ | required by a bound introduced by this call
+ |
+note: required by a bound in `check`
+ --> $DIR/const_param_ty_bad.rs:4:18
+ |
+LL | fn check(_: impl std::marker::ConstParamTy) {}
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `check`
+
+error[E0277]: `*const ()` can't be used as a const parameter type
+ --> $DIR/const_param_ty_bad.rs:12:11
+ |
+LL | check(&() as *const ());
+ | ----- ^^^^^^^^^^^^^^^^ the trait `ConstParamTy` is not implemented for `*const ()`
+ | |
+ | required by a bound introduced by this call
+ |
+note: required by a bound in `check`
+ --> $DIR/const_param_ty_bad.rs:4:18
+ |
+LL | fn check(_: impl std::marker::ConstParamTy) {}
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `check`
+
+error: aborting due to 6 previous errors
+
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/const-generics/adt_const_params/const_param_ty_bad_empty_array.rs b/tests/ui/const-generics/adt_const_params/const_param_ty_bad_empty_array.rs
new file mode 100644
index 0000000000000..b0e3b13cc1ef9
--- /dev/null
+++ b/tests/ui/const-generics/adt_const_params/const_param_ty_bad_empty_array.rs
@@ -0,0 +1,12 @@
+#![allow(incomplete_features)]
+#![feature(adt_const_params)]
+
+#[derive(PartialEq, Eq)]
+struct NotParam;
+
+fn check<T: std::marker::ConstParamTy>() {}
+
+fn main() {
+ check::<[NotParam; 0]>();
+ //~^ error: `NotParam` can't be used as a const parameter type
+}
diff --git a/tests/ui/const-generics/adt_const_params/const_param_ty_bad_empty_array.stderr b/tests/ui/const-generics/adt_const_params/const_param_ty_bad_empty_array.stderr
new file mode 100644
index 0000000000000..ef55242df8742
--- /dev/null
+++ b/tests/ui/const-generics/adt_const_params/const_param_ty_bad_empty_array.stderr
@@ -0,0 +1,16 @@
+error[E0277]: `NotParam` can't be used as a const parameter type
+ --> $DIR/const_param_ty_bad_empty_array.rs:10:13
+ |
+LL | check::<[NotParam; 0]>();
+ | ^^^^^^^^^^^^^ the trait `ConstParamTy` is not implemented for `NotParam`
+ |
+ = note: required for `[NotParam; 0]` to implement `ConstParamTy`
+note: required by a bound in `check`
+ --> $DIR/const_param_ty_bad_empty_array.rs:7:13
+ |
+LL | fn check<T: std::marker::ConstParamTy>() {}
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `check`
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/const-generics/adt_const_params/const_param_ty_generic_bounds_do_not_hold.rs b/tests/ui/const-generics/adt_const_params/const_param_ty_generic_bounds_do_not_hold.rs
new file mode 100644
index 0000000000000..e4dc76703a2d8
--- /dev/null
+++ b/tests/ui/const-generics/adt_const_params/const_param_ty_generic_bounds_do_not_hold.rs
@@ -0,0 +1,13 @@
+#![allow(incomplete_features)]
+#![feature(adt_const_params)]
+
+#[derive(PartialEq, Eq)]
+struct NotParam;
+
+fn check<T: std::marker::ConstParamTy + ?Sized>() {}
+
+fn main() {
+ check::<&NotParam>(); //~ error: `NotParam` can't be used as a const parameter type
+ check::<[NotParam]>(); //~ error: `NotParam` can't be used as a const parameter type
+ check::<[NotParam; 17]>(); //~ error: `NotParam` can't be used as a const parameter type
+}
diff --git a/tests/ui/const-generics/adt_const_params/const_param_ty_generic_bounds_do_not_hold.stderr b/tests/ui/const-generics/adt_const_params/const_param_ty_generic_bounds_do_not_hold.stderr
new file mode 100644
index 0000000000000..86d1c94e87f96
--- /dev/null
+++ b/tests/ui/const-generics/adt_const_params/const_param_ty_generic_bounds_do_not_hold.stderr
@@ -0,0 +1,42 @@
+error[E0277]: `NotParam` can't be used as a const parameter type
+ --> $DIR/const_param_ty_generic_bounds_do_not_hold.rs:10:13
+ |
+LL | check::<&NotParam>();
+ | ^^^^^^^^^ the trait `ConstParamTy` is not implemented for `NotParam`
+ |
+ = note: required for `&NotParam` to implement `ConstParamTy`
+note: required by a bound in `check`
+ --> $DIR/const_param_ty_generic_bounds_do_not_hold.rs:7:13
+ |
+LL | fn check<T: std::marker::ConstParamTy + ?Sized>() {}
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `check`
+
+error[E0277]: `NotParam` can't be used as a const parameter type
+ --> $DIR/const_param_ty_generic_bounds_do_not_hold.rs:11:13
+ |
+LL | check::<[NotParam]>();
+ | ^^^^^^^^^^ the trait `ConstParamTy` is not implemented for `NotParam`
+ |
+ = note: required for `[NotParam]` to implement `ConstParamTy`
+note: required by a bound in `check`
+ --> $DIR/const_param_ty_generic_bounds_do_not_hold.rs:7:13
+ |
+LL | fn check<T: std::marker::ConstParamTy + ?Sized>() {}
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `check`
+
+error[E0277]: `NotParam` can't be used as a const parameter type
+ --> $DIR/const_param_ty_generic_bounds_do_not_hold.rs:12:13
+ |
+LL | check::<[NotParam; 17]>();
+ | ^^^^^^^^^^^^^^ the trait `ConstParamTy` is not implemented for `NotParam`
+ |
+ = note: required for `[NotParam; 17]` to implement `ConstParamTy`
+note: required by a bound in `check`
+ --> $DIR/const_param_ty_generic_bounds_do_not_hold.rs:7:13
+ |
+LL | fn check<T: std::marker::ConstParamTy + ?Sized>() {}
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `check`
+
+error: aborting due to 3 previous errors
+
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/const-generics/adt_const_params/const_param_ty_good.rs b/tests/ui/const-generics/adt_const_params/const_param_ty_good.rs
new file mode 100644
index 0000000000000..a1b711a3024e3
--- /dev/null
+++ b/tests/ui/const-generics/adt_const_params/const_param_ty_good.rs
@@ -0,0 +1,43 @@
+// check-pass
+#![allow(incomplete_features)]
+#![feature(adt_const_params)]
+use std::marker::ConstParamTy;
+
+#[derive(PartialEq, Eq)]
+struct S<T> {
+ field: u8,
+ gen: T,
+}
+
+impl<T: ConstParamTy> ConstParamTy for S<T> {}
+
+fn check<T: ConstParamTy + ?Sized>() {}
+
+fn main() {
+ check::<u8>();
+ check::<u16>();
+ check::<u32>();
+ check::<u64>();
+ check::<u128>();
+
+ check::<i8>();
+ check::<i16>();
+ check::<i32>();
+ check::<i64>();
+ check::<i128>();
+
+ check::<char>();
+ check::<bool>();
+ check::<str>();
+
+ check::<&u8>();
+ check::<&str>();
+ check::<[usize]>();
+ check::<[u16; 0]>();
+ check::<[u8; 42]>();
+
+ check::<S<u8>>();
+ check::<S<[&[bool]; 8]>>();
+
+ // FIXME: test tuples
+}
diff --git a/tests/ui/const-generics/adt_const_params/const_param_ty_impl_bad_field.rs b/tests/ui/const-generics/adt_const_params/const_param_ty_impl_bad_field.rs
new file mode 100644
index 0000000000000..07fd243737e2a
--- /dev/null
+++ b/tests/ui/const-generics/adt_const_params/const_param_ty_impl_bad_field.rs
@@ -0,0 +1,13 @@
+#![allow(incomplete_features)]
+#![feature(adt_const_params)]
+
+#[derive(PartialEq, Eq)]
+struct NotParam;
+
+#[derive(PartialEq, Eq)]
+struct CantParam(NotParam);
+
+impl std::marker::ConstParamTy for CantParam {}
+//~^ error: the trait `ConstParamTy` cannot be implemented for this type
+
+fn main() {}
diff --git a/tests/ui/const-generics/adt_const_params/const_param_ty_impl_bad_field.stderr b/tests/ui/const-generics/adt_const_params/const_param_ty_impl_bad_field.stderr
new file mode 100644
index 0000000000000..c8e065848b1e0
--- /dev/null
+++ b/tests/ui/const-generics/adt_const_params/const_param_ty_impl_bad_field.stderr
@@ -0,0 +1,12 @@
+error[E0204]: the trait `ConstParamTy` cannot be implemented for this type
+ --> $DIR/const_param_ty_impl_bad_field.rs:10:36
+ |
+LL | struct CantParam(NotParam);
+ | -------- this field does not implement `ConstParamTy`
+LL |
+LL | impl std::marker::ConstParamTy for CantParam {}
+ | ^^^^^^^^^
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0204`.
diff --git a/tests/ui/const-generics/adt_const_params/const_param_ty_impl_no_structural_eq.rs b/tests/ui/const-generics/adt_const_params/const_param_ty_impl_no_structural_eq.rs
new file mode 100644
index 0000000000000..17ef396164efd
--- /dev/null
+++ b/tests/ui/const-generics/adt_const_params/const_param_ty_impl_no_structural_eq.rs
@@ -0,0 +1,17 @@
+#![allow(incomplete_features)]
+#![feature(adt_const_params)]
+
+#[derive(PartialEq, Eq)]
+struct ImplementsConstParamTy;
+impl std::marker::ConstParamTy for ImplementsConstParamTy {}
+
+struct CantParam(ImplementsConstParamTy);
+
+impl std::marker::ConstParamTy for CantParam {}
+//~^ error: the type `CantParam` does not `#[derive(Eq)]`
+
+fn check<T: std::marker::ConstParamTy>() {}
+
+fn main() {
+ check::<ImplementsConstParamTy>();
+}
diff --git a/tests/ui/const-generics/adt_const_params/const_param_ty_impl_no_structural_eq.stderr b/tests/ui/const-generics/adt_const_params/const_param_ty_impl_no_structural_eq.stderr
new file mode 100644
index 0000000000000..ca5abf5e25420
--- /dev/null
+++ b/tests/ui/const-generics/adt_const_params/const_param_ty_impl_no_structural_eq.stderr
@@ -0,0 +1,12 @@
+error[E0277]: the type `CantParam` does not `#[derive(Eq)]`
+ --> $DIR/const_param_ty_impl_no_structural_eq.rs:10:36
+ |
+LL | impl std::marker::ConstParamTy for CantParam {}
+ | ^^^^^^^^^ the trait `StructuralEq` is not implemented for `CantParam`
+ |
+note: required by a bound in `ConstParamTy`
+ --> $SRC_DIR/core/src/marker.rs:LL:COL
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/const-generics/nested-type.rs b/tests/ui/const-generics/nested-type.rs
index 5240f5c3b0b64..ff95018065a84 100644
--- a/tests/ui/const-generics/nested-type.rs
+++ b/tests/ui/const-generics/nested-type.rs
@@ -3,7 +3,7 @@
#![cfg_attr(full, feature(adt_const_params))]
#![cfg_attr(full, allow(incomplete_features))]
-struct Foo<const N: [u8; { //[min]~ ERROR `[u8; _]` is forbidden
+struct Foo<const N: [u8; {
struct Foo<const N: usize>;
impl<const N: usize> Foo<N> {
@@ -15,5 +15,9 @@ struct Foo<const N: [u8; { //[min]~ ERROR `[u8; _]` is forbidden
Foo::<17>::value()
//~^ ERROR cannot call non-const fn
}]>;
+//[min]~^^^^^^^^^^^^ ERROR `[u8; {
+
+// N.B. it is important that the comment above is not inside the array length,
+// otherwise it may check for itself, instead of the actual error
fn main() {}
diff --git a/tests/ui/fmt/format-string-error.rs b/tests/ui/fmt/format-string-error.rs
index eae4f3cb5479f..9b436e2c479f2 100644
--- a/tests/ui/fmt/format-string-error.rs
+++ b/tests/ui/fmt/format-string-error.rs
@@ -17,7 +17,7 @@ fn main() {
let _ = format!("}");
//~^ ERROR invalid format string: unmatched `}` found
let _ = format!("{\\}");
- //~^ ERROR invalid format string: expected `'}'`, found `'\\'`
+ //~^ ERROR invalid format string: expected `'}'`, found `'\'`
let _ = format!("\n\n\n{\n\n\n");
//~^ ERROR invalid format string
let _ = format!(r###"
diff --git a/tests/ui/parser/issues/issue-62913.rs b/tests/ui/parser/issues/issue-62913.rs
index 0db06f636c3ec..a55ef5ac71030 100644
--- a/tests/ui/parser/issues/issue-62913.rs
+++ b/tests/ui/parser/issues/issue-62913.rs
@@ -1,4 +1,4 @@
"\u\\"
//~^ ERROR incorrect unicode escape sequence
//~| ERROR invalid trailing slash in literal
-//~| ERROR expected item, found `"\u\\"`
+//~| ERROR expected item, found `"\u\"`