bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Rework trait expansion to happen once explicitly

Browse source
This commit is contained in:
Michael Goulet 2024-12-04 02:04:26 +00:00
parent 8361aef0d7
commit 824a867e82
26 changed files with 576 additions and 657 deletions
Download patch file Download diff file Expand all files Collapse all files

203
compiler/rustc_hir_analysis/src/hir_ty_lowering/dyn_compatibility.rs
View file

@ -4,13 +4,12 @@ use rustc_errors::struct_span_code_err;
use rustc_hir as hir; use rustc_hir as hir;
use rustc_hir::def::{DefKind, Res}; use rustc_hir::def::{DefKind, Res};
use rustc_lint_defs::builtin::UNUSED_ASSOCIATED_TYPE_BOUNDS; use rustc_lint_defs::builtin::UNUSED_ASSOCIATED_TYPE_BOUNDS;
use rustc_middle::span_bug;
use rustc_middle::ty::fold::BottomUpFolder; use rustc_middle::ty::fold::BottomUpFolder;
use rustc_middle::ty::{ use rustc_middle::ty::{
self, DynKind, ExistentialPredicateStableCmpExt as _, Ty, TyCtxt, TypeFoldable, self, DynKind, ExistentialPredicateStableCmpExt as _, Ty, TyCtxt, TypeFoldable,
TypeVisitableExt, Upcast, TypeVisitableExt, Upcast,
}; };
use rustc_span::{DUMMY_SP, ErrorGuaranteed, Span}; use rustc_span::{ErrorGuaranteed, Span};
use rustc_trait_selection::error_reporting::traits::report_dyn_incompatibility; use rustc_trait_selection::error_reporting::traits::report_dyn_incompatibility;
use rustc_trait_selection::traits::{self, hir_ty_lowering_dyn_compatibility_violations}; use rustc_trait_selection::traits::{self, hir_ty_lowering_dyn_compatibility_violations};
use rustc_type_ir::elaborate::ClauseWithSupertraitSpan; use rustc_type_ir::elaborate::ClauseWithSupertraitSpan;
@ -30,16 +29,16 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
&self, &self,
span: Span, span: Span,
hir_id: hir::HirId, hir_id: hir::HirId,
hir_trait_bounds: &[hir::PolyTraitRef<'tcx>], hir_bounds: &[hir::PolyTraitRef<'tcx>],
lifetime: &hir::Lifetime, lifetime: &hir::Lifetime,
representation: DynKind, representation: DynKind,
) -> Ty<'tcx> { ) -> Ty<'tcx> {
let tcx = self.tcx(); let tcx = self.tcx();
let dummy_self = tcx.types.trait_object_dummy_self;
let mut bounds = Bounds::default(); let mut user_written_bounds = Bounds::default();
let mut potential_assoc_types = Vec::new(); let mut potential_assoc_types = Vec::new();
let dummy_self = self.tcx().types.trait_object_dummy_self; for trait_bound in hir_bounds.iter() {
for trait_bound in hir_trait_bounds.iter().rev() {
if let hir::BoundPolarity::Maybe(_) = trait_bound.modifiers.polarity { if let hir::BoundPolarity::Maybe(_) = trait_bound.modifiers.polarity {
continue; continue;
} }
@ -53,92 +52,67 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
hir::BoundConstness::Never, hir::BoundConstness::Never,
hir::BoundPolarity::Positive, hir::BoundPolarity::Positive,
dummy_self, dummy_self,
&mut bounds, &mut user_written_bounds,
PredicateFilter::SelfOnly, PredicateFilter::SelfOnly,
) { ) {
potential_assoc_types.extend(cur_potential_assoc_types); potential_assoc_types.extend(cur_potential_assoc_types);
} }
} }
let mut trait_bounds = vec![]; let (trait_bounds, mut projection_bounds) =
let mut projection_bounds = vec![]; traits::expand_trait_aliases(tcx, user_written_bounds.clauses());
for (pred, span) in bounds.clauses() { let (regular_traits, mut auto_traits): (Vec<_>, Vec<_>) = trait_bounds
let bound_pred = pred.kind(); .into_iter()
match bound_pred.skip_binder() { .partition(|(trait_ref, _)| !tcx.trait_is_auto(trait_ref.def_id()));
ty::ClauseKind::Trait(trait_pred) => {
assert_eq!(trait_pred.polarity, ty::PredicatePolarity::Positive); // We don't support empty trait objects.
trait_bounds.push((bound_pred.rebind(trait_pred.trait_ref), span)); if regular_traits.is_empty() && auto_traits.is_empty() {
} let guar =
ty::ClauseKind::Projection(proj) => { self.report_trait_object_with_no_traits_error(span, user_written_bounds.clauses());
projection_bounds.push((bound_pred.rebind(proj), span)); return Ty::new_error(tcx, guar);
}
ty::ClauseKind::TypeOutlives(_) => {
// Do nothing, we deal with regions separately
}
ty::ClauseKind::RegionOutlives(_)
| ty::ClauseKind::ConstArgHasType(..)
| ty::ClauseKind::WellFormed(_)
| ty::ClauseKind::ConstEvaluatable(_)
| ty::ClauseKind::HostEffect(..) => {
span_bug!(span, "did not expect {pred} clause in object bounds");
}
}
} }
// Expand trait aliases recursively and check that only one regular (non-auto) trait
// is used and no 'maybe' bounds are used.
let expanded_traits =
traits::expand_trait_aliases(tcx, trait_bounds.iter().map(|&(a, b)| (a, b)));
let (mut auto_traits, regular_traits): (Vec<_>, Vec<_>) =
expanded_traits.partition(|i| tcx.trait_is_auto(i.trait_ref().def_id()));
// We don't support >1 principal // We don't support >1 principal
if regular_traits.len() > 1 { if regular_traits.len() > 1 {
let guar = self.report_trait_object_addition_traits_error(&regular_traits); let guar = self.report_trait_object_addition_traits_error(&regular_traits);
return Ty::new_error(tcx, guar); return Ty::new_error(tcx, guar);
} }
// We don't support empty trait objects.
if regular_traits.is_empty() && auto_traits.is_empty() {
let guar = self.report_trait_object_with_no_traits_error(span, &trait_bounds);
return Ty::new_error(tcx, guar);
}
// Don't create a dyn trait if we have errors in the principal. // Don't create a dyn trait if we have errors in the principal.
if let Err(guar) = trait_bounds.error_reported() { if let Err(guar) = regular_traits.error_reported() {
return Ty::new_error(tcx, guar); return Ty::new_error(tcx, guar);
} }
// Check that there are no gross dyn-compatibility violations; // Check that there are no gross dyn-compatibility violations;
// most importantly, that the supertraits don't contain `Self`, // most importantly, that the supertraits don't contain `Self`,
// to avoid ICEs. // to avoid ICEs.
for item in &regular_traits { for (clause, span) in user_written_bounds.clauses() {
let violations = if let Some(trait_pred) = clause.as_trait_clause() {
hir_ty_lowering_dyn_compatibility_violations(tcx, item.trait_ref().def_id()); let violations =
if !violations.is_empty() { hir_ty_lowering_dyn_compatibility_violations(tcx, trait_pred.def_id());
let reported = report_dyn_incompatibility( if !violations.is_empty() {
tcx, let reported = report_dyn_incompatibility(
span, tcx,
Some(hir_id), span,
item.trait_ref().def_id(), Some(hir_id),
&violations, trait_pred.def_id(),
) &violations,
.emit(); )
return Ty::new_error(tcx, reported); .emit();
return Ty::new_error(tcx, reported);
}
} }
} }
let principal_trait = regular_traits.into_iter().next();
let mut needed_associated_types = FxIndexSet::default(); let mut needed_associated_types = FxIndexSet::default();
if let Some((principal_trait, spans)) = &principal_trait {
let principal_span = regular_traits.first().map_or(DUMMY_SP, |info| info.bottom().1); let pred: ty::Predicate<'tcx> = (*principal_trait).upcast(tcx);
let regular_traits_refs_spans = trait_bounds
.into_iter()
.filter(|(trait_ref, _)| !tcx.trait_is_auto(trait_ref.def_id()));
for (base_trait_ref, original_span) in regular_traits_refs_spans {
let base_pred: ty::Predicate<'tcx> = base_trait_ref.upcast(tcx);
for ClauseWithSupertraitSpan { pred, supertrait_span } in for ClauseWithSupertraitSpan { pred, supertrait_span } in
traits::elaborate(tcx, [ClauseWithSupertraitSpan::new(base_pred, original_span)]) traits::elaborate(tcx, [ClauseWithSupertraitSpan::new(
.filter_only_self() pred,
*spans.last().unwrap(),
)])
.filter_only_self()
{ {
debug!("observing object predicate `{pred:?}`"); debug!("observing object predicate `{pred:?}`");
@ -179,7 +153,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
// } // }
// ``` // ```
// //
// Here, the user could theoretically write `dyn MyTrait<Output = X>`, // Here, the user could theoretically write `dyn MyTrait<MyOutput = X>`,
// but actually supporting that would "expand" to an infinitely-long type // but actually supporting that would "expand" to an infinitely-long type
// `fix $ τ → dyn MyTrait<MyOutput = X, Output = <τ as MyTrait>::MyOutput`. // `fix $ τ → dyn MyTrait<MyOutput = X, Output = <τ as MyTrait>::MyOutput`.
// //
@ -188,12 +162,12 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
// the discussion in #56288 for alternatives. // the discussion in #56288 for alternatives.
if !references_self { if !references_self {
// Include projections defined on supertraits. // Include projections defined on supertraits.
projection_bounds.push((pred, original_span)); projection_bounds.push((pred, supertrait_span));
} }
self.check_elaborated_projection_mentions_input_lifetimes( self.check_elaborated_projection_mentions_input_lifetimes(
pred, pred,
original_span, *spans.first().unwrap(),
supertrait_span, supertrait_span,
); );
} }
@ -202,11 +176,13 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
} }
} }
// `dyn Trait<Assoc = Foo>` desugars to (not Rust syntax) `dyn Trait where <Self as Trait>::Assoc = Foo`. // `dyn Trait<Assoc = Foo>` desugars to (not Rust syntax) `dyn Trait where
// So every `Projection` clause is an `Assoc = Foo` bound. `associated_types` contains all associated // <Self as Trait>::Assoc = Foo`. So every `Projection` clause is an
// types's `DefId`, so the following loop removes all the `DefIds` of the associated types that have a // `Assoc = Foo` bound. `needed_associated_types` contains all associated
// corresponding `Projection` clause // types that we expect to be provided by the user, so the following loop
for (projection_bound, span) in &projection_bounds { // removes all the associated types that have a corresponding `Projection`
// clause, either from expanding trait aliases or written by the user.
for &(projection_bound, span) in &projection_bounds {
let def_id = projection_bound.item_def_id(); let def_id = projection_bound.item_def_id();
let trait_ref = tcx.anonymize_bound_vars( let trait_ref = tcx.anonymize_bound_vars(
projection_bound.map_bound(|p| p.projection_term.trait_ref(tcx)), projection_bound.map_bound(|p| p.projection_term.trait_ref(tcx)),
@ -216,17 +192,17 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
tcx.emit_node_span_lint( tcx.emit_node_span_lint(
UNUSED_ASSOCIATED_TYPE_BOUNDS, UNUSED_ASSOCIATED_TYPE_BOUNDS,
hir_id, hir_id,
*span, span,
crate::errors::UnusedAssociatedTypeBounds { span: *span }, crate::errors::UnusedAssociatedTypeBounds { span },
); );
} }
} }
if let Err(guar) = self.check_for_required_assoc_tys( if let Err(guar) = self.check_for_required_assoc_tys(
principal_span, principal_trait.as_ref().map_or(smallvec![], |(_, spans)| spans.clone()),
needed_associated_types, needed_associated_types,
potential_assoc_types, potential_assoc_types,
hir_trait_bounds, hir_bounds,
) { ) {
return Ty::new_error(tcx, guar); return Ty::new_error(tcx, guar);
} }
@ -236,32 +212,36 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
// We remove duplicates by inserting into a `FxHashSet` to avoid re-ordering // We remove duplicates by inserting into a `FxHashSet` to avoid re-ordering
// the bounds // the bounds
let mut duplicates = FxHashSet::default(); let mut duplicates = FxHashSet::default();
auto_traits.retain(|i| duplicates.insert(i.trait_ref().def_id())); auto_traits.retain(|(trait_pred, _)| duplicates.insert(trait_pred.def_id()));
debug!(?regular_traits);
debug!(?principal_trait);
debug!(?auto_traits); debug!(?auto_traits);
// Erase the `dummy_self` (`trait_object_dummy_self`) used above. // Erase the `dummy_self` (`trait_object_dummy_self`) used above.
let existential_trait_refs = regular_traits.iter().map(|i| { let principal_trait_ref = principal_trait.map(|(trait_pred, spans)| {
i.trait_ref().map_bound(|trait_ref: ty::TraitRef<'tcx>| { trait_pred.map_bound(|trait_pred| {
let trait_ref = trait_pred.trait_ref;
assert_eq!(trait_pred.polarity, ty::PredicatePolarity::Positive);
assert_eq!(trait_ref.self_ty(), dummy_self); assert_eq!(trait_ref.self_ty(), dummy_self);
let span = *spans.first().unwrap();
// Verify that `dummy_self` did not leak inside default type parameters. This // Verify that `dummy_self` did not leak inside default type parameters. This
// could not be done at path creation, since we need to see through trait aliases. // could not be done at path creation, since we need to see through trait aliases.
let mut missing_type_params = vec![]; let mut missing_type_params = vec![];
let mut references_self = false;
let generics = tcx.generics_of(trait_ref.def_id); let generics = tcx.generics_of(trait_ref.def_id);
let args: Vec<_> = trait_ref let args: Vec<_> = trait_ref
.args .args
.iter() .iter()
.enumerate() .enumerate()
.skip(1) // Remove `Self` for `ExistentialPredicate`. // Skip `Self`
.skip(1)
.map(|(index, arg)| { .map(|(index, arg)| {
if arg == dummy_self.into() { if arg == dummy_self.into() {
let param = &generics.own_params[index]; let param = &generics.own_params[index];
missing_type_params.push(param.name); missing_type_params.push(param.name);
Ty::new_misc_error(tcx).into() Ty::new_misc_error(tcx).into()
} else if arg.walk().any(|arg| arg == dummy_self.into()) { } else if arg.walk().any(|arg| arg == dummy_self.into()) {
references_self = true;
let guar = self.dcx().span_delayed_bug( let guar = self.dcx().span_delayed_bug(
span, span,
"trait object trait bounds reference `Self`", "trait object trait bounds reference `Self`",
@ -273,8 +253,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
}) })
.collect(); .collect();
let span = i.bottom().1; let empty_generic_args = hir_bounds.iter().any(|hir_bound| {
let empty_generic_args = hir_trait_bounds.iter().any(|hir_bound| {
hir_bound.trait_ref.path.res == Res::Def(DefKind::Trait, trait_ref.def_id) hir_bound.trait_ref.path.res == Res::Def(DefKind::Trait, trait_ref.def_id)
&& hir_bound.span.contains(span) && hir_bound.span.contains(span)
}); });
@ -285,26 +264,11 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
empty_generic_args, empty_generic_args,
); );
if references_self { ty::ExistentialPredicate::Trait(ty::ExistentialTraitRef::new(
let def_id = i.bottom().0.def_id(); tcx,
struct_span_code_err!( trait_ref.def_id,
self.dcx(), args,
i.bottom().1, ))
E0038,
"the {} `{}` cannot be made into an object",
tcx.def_descr(def_id),
tcx.item_name(def_id),
)
.with_note(
rustc_middle::traits::DynCompatibilityViolation::SupertraitSelf(
smallvec![],
)
.error_msg(),
)
.emit();
}
ty::ExistentialTraitRef::new(tcx, trait_ref.def_id, args)
}) })
}); });
@ -327,21 +291,24 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
b.projection_term = replace_dummy_self_with_error(tcx, b.projection_term, guar); b.projection_term = replace_dummy_self_with_error(tcx, b.projection_term, guar);
} }
ty::ExistentialProjection::erase_self_ty(tcx, b) ty::ExistentialPredicate::Projection(ty::ExistentialProjection::erase_self_ty(
tcx, b,
))
}) })
}); });
let regular_trait_predicates = existential_trait_refs let auto_trait_predicates = auto_traits.into_iter().map(|(trait_pred, _)| {
.map(|trait_ref| trait_ref.map_bound(ty::ExistentialPredicate::Trait)); assert_eq!(trait_pred.polarity(), ty::PredicatePolarity::Positive);
let auto_trait_predicates = auto_traits.into_iter().map(|trait_ref| { assert_eq!(trait_pred.self_ty().skip_binder(), dummy_self);
ty::Binder::dummy(ty::ExistentialPredicate::AutoTrait(trait_ref.trait_ref().def_id()))
ty::Binder::dummy(ty::ExistentialPredicate::AutoTrait(trait_pred.def_id()))
}); });
// N.b. principal, projections, auto traits // N.b. principal, projections, auto traits
// FIXME: This is actually wrong with multiple principals in regards to symbol mangling // FIXME: This is actually wrong with multiple principals in regards to symbol mangling
let mut v = regular_trait_predicates let mut v = principal_trait_ref
.chain( .into_iter()
existential_projections.map(|x| x.map_bound(ty::ExistentialPredicate::Projection)), .chain(existential_projections)
)
.chain(auto_trait_predicates) .chain(auto_trait_predicates)
.collect::<SmallVec<[_; 8]>>(); .collect::<SmallVec<[_; 8]>>();
v.sort_by(|a, b| a.skip_binder().stable_cmp(tcx, &b.skip_binder())); v.sort_by(|a, b| a.skip_binder().stable_cmp(tcx, &b.skip_binder()));

50
compiler/rustc_hir_analysis/src/hir_ty_lowering/errors.rs
View file

@ -11,7 +11,7 @@ use rustc_hir::def_id::DefId;
use rustc_middle::bug; use rustc_middle::bug;
use rustc_middle::ty::print::{PrintPolyTraitRefExt as _, PrintTraitRefExt as _}; use rustc_middle::ty::print::{PrintPolyTraitRefExt as _, PrintTraitRefExt as _};
use rustc_middle::ty::{ use rustc_middle::ty::{
self, AdtDef, Binder, GenericParamDefKind, TraitRef, Ty, TyCtxt, TypeVisitableExt, self, AdtDef, GenericParamDefKind, Ty, TyCtxt, TypeVisitableExt,
suggest_constraining_type_param, suggest_constraining_type_param,
}; };
use rustc_session::parse::feature_err; use rustc_session::parse::feature_err;
@ -19,8 +19,9 @@ use rustc_span::edit_distance::find_best_match_for_name;
use rustc_span::{BytePos, DUMMY_SP, Ident, Span, Symbol, kw, sym}; use rustc_span::{BytePos, DUMMY_SP, Ident, Span, Symbol, kw, sym};
use rustc_trait_selection::error_reporting::traits::report_dyn_incompatibility; use rustc_trait_selection::error_reporting::traits::report_dyn_incompatibility;
use rustc_trait_selection::traits::{ use rustc_trait_selection::traits::{
FulfillmentError, TraitAliasExpansionInfo, dyn_compatibility_violations_for_assoc_item, FulfillmentError, dyn_compatibility_violations_for_assoc_item,
}; };
use smallvec::SmallVec;
use crate::errors::{ use crate::errors::{
self, AssocItemConstraintsNotAllowedHere, ManualImplementation, MissingTypeParams, self, AssocItemConstraintsNotAllowedHere, ManualImplementation, MissingTypeParams,
@ -720,7 +721,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
/// emit a generic note suggesting using a `where` clause to constraint instead. /// emit a generic note suggesting using a `where` clause to constraint instead.
pub(crate) fn check_for_required_assoc_tys( pub(crate) fn check_for_required_assoc_tys(
&self, &self,
principal_span: Span, spans: SmallVec<[Span; 1]>,
missing_assoc_types: FxIndexSet<(DefId, ty::PolyTraitRef<'tcx>)>, missing_assoc_types: FxIndexSet<(DefId, ty::PolyTraitRef<'tcx>)>,
potential_assoc_types: Vec<usize>, potential_assoc_types: Vec<usize>,
trait_bounds: &[hir::PolyTraitRef<'_>], trait_bounds: &[hir::PolyTraitRef<'_>],
@ -729,6 +730,8 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
return Ok(()); return Ok(());
} }
let principal_span = *spans.first().unwrap();
let tcx = self.tcx(); let tcx = self.tcx();
// FIXME: This logic needs some more care w.r.t handling of conflicts // FIXME: This logic needs some more care w.r.t handling of conflicts
let missing_assoc_types: Vec<_> = missing_assoc_types let missing_assoc_types: Vec<_> = missing_assoc_types
@ -1124,29 +1127,36 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
pub fn report_trait_object_addition_traits_error( pub fn report_trait_object_addition_traits_error(
&self, &self,
regular_traits: &Vec<TraitAliasExpansionInfo<'_>>, regular_traits: &Vec<(ty::PolyTraitPredicate<'tcx>, SmallVec<[Span; 1]>)>,
) -> ErrorGuaranteed { ) -> ErrorGuaranteed {
let first_trait = &regular_traits[0]; // we use the last span to point at the traits themselves,
let additional_trait = &regular_traits[1]; // and all other preceding spans are trait alias expansions.
let (&first_span, first_alias_spans) = regular_traits[0].1.split_last().unwrap();
let (&second_span, second_alias_spans) = regular_traits[1].1.split_last().unwrap();
let mut err = struct_span_code_err!( let mut err = struct_span_code_err!(
self.dcx(), self.dcx(),
additional_trait.bottom().1, *regular_traits[1].1.first().unwrap(),
E0225, E0225,
"only auto traits can be used as additional traits in a trait object" "only auto traits can be used as additional traits in a trait object"
); );
additional_trait.label_with_exp_info( err.span_label(first_span, "first non-auto trait");
&mut err, for &alias_span in first_alias_spans {
"additional non-auto trait", err.span_label(alias_span, "first non-auto trait comes from this alias");
"additional use", }
); err.span_label(second_span, "additional non-auto trait");
first_trait.label_with_exp_info(&mut err, "first non-auto trait", "first use"); for &alias_span in second_alias_spans {
err.span_label(alias_span, "second non-auto trait comes from this alias");
}
err.help(format!( err.help(format!(
"consider creating a new trait with all of these as supertraits and using that \ "consider creating a new trait with all of these as supertraits and using that \
trait here instead: `trait NewTrait: {} {{}}`", trait here instead: `trait NewTrait: {} {{}}`",
regular_traits regular_traits
.iter() .iter()
// FIXME: This should `print_sugared`, but also needs to integrate projection bounds... // FIXME: This should `print_sugared`, but also needs to integrate projection bounds...
.map(|t| t.trait_ref().print_only_trait_path().to_string()) .map(|(pred, _)| pred
.map_bound(|pred| pred.trait_ref)
.print_only_trait_path()
.to_string())
.collect::<Vec<_>>() .collect::<Vec<_>>()
.join(" + "), .join(" + "),
)); ));
@ -1161,14 +1171,14 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
pub fn report_trait_object_with_no_traits_error( pub fn report_trait_object_with_no_traits_error(
&self, &self,
span: Span, span: Span,
trait_bounds: &Vec<(Binder<'tcx, TraitRef<'tcx>>, Span)>, user_written_clauses: impl IntoIterator<Item = (ty::Clause<'tcx>, Span)>,
) -> ErrorGuaranteed { ) -> ErrorGuaranteed {
let tcx = self.tcx(); let tcx = self.tcx();
let trait_alias_span = trait_bounds let trait_alias_span = user_written_clauses
.iter() .into_iter()
.map(|&(trait_ref, _)| trait_ref.def_id()) .filter_map(|(clause, _)| clause.as_trait_clause())
.find(|&trait_ref| tcx.is_trait_alias(trait_ref)) .find(|trait_ref| tcx.is_trait_alias(trait_ref.def_id()))
.map(|trait_ref| tcx.def_span(trait_ref)); .map(|trait_ref| tcx.def_span(trait_ref.def_id()));
self.dcx().emit_err(TraitObjectDeclaredWithNoTraits { span, trait_alias_span }) self.dcx().emit_err(TraitObjectDeclaredWithNoTraits { span, trait_alias_span })
} }

11
compiler/rustc_hir_typeck/src/method/probe.rs
View file

@ -1,6 +1,5 @@
use std::cell::{Cell, RefCell}; use std::cell::{Cell, RefCell};
use std::cmp::max; use std::cmp::max;
use std::iter;
use std::ops::Deref; use std::ops::Deref;
use rustc_data_structures::fx::FxHashSet; use rustc_data_structures::fx::FxHashSet;
@ -1009,11 +1008,11 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
if self.tcx.is_trait_alias(trait_def_id) { if self.tcx.is_trait_alias(trait_def_id) {
// For trait aliases, recursively assume all explicitly named traits are relevant // For trait aliases, recursively assume all explicitly named traits are relevant
for expansion in traits::expand_trait_aliases( for (bound_trait_pred, _) in
self.tcx, traits::expand_trait_aliases(self.tcx, [(trait_ref.upcast(self.tcx), self.span)]).0
iter::once((ty::Binder::dummy(trait_ref), self.span)), {
) { assert_eq!(bound_trait_pred.polarity(), ty::PredicatePolarity::Positive);
let bound_trait_ref = expansion.trait_ref(); let bound_trait_ref = bound_trait_pred.map_bound(|pred| pred.trait_ref);
for item in self.impl_or_trait_item(bound_trait_ref.def_id()) { for item in self.impl_or_trait_item(bound_trait_ref.def_id()) {
if !self.has_applicable_self(&item) { if !self.has_applicable_self(&item) {
self.record_static_candidate(CandidateSource::Trait( self.record_static_candidate(CandidateSource::Trait(

3
compiler/rustc_trait_selection/src/error_reporting/traits/mod.rs
View file

@ -437,7 +437,8 @@ pub fn report_dyn_incompatibility<'tcx>(
tcx.dcx(), tcx.dcx(),
span, span,
E0038, E0038,
"the trait `{}` cannot be made into an object", "the {} `{}` cannot be made into an object",
tcx.def_descr(trait_def_id),
trait_str trait_str
); );
err.span_label(span, format!("`{trait_str}` cannot be made into an object")); err.span_label(span, format!("`{trait_str}` cannot be made into an object"));

6
compiler/rustc_trait_selection/src/traits/mod.rs
View file

@ -66,9 +66,9 @@ pub use self::specialize::{
}; };
pub use self::structural_normalize::StructurallyNormalizeExt; pub use self::structural_normalize::StructurallyNormalizeExt;
pub use self::util::{ pub use self::util::{
BoundVarReplacer, PlaceholderReplacer, TraitAliasExpander, TraitAliasExpansionInfo, elaborate, BoundVarReplacer, PlaceholderReplacer, elaborate, expand_trait_aliases, impl_item_is_final,
expand_trait_aliases, impl_item_is_final, supertraits, supertraits, transitive_bounds_that_define_assoc_item, upcast_choices,
transitive_bounds_that_define_assoc_item, upcast_choices, with_replaced_escaping_bound_vars, with_replaced_escaping_bound_vars,
}; };
use crate::error_reporting::InferCtxtErrorExt; use crate::error_reporting::InferCtxtErrorExt;
use crate::infer::outlives::env::OutlivesEnvironment; use crate::infer::outlives::env::OutlivesEnvironment;

205
compiler/rustc_trait_selection/src/traits/util.rs
View file

@ -1,162 +1,85 @@
use std::collections::BTreeMap; use std::collections::{BTreeMap, VecDeque};
use rustc_data_structures::fx::FxIndexMap; use rustc_data_structures::fx::{FxHashSet, FxIndexMap};
use rustc_errors::Diag;
use rustc_hir::def_id::DefId; use rustc_hir::def_id::DefId;
use rustc_infer::infer::InferCtxt; use rustc_infer::infer::InferCtxt;
pub use rustc_infer::traits::util::*; pub use rustc_infer::traits::util::*;
use rustc_middle::bug; use rustc_middle::bug;
use rustc_middle::ty::{ use rustc_middle::ty::{
self, Ty, TyCtxt, TypeFoldable, TypeFolder, TypeSuperFoldable, TypeVisitableExt, Upcast, self, Ty, TyCtxt, TypeFoldable, TypeFolder, TypeSuperFoldable, TypeVisitableExt,
}; };
use rustc_span::Span; use rustc_span::Span;
use smallvec::{SmallVec, smallvec}; use smallvec::{SmallVec, smallvec};
use tracing::debug; use tracing::debug;
/////////////////////////////////////////////////////////////////////////// /// Return the trait and projection predicates that come from eagerly expanding the
// `TraitAliasExpander` iterator /// trait aliases in the list of clauses. For each trait predicate, record a stack
/////////////////////////////////////////////////////////////////////////// /// of spans that trace from the user-written trait alias bound. For projection predicates,
/// just record the span of the projection itself.
/// "Trait alias expansion" is the process of expanding a sequence of trait ///
/// references into another sequence by transitively following all trait /// For trait aliases, we don't deduplicte the predicates, since we currently do not
/// aliases. e.g. If you have bounds like `Foo + Send`, a trait alias /// consider duplicated traits as a single trait for the purposes of our "one trait principal"
/// `trait Foo = Bar + Sync;`, and another trait alias /// restriction; however, for projections we do deduplicate them.
/// `trait Bar = Read + Write`, then the bounds would expand to ///
/// `Read + Write + Sync + Send`. /// ```rust,ignore (fails)
/// Expansion is done via a DFS (depth-first search), and the `visited` field /// trait Bar {}
/// is used to avoid cycles. /// trait Foo = Bar + Bar;
pub struct TraitAliasExpander<'tcx> { ///
tcx: TyCtxt<'tcx>, /// let not_object_safe: dyn Foo; // bad, two `Bar` principals.
stack: Vec<TraitAliasExpansionInfo<'tcx>>, /// ```
}
/// Stores information about the expansion of a trait via a path of zero or more trait aliases.
#[derive(Debug, Clone)]
pub struct TraitAliasExpansionInfo<'tcx> {
pub path: SmallVec<[(ty::PolyTraitRef<'tcx>, Span); 4]>,
}
impl<'tcx> TraitAliasExpansionInfo<'tcx> {
fn new(trait_ref: ty::PolyTraitRef<'tcx>, span: Span) -> Self {
Self { path: smallvec![(trait_ref, span)] }
}
/// Adds diagnostic labels to `diag` for the expansion path of a trait through all intermediate
/// trait aliases.
pub fn label_with_exp_info(
&self,
diag: &mut Diag<'_>,
top_label: &'static str,
use_desc: &str,
) {
diag.span_label(self.top().1, top_label);
if self.path.len() > 1 {
for (_, sp) in self.path.iter().rev().skip(1).take(self.path.len() - 2) {
diag.span_label(*sp, format!("referenced here ({use_desc})"));
}
}
if self.top().1 != self.bottom().1 {
// When the trait object is in a return type these two spans match, we don't want
// redundant labels.
diag.span_label(
self.bottom().1,
format!("trait alias used in trait object type ({use_desc})"),
);
}
}
pub fn trait_ref(&self) -> ty::PolyTraitRef<'tcx> {
self.top().0
}
pub fn top(&self) -> &(ty::PolyTraitRef<'tcx>, Span) {
self.path.last().unwrap()
}
pub fn bottom(&self) -> &(ty::PolyTraitRef<'tcx>, Span) {
self.path.first().unwrap()
}
fn clone_and_push(&self, trait_ref: ty::PolyTraitRef<'tcx>, span: Span) -> Self {
let mut path = self.path.clone();
path.push((trait_ref, span));
Self { path }
}
}
pub fn expand_trait_aliases<'tcx>( pub fn expand_trait_aliases<'tcx>(
tcx: TyCtxt<'tcx>, tcx: TyCtxt<'tcx>,
trait_refs: impl Iterator<Item = (ty::PolyTraitRef<'tcx>, Span)>, clauses: impl IntoIterator<Item = (ty::Clause<'tcx>, Span)>,
) -> TraitAliasExpander<'tcx> { ) -> (
let items: Vec<_> = Vec<(ty::PolyTraitPredicate<'tcx>, SmallVec<[Span; 1]>)>,
trait_refs.map(|(trait_ref, span)| TraitAliasExpansionInfo::new(trait_ref, span)).collect(); Vec<(ty::PolyProjectionPredicate<'tcx>, Span)>,
TraitAliasExpander { tcx, stack: items } ) {
} let mut trait_preds = vec![];
let mut projection_preds = vec![];
let mut seen_projection_preds = FxHashSet::default();
impl<'tcx> TraitAliasExpander<'tcx> { let mut queue: VecDeque<_> = clauses.into_iter().map(|(p, s)| (p, smallvec![s])).collect();
/// If `item` is a trait alias and its predicate has not yet been visited, then expands `item`
/// to the definition, pushes the resulting expansion onto `self.stack`, and returns `false`.
/// Otherwise, immediately returns `true` if `item` is a regular trait, or `false` if it is a
/// trait alias.
/// The return value indicates whether `item` should be yielded to the user.
fn expand(&mut self, item: &TraitAliasExpansionInfo<'tcx>) -> bool {
let tcx = self.tcx;
let trait_ref = item.trait_ref();
let pred = trait_ref.upcast(tcx);
debug!("expand_trait_aliases: trait_ref={:?}", trait_ref); while let Some((clause, spans)) = queue.pop_front() {
match clause.kind().skip_binder() {
// Don't recurse if this bound is not a trait alias. ty::ClauseKind::Trait(trait_pred) => {
let is_alias = tcx.is_trait_alias(trait_ref.def_id()); if tcx.is_trait_alias(trait_pred.def_id()) {
if !is_alias { queue.extend(
return true; tcx.explicit_super_predicates_of(trait_pred.def_id())
} .iter_identity_copied()
.map(|(clause, span)| {
// Don't recurse if this trait alias is already on the stack for the DFS search. let mut spans = spans.clone();
let anon_pred = anonymize_predicate(tcx, pred); spans.push(span);
if item (
.path clause.instantiate_supertrait(
.iter() tcx,
.rev() clause.kind().rebind(trait_pred.trait_ref),
.skip(1) ),
.any(|&(tr, _)| anonymize_predicate(tcx, tr.upcast(tcx)) == anon_pred) spans,
{ )
return false; }),
} );
} else {
// Get components of trait alias. trait_preds.push((clause.kind().rebind(trait_pred), spans));
let predicates = tcx.explicit_super_predicates_of(trait_ref.def_id()); }
debug!(?predicates);
let items = predicates.skip_binder().iter().rev().filter_map(|(pred, span)| {
pred.instantiate_supertrait(tcx, trait_ref)
.as_trait_clause()
.map(|trait_ref| item.clone_and_push(trait_ref.map_bound(|t| t.trait_ref), *span))
});
debug!("expand_trait_aliases: items={:?}", items.clone().collect::<Vec<_>>());
self.stack.extend(items);
false
}
}
impl<'tcx> Iterator for TraitAliasExpander<'tcx> {
type Item = TraitAliasExpansionInfo<'tcx>;
fn size_hint(&self) -> (usize, Option<usize>) {
(self.stack.len(), None)
}
fn next(&mut self) -> Option<TraitAliasExpansionInfo<'tcx>> {
while let Some(item) = self.stack.pop() {
if self.expand(&item) {
return Some(item);
} }
ty::ClauseKind::Projection(projection_pred) => {
let projection_pred = clause.kind().rebind(projection_pred);
if !seen_projection_preds.insert(tcx.anonymize_bound_vars(projection_pred)) {
continue;
}
projection_preds.push((projection_pred, *spans.last().unwrap()));
}
ty::ClauseKind::RegionOutlives(..)
| ty::ClauseKind::TypeOutlives(..)
| ty::ClauseKind::ConstArgHasType(_, _)
| ty::ClauseKind::WellFormed(_)
| ty::ClauseKind::ConstEvaluatable(_)
| ty::ClauseKind::HostEffect(..) => {}
} }
None
} }
(trait_preds, projection_preds)
} }
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////

8
compiler/rustc_type_ir/src/visit.rs
View file

@ -47,6 +47,7 @@ use std::ops::ControlFlow;
use rustc_ast_ir::visit::VisitorResult; use rustc_ast_ir::visit::VisitorResult;
use rustc_ast_ir::{try_visit, walk_visitable_list}; use rustc_ast_ir::{try_visit, walk_visitable_list};
use rustc_index::{Idx, IndexVec}; use rustc_index::{Idx, IndexVec};
use smallvec::SmallVec;
use thin_vec::ThinVec; use thin_vec::ThinVec;
use crate::data_structures::Lrc; use crate::data_structures::Lrc;
@ -192,6 +193,13 @@ impl<I: Interner, T: TypeVisitable<I>> TypeVisitable<I> for ThinVec<T> {
} }
} }
impl<I: Interner, T: TypeVisitable<I>, const N: usize> TypeVisitable<I> for SmallVec<[T; N]> {
fn visit_with<V: TypeVisitor<I>>(&self, visitor: &mut V) -> V::Result {
walk_visitable_list!(visitor, self.iter());
V::Result::output()
}
}
// `TypeFoldable` isn't impl'd for `&[T]`. It doesn't make sense in the general // `TypeFoldable` isn't impl'd for `&[T]`. It doesn't make sense in the general
// case, because we can't return a new slice. But note that there are a couple // case, because we can't return a new slice. But note that there are a couple
// of trivial impls of `TypeFoldable` for specific slice types elsewhere. // of trivial impls of `TypeFoldable` for specific slice types elsewhere.

4
tests/rustdoc-ui/issues/ice-generic-type-alias-105742.stderr
View file

@ -295,10 +295,10 @@ LL | Output = <Self as SVec>::Item> as SVec>::Item<T>,
| +++ | +++
error[E0038]: the trait `SVec` cannot be made into an object error[E0038]: the trait `SVec` cannot be made into an object
--> $DIR/ice-generic-type-alias-105742.rs:5:31 --> $DIR/ice-generic-type-alias-105742.rs:5:35
| |
LL | pub fn next<'a, T>(s: &'a mut dyn SVec<Item = T, Output = T>) { LL | pub fn next<'a, T>(s: &'a mut dyn SVec<Item = T, Output = T>) {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `SVec` cannot be made into an object | ^^^^^^^^^^^^^^^^^^^^^^^^^^ `SVec` cannot be made into an object
| |
note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety> note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
--> $DIR/ice-generic-type-alias-105742.rs:15:17 --> $DIR/ice-generic-type-alias-105742.rs:15:17

8
tests/ui/const-generics/adt_const_params/const_param_ty_dyn_compatibility.stderr
View file

@ -1,8 +1,8 @@
error[E0038]: the trait `ConstParamTy_` cannot be made into an object error[E0038]: the trait `ConstParamTy_` cannot be made into an object
--> $DIR/const_param_ty_dyn_compatibility.rs:6:12 --> $DIR/const_param_ty_dyn_compatibility.rs:6:16
| |
LL | fn foo(a: &dyn ConstParamTy_) {} LL | fn foo(a: &dyn ConstParamTy_) {}
| ^^^^^^^^^^^^^^^^^ `ConstParamTy_` cannot be made into an object | ^^^^^^^^^^^^^ `ConstParamTy_` cannot be made into an object
| |
note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety> note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
--> $SRC_DIR/core/src/cmp.rs:LL:COL --> $SRC_DIR/core/src/cmp.rs:LL:COL
@ -14,10 +14,10 @@ LL | fn foo(a: &impl ConstParamTy_) {}
| ~~~~ | ~~~~
error[E0038]: the trait `UnsizedConstParamTy` cannot be made into an object error[E0038]: the trait `UnsizedConstParamTy` cannot be made into an object
--> $DIR/const_param_ty_dyn_compatibility.rs:9:12 --> $DIR/const_param_ty_dyn_compatibility.rs:9:16
| |
LL | fn bar(a: &dyn UnsizedConstParamTy) {} LL | fn bar(a: &dyn UnsizedConstParamTy) {}
| ^^^^^^^^^^^^^^^^^^^^^^^ `UnsizedConstParamTy` cannot be made into an object | ^^^^^^^^^^^^^^^^^^^ `UnsizedConstParamTy` cannot be made into an object
| |
note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety> note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
--> $SRC_DIR/core/src/cmp.rs:LL:COL --> $SRC_DIR/core/src/cmp.rs:LL:COL

12
tests/ui/dyn-compatibility/mentions-Self-in-super-predicates.stderr
View file

@ -1,8 +1,8 @@
error[E0038]: the trait `Expr` cannot be made into an object error[E0038]: the trait `Expr` cannot be made into an object
--> $DIR/mentions-Self-in-super-predicates.rs:12:23 --> $DIR/mentions-Self-in-super-predicates.rs:12:27
| |
LL | elements: Vec<Box<dyn Expr + 'x>>, LL | elements: Vec<Box<dyn Expr + 'x>>,
| ^^^^^^^^^^^^^ `Expr` cannot be made into an object | ^^^^ `Expr` cannot be made into an object
| |
note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety> note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
--> $DIR/mentions-Self-in-super-predicates.rs:5:21 --> $DIR/mentions-Self-in-super-predicates.rs:5:21
@ -14,10 +14,10 @@ LL | trait Expr: Debug + PartialEq {
= help: only type `SExpr<'x>` implements the trait, consider using it directly instead = help: only type `SExpr<'x>` implements the trait, consider using it directly instead
error[E0038]: the trait `Expr` cannot be made into an object error[E0038]: the trait `Expr` cannot be made into an object
--> $DIR/mentions-Self-in-super-predicates.rs:38:16 --> $DIR/mentions-Self-in-super-predicates.rs:38:20
| |
LL | let a: Box<dyn Expr> = Box::new(SExpr::new()); LL | let a: Box<dyn Expr> = Box::new(SExpr::new());
| ^^^^^^^^ `Expr` cannot be made into an object | ^^^^ `Expr` cannot be made into an object
| |
note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety> note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
--> $DIR/mentions-Self-in-super-predicates.rs:5:21 --> $DIR/mentions-Self-in-super-predicates.rs:5:21
@ -29,10 +29,10 @@ LL | trait Expr: Debug + PartialEq {
= help: only type `SExpr<'x>` implements the trait, consider using it directly instead = help: only type `SExpr<'x>` implements the trait, consider using it directly instead
error[E0038]: the trait `Expr` cannot be made into an object error[E0038]: the trait `Expr` cannot be made into an object
--> $DIR/mentions-Self-in-super-predicates.rs:40:16 --> $DIR/mentions-Self-in-super-predicates.rs:40:20
| |
LL | let b: Box<dyn Expr> = Box::new(SExpr::new()); LL | let b: Box<dyn Expr> = Box::new(SExpr::new());
| ^^^^^^^^ `Expr` cannot be made into an object | ^^^^ `Expr` cannot be made into an object
| |
note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety> note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
--> $DIR/mentions-Self-in-super-predicates.rs:5:21 --> $DIR/mentions-Self-in-super-predicates.rs:5:21

4
tests/ui/dyn-compatibility/supertrait-mentions-Self.stderr
View file

@ -19,10 +19,10 @@ LL | trait Bar<T: ?Sized> {
| ++++++++ | ++++++++
error[E0038]: the trait `Baz` cannot be made into an object error[E0038]: the trait `Baz` cannot be made into an object
--> $DIR/supertrait-mentions-Self.rs:16:31 --> $DIR/supertrait-mentions-Self.rs:16:35
| |
LL | fn make_baz<T:Baz>(t: &T) -> &dyn Baz { LL | fn make_baz<T:Baz>(t: &T) -> &dyn Baz {
| ^^^^^^^ `Baz` cannot be made into an object | ^^^ `Baz` cannot be made into an object
| |
note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety> note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
--> $DIR/supertrait-mentions-Self.rs:8:13 --> $DIR/supertrait-mentions-Self.rs:8:13

4
tests/ui/error-codes/E0225.stderr
View file

@ -20,8 +20,8 @@ LL | trait Foo = std::io::Read + std::io::Write;
LL | let _: Box<dyn Foo>; LL | let _: Box<dyn Foo>;
| ^^^ | ^^^
| | | |
| trait alias used in trait object type (additional use) | first non-auto trait comes from this alias
| trait alias used in trait object type (first use) | second non-auto trait comes from this alias
| |
= help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: std::io::Read + std::io::Write {}` = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: std::io::Read + std::io::Write {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits> = note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>

4
tests/ui/issues/issue-26056.stderr
View file

@ -1,8 +1,8 @@
error[E0038]: the trait `Map` cannot be made into an object error[E0038]: the trait `Map` cannot be made into an object
--> $DIR/issue-26056.rs:20:13 --> $DIR/issue-26056.rs:20:17
| |
LL | as &dyn Map<Key=u32,MapValue=u32>; LL | as &dyn Map<Key=u32,MapValue=u32>;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `Map` cannot be made into an object | ^^^^^^^^^^^^^^^^^^^^^^^^^ `Map` cannot be made into an object
| |
note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety> note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
--> $DIR/issue-26056.rs:9:12 --> $DIR/issue-26056.rs:9:12

4
tests/ui/traits/alias/generic-default-in-dyn.rs
View file

@ -2,9 +2,9 @@ trait SendEqAlias<T> = PartialEq;
//~^ ERROR trait aliases are experimental //~^ ERROR trait aliases are experimental
struct Foo<T>(dyn SendEqAlias<T>); struct Foo<T>(dyn SendEqAlias<T>);
//~^ ERROR the type parameter `Rhs` must be explicitly specified [E0393] //~^ ERROR the trait alias `SendEqAlias` cannot be made into an object
struct Bar<T>(dyn SendEqAlias<T>, T); struct Bar<T>(dyn SendEqAlias<T>, T);
//~^ ERROR the type parameter `Rhs` must be explicitly specified [E0393] //~^ ERROR the trait alias `SendEqAlias` cannot be made into an object
fn main() {} fn main() {}

30
tests/ui/traits/alias/generic-default-in-dyn.stderr
View file

@ -8,29 +8,35 @@ LL | trait SendEqAlias<T> = PartialEq;
= help: add `#![feature(trait_alias)]` to the crate attributes to enable = help: add `#![feature(trait_alias)]` to the crate attributes to enable
= note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
error[E0393]: the type parameter `Rhs` must be explicitly specified error[E0038]: the trait alias `SendEqAlias` cannot be made into an object
--> $DIR/generic-default-in-dyn.rs:4:19 --> $DIR/generic-default-in-dyn.rs:4:19
| |
LL | struct Foo<T>(dyn SendEqAlias<T>); LL | struct Foo<T>(dyn SendEqAlias<T>);
| ^^^^^^^^^^^^^^ missing reference to `Rhs` | ^^^^^^^^^^^^^^ `SendEqAlias` cannot be made into an object
--> $SRC_DIR/core/src/cmp.rs:LL:COL
| |
= note: type parameter `Rhs` must be specified for this note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
--> $DIR/generic-default-in-dyn.rs:1:24
| |
= note: because of the default `Self` reference, type parameters must be specified on object types LL | trait SendEqAlias<T> = PartialEq;
| ----------- ^^^^^^^^^ ...because it uses `Self` as a type parameter
| |
| this trait cannot be made into an object...
error[E0393]: the type parameter `Rhs` must be explicitly specified error[E0038]: the trait alias `SendEqAlias` cannot be made into an object
--> $DIR/generic-default-in-dyn.rs:7:19 --> $DIR/generic-default-in-dyn.rs:7:19
| |
LL | struct Bar<T>(dyn SendEqAlias<T>, T); LL | struct Bar<T>(dyn SendEqAlias<T>, T);
| ^^^^^^^^^^^^^^ missing reference to `Rhs` | ^^^^^^^^^^^^^^ `SendEqAlias` cannot be made into an object
--> $SRC_DIR/core/src/cmp.rs:LL:COL
| |
= note: type parameter `Rhs` must be specified for this note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
--> $DIR/generic-default-in-dyn.rs:1:24
| |
= note: because of the default `Self` reference, type parameters must be specified on object types LL | trait SendEqAlias<T> = PartialEq;
| ----------- ^^^^^^^^^ ...because it uses `Self` as a type parameter
| |
| this trait cannot be made into an object...
error: aborting due to 3 previous errors error: aborting due to 3 previous errors
Some errors have detailed explanations: E0393, E0658. Some errors have detailed explanations: E0038, E0658.
For more information about an error, try `rustc --explain E0393`. For more information about an error, try `rustc --explain E0038`.

234
tests/ui/traits/alias/no-duplicates.stderr
View file

@ -4,32 +4,32 @@ error[E0225]: only auto traits can be used as additional traits in a trait objec
LL | trait _0 = Obj; LL | trait _0 = Obj;
| --- | ---
| | | |
| additional non-auto trait
| first non-auto trait | first non-auto trait
| additional non-auto trait
... ...
LL | type _T00 = dyn _0 + _0; LL | type _T00 = dyn _0 + _0;
| -- ^^ trait alias used in trait object type (additional use) | -- ^^ second non-auto trait comes from this alias
| | | |
| trait alias used in trait object type (first use) | first non-auto trait comes from this alias
| |
= help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj {}` = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits> = note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object error[E0225]: only auto traits can be used as additional traits in a trait object
--> $DIR/no-duplicates.rs:19:22 --> $DIR/no-duplicates.rs:19:17
| |
LL | trait _0 = Obj; LL | trait _0 = Obj;
| --- | ---
| | | |
| additional non-auto trait
| first non-auto trait | first non-auto trait
| additional non-auto trait
LL | trait _1 = _0; LL | trait _1 = _0;
| -- referenced here (first use) | -- second non-auto trait comes from this alias
... ...
LL | type _T01 = dyn _1 + _0; LL | type _T01 = dyn _1 + _0;
| -- ^^ trait alias used in trait object type (additional use) | ^^ -- first non-auto trait comes from this alias
| | | |
| trait alias used in trait object type (first use) | second non-auto trait comes from this alias
| |
= help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj {}` = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits> = note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
@ -40,18 +40,18 @@ error[E0225]: only auto traits can be used as additional traits in a trait objec
LL | trait _0 = Obj; LL | trait _0 = Obj;
| --- | ---
| | | |
| additional non-auto trait
| first non-auto trait | first non-auto trait
| additional non-auto trait
LL | trait _1 = _0; LL | trait _1 = _0;
| -- | --
| | | |
| referenced here (additional use) | first non-auto trait comes from this alias
| referenced here (first use) | second non-auto trait comes from this alias
... ...
LL | type _T02 = dyn _1 + _1; LL | type _T02 = dyn _1 + _1;
| -- ^^ trait alias used in trait object type (additional use) | -- ^^ second non-auto trait comes from this alias
| | | |
| trait alias used in trait object type (first use) | first non-auto trait comes from this alias
| |
= help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj {}` = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits> = note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
@ -62,10 +62,10 @@ error[E0225]: only auto traits can be used as additional traits in a trait objec
LL | trait _0 = Obj; LL | trait _0 = Obj;
| --- additional non-auto trait | --- additional non-auto trait
LL | trait _1 = _0; LL | trait _1 = _0;
| -- referenced here (additional use) | -- second non-auto trait comes from this alias
... ...
LL | type _T03 = dyn Obj + _1; LL | type _T03 = dyn Obj + _1;
| --- ^^ trait alias used in trait object type (additional use) | --- ^^ second non-auto trait comes from this alias
| | | |
| first non-auto trait | first non-auto trait
| |
@ -73,17 +73,17 @@ LL | type _T03 = dyn Obj + _1;
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits> = note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object error[E0225]: only auto traits can be used as additional traits in a trait object
--> $DIR/no-duplicates.rs:28:22 --> $DIR/no-duplicates.rs:28:17
| |
LL | trait _0 = Obj; LL | trait _0 = Obj;
| --- first non-auto trait | --- additional non-auto trait
LL | trait _1 = _0; LL | trait _1 = _0;
| -- referenced here (first use) | -- second non-auto trait comes from this alias
... ...
LL | type _T04 = dyn _1 + Obj; LL | type _T04 = dyn _1 + Obj;
| -- ^^^ additional non-auto trait | ^^ --- first non-auto trait
| | | |
| trait alias used in trait object type (first use) | second non-auto trait comes from this alias
| |
= help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj {}` = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits> = note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
@ -92,23 +92,17 @@ error[E0225]: only auto traits can be used as additional traits in a trait objec
--> $DIR/no-duplicates.rs:37:17 --> $DIR/no-duplicates.rs:37:17
| |
LL | trait _0 = Obj; LL | trait _0 = Obj;
| --- | --- additional non-auto trait
| |
| additional non-auto trait
| first non-auto trait
LL | trait _1 = _0;
| -- referenced here (additional use)
... ...
LL | trait _2 = _0 + _1; LL | trait _2 = _0 + _1;
| -- -- referenced here (additional use) | -- second non-auto trait comes from this alias
| | LL | trait _3 = Obj;
| referenced here (first use) | --- first non-auto trait
... ...
LL | type _T10 = dyn _2 + _3; LL | type _T10 = dyn _2 + _3;
| ^^ | ^^ -- first non-auto trait comes from this alias
| | | |
| trait alias used in trait object type (additional use) | second non-auto trait comes from this alias
| trait alias used in trait object type (first use)
| |
= help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj + Obj {}` = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj + Obj {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits> = note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
@ -120,14 +114,14 @@ LL | trait _0 = Obj;
| --- additional non-auto trait | --- additional non-auto trait
... ...
LL | trait _2 = _0 + _1; LL | trait _2 = _0 + _1;
| -- referenced here (additional use) | -- second non-auto trait comes from this alias
LL | trait _3 = Obj; LL | trait _3 = Obj;
| --- first non-auto trait | --- first non-auto trait
... ...
LL | type _T11 = dyn _3 + _2; LL | type _T11 = dyn _3 + _2;
| -- ^^ trait alias used in trait object type (additional use) | -- ^^ second non-auto trait comes from this alias
| | | |
| trait alias used in trait object type (first use) | first non-auto trait comes from this alias
| |
= help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj + Obj {}` = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj + Obj {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits> = note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
@ -139,10 +133,10 @@ LL | trait _0 = Obj;
| --- additional non-auto trait | --- additional non-auto trait
... ...
LL | trait _2 = _0 + _1; LL | trait _2 = _0 + _1;
| -- referenced here (additional use) | -- second non-auto trait comes from this alias
... ...
LL | type _T12 = dyn Obj + _2; LL | type _T12 = dyn Obj + _2;
| --- ^^ trait alias used in trait object type (additional use) | --- ^^ second non-auto trait comes from this alias
| | | |
| first non-auto trait | first non-auto trait
| |
@ -153,42 +147,34 @@ error[E0225]: only auto traits can be used as additional traits in a trait objec
--> $DIR/no-duplicates.rs:46:17 --> $DIR/no-duplicates.rs:46:17
| |
LL | trait _0 = Obj; LL | trait _0 = Obj;
| --- | --- additional non-auto trait
| |
| additional non-auto trait
| first non-auto trait
LL | trait _1 = _0;
| -- referenced here (additional use)
... ...
LL | trait _2 = _0 + _1; LL | trait _2 = _0 + _1;
| -- -- referenced here (additional use) | -- second non-auto trait comes from this alias
| |
| referenced here (first use)
... ...
LL | type _T13 = dyn _2 + Obj; LL | type _T13 = dyn _2 + Obj;
| ^^ | ^^ --- first non-auto trait
| | | |
| trait alias used in trait object type (additional use) | second non-auto trait comes from this alias
| trait alias used in trait object type (first use)
| |
= help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj + Obj {}` = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj + Obj {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits> = note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object error[E0225]: only auto traits can be used as additional traits in a trait object
--> $DIR/no-duplicates.rs:49:22 --> $DIR/no-duplicates.rs:49:17
| |
LL | trait _0 = Obj; LL | trait _0 = Obj;
| --- first non-auto trait | --- additional non-auto trait
LL | trait _1 = _0; LL | trait _1 = _0;
| -- referenced here (first use) | -- second non-auto trait comes from this alias
... ...
LL | trait _3 = Obj; LL | trait _3 = Obj;
| --- additional non-auto trait | --- first non-auto trait
... ...
LL | type _T14 = dyn _1 + _3; LL | type _T14 = dyn _1 + _3;
| -- ^^ trait alias used in trait object type (additional use) | ^^ -- first non-auto trait comes from this alias
| | | |
| trait alias used in trait object type (first use) | second non-auto trait comes from this alias
| |
= help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj {}` = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits> = note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
@ -199,15 +185,15 @@ error[E0225]: only auto traits can be used as additional traits in a trait objec
LL | trait _0 = Obj; LL | trait _0 = Obj;
| --- additional non-auto trait | --- additional non-auto trait
LL | trait _1 = _0; LL | trait _1 = _0;
| -- referenced here (additional use) | -- second non-auto trait comes from this alias
... ...
LL | trait _3 = Obj; LL | trait _3 = Obj;
| --- first non-auto trait | --- first non-auto trait
... ...
LL | type _T15 = dyn _3 + _1; LL | type _T15 = dyn _3 + _1;
| -- ^^ trait alias used in trait object type (additional use) | -- ^^ second non-auto trait comes from this alias
| | | |
| trait alias used in trait object type (first use) | first non-auto trait comes from this alias
| |
= help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj {}` = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits> = note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
@ -218,17 +204,17 @@ error[E0225]: only auto traits can be used as additional traits in a trait objec
LL | trait _0 = Obj; LL | trait _0 = Obj;
| --- first non-auto trait | --- first non-auto trait
LL | trait _1 = _0; LL | trait _1 = _0;
| -- referenced here (first use) | -- first non-auto trait comes from this alias
... ...
LL | trait _3 = Obj; LL | trait _3 = Obj;
| --- additional non-auto trait | --- additional non-auto trait
LL | trait _4 = _3; LL | trait _4 = _3;
| -- referenced here (additional use) | -- second non-auto trait comes from this alias
... ...
LL | type _T16 = dyn _1 + _4; LL | type _T16 = dyn _1 + _4;
| -- ^^ trait alias used in trait object type (additional use) | -- ^^ second non-auto trait comes from this alias
| | | |
| trait alias used in trait object type (first use) | first non-auto trait comes from this alias
| |
= help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj {}` = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits> = note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
@ -239,17 +225,17 @@ error[E0225]: only auto traits can be used as additional traits in a trait objec
LL | trait _0 = Obj; LL | trait _0 = Obj;
| --- additional non-auto trait | --- additional non-auto trait
LL | trait _1 = _0; LL | trait _1 = _0;
| -- referenced here (additional use) | -- second non-auto trait comes from this alias
... ...
LL | trait _3 = Obj; LL | trait _3 = Obj;
| --- first non-auto trait | --- first non-auto trait
LL | trait _4 = _3; LL | trait _4 = _3;
| -- referenced here (first use) | -- first non-auto trait comes from this alias
... ...
LL | type _T17 = dyn _4 + _1; LL | type _T17 = dyn _4 + _1;
| -- ^^ trait alias used in trait object type (additional use) | -- ^^ second non-auto trait comes from this alias
| | | |
| trait alias used in trait object type (first use) | first non-auto trait comes from this alias
| |
= help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj {}` = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits> = note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
@ -260,13 +246,13 @@ error[E0225]: only auto traits can be used as additional traits in a trait objec
LL | trait _5 = Obj + Send; LL | trait _5 = Obj + Send;
| --- | ---
| | | |
| additional non-auto trait
| first non-auto trait | first non-auto trait
| additional non-auto trait
LL | LL |
LL | type _T20 = dyn _5 + _5; LL | type _T20 = dyn _5 + _5;
| -- ^^ trait alias used in trait object type (additional use) | -- ^^ second non-auto trait comes from this alias
| | | |
| trait alias used in trait object type (first use) | first non-auto trait comes from this alias
| |
= help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj {}` = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits> = note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
@ -278,7 +264,7 @@ LL | trait _5 = Obj + Send;
| --- additional non-auto trait | --- additional non-auto trait
... ...
LL | type _T21 = dyn Obj + _5; LL | type _T21 = dyn Obj + _5;
| --- ^^ trait alias used in trait object type (additional use) | --- ^^ second non-auto trait comes from this alias
| | | |
| first non-auto trait | first non-auto trait
| |
@ -286,29 +272,29 @@ LL | type _T21 = dyn Obj + _5;
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits> = note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object error[E0225]: only auto traits can be used as additional traits in a trait object
--> $DIR/no-duplicates.rs:71:22 --> $DIR/no-duplicates.rs:71:17
| |
LL | trait _5 = Obj + Send; LL | trait _5 = Obj + Send;
| --- first non-auto trait | --- additional non-auto trait
... ...
LL | type _T22 = dyn _5 + Obj; LL | type _T22 = dyn _5 + Obj;
| -- ^^^ additional non-auto trait | ^^ --- first non-auto trait
| | | |
| trait alias used in trait object type (first use) | second non-auto trait comes from this alias
| |
= help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj {}` = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits> = note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object error[E0225]: only auto traits can be used as additional traits in a trait object
--> $DIR/no-duplicates.rs:74:36 --> $DIR/no-duplicates.rs:74:17
| |
LL | trait _5 = Obj + Send; LL | trait _5 = Obj + Send;
| --- first non-auto trait | --- additional non-auto trait
... ...
LL | type _T23 = dyn _5 + Send + Sync + Obj; LL | type _T23 = dyn _5 + Send + Sync + Obj;
| -- ^^^ additional non-auto trait | ^^ --- first non-auto trait
| | | |
| trait alias used in trait object type (first use) | second non-auto trait comes from this alias
| |
= help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj {}` = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits> = note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
@ -319,19 +305,19 @@ error[E0225]: only auto traits can be used as additional traits in a trait objec
LL | trait _5 = Obj + Send; LL | trait _5 = Obj + Send;
| --- | ---
| | | |
| additional non-auto trait
| first non-auto trait | first non-auto trait
| additional non-auto trait
... ...
LL | trait _6 = _5 + _5; // ==> Obj + Send + Obj + Send LL | trait _6 = _5 + _5; // ==> Obj + Send + Obj + Send
| -- -- referenced here (additional use) | -- -- second non-auto trait comes from this alias
| | | |
| referenced here (first use) | first non-auto trait comes from this alias
LL | LL |
LL | type _T30 = dyn _6; LL | type _T30 = dyn _6;
| ^^ | ^^
| | | |
| trait alias used in trait object type (additional use) | first non-auto trait comes from this alias
| trait alias used in trait object type (first use) | second non-auto trait comes from this alias
| |
= help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj {}` = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits> = note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
@ -342,19 +328,19 @@ error[E0225]: only auto traits can be used as additional traits in a trait objec
LL | trait _5 = Obj + Send; LL | trait _5 = Obj + Send;
| --- | ---
| | | |
| additional non-auto trait
| first non-auto trait | first non-auto trait
| additional non-auto trait
... ...
LL | trait _6 = _5 + _5; // ==> Obj + Send + Obj + Send LL | trait _6 = _5 + _5; // ==> Obj + Send + Obj + Send
| -- -- referenced here (additional use) | -- -- second non-auto trait comes from this alias
| | | |
| referenced here (first use) | first non-auto trait comes from this alias
... ...
LL | type _T31 = dyn _6 + Send; LL | type _T31 = dyn _6 + Send;
| ^^ | ^^
| | | |
| trait alias used in trait object type (additional use) | first non-auto trait comes from this alias
| trait alias used in trait object type (first use) | second non-auto trait comes from this alias
| |
= help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj {}` = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits> = note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
@ -365,38 +351,38 @@ error[E0225]: only auto traits can be used as additional traits in a trait objec
LL | trait _5 = Obj + Send; LL | trait _5 = Obj + Send;
| --- | ---
| | | |
| additional non-auto trait
| first non-auto trait | first non-auto trait
| additional non-auto trait
... ...
LL | trait _6 = _5 + _5; // ==> Obj + Send + Obj + Send LL | trait _6 = _5 + _5; // ==> Obj + Send + Obj + Send
| -- -- referenced here (additional use) | -- -- second non-auto trait comes from this alias
| | | |
| referenced here (first use) | first non-auto trait comes from this alias
... ...
LL | type _T32 = dyn Send + _6; LL | type _T32 = dyn Send + _6;
| ^^ | ^^
| | | |
| trait alias used in trait object type (additional use) | first non-auto trait comes from this alias
| trait alias used in trait object type (first use) | second non-auto trait comes from this alias
| |
= help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj {}` = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits> = note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object error[E0225]: only auto traits can be used as additional traits in a trait object
--> $DIR/no-duplicates.rs:95:22 --> $DIR/no-duplicates.rs:95:17
| |
LL | trait _5 = Obj + Send; LL | trait _5 = Obj + Send;
| --- first non-auto trait | --- additional non-auto trait
... ...
LL | trait _7 = _5 + Sync; LL | trait _7 = _5 + Sync;
| -- referenced here (first use) | -- second non-auto trait comes from this alias
LL | trait _8 = Unpin + _7; LL | trait _8 = Unpin + _7;
| -- referenced here (first use) | -- second non-auto trait comes from this alias
LL | LL |
LL | type _T40 = dyn _8 + Obj; LL | type _T40 = dyn _8 + Obj;
| -- ^^^ additional non-auto trait | ^^ --- first non-auto trait
| | | |
| trait alias used in trait object type (first use) | second non-auto trait comes from this alias
| |
= help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj {}` = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits> = note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
@ -408,12 +394,12 @@ LL | trait _5 = Obj + Send;
| --- additional non-auto trait | --- additional non-auto trait
... ...
LL | trait _7 = _5 + Sync; LL | trait _7 = _5 + Sync;
| -- referenced here (additional use) | -- second non-auto trait comes from this alias
LL | trait _8 = Unpin + _7; LL | trait _8 = Unpin + _7;
| -- referenced here (additional use) | -- second non-auto trait comes from this alias
... ...
LL | type _T41 = dyn Obj + _8; LL | type _T41 = dyn Obj + _8;
| --- ^^ trait alias used in trait object type (additional use) | --- ^^ second non-auto trait comes from this alias
| | | |
| first non-auto trait | first non-auto trait
| |
@ -421,25 +407,25 @@ LL | type _T41 = dyn Obj + _8;
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits> = note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object error[E0225]: only auto traits can be used as additional traits in a trait object
--> $DIR/no-duplicates.rs:101:22 --> $DIR/no-duplicates.rs:101:17
| |
LL | trait _3 = Obj; LL | trait _3 = Obj;
| --- additional non-auto trait | --- first non-auto trait
LL | trait _4 = _3; LL | trait _4 = _3;
| -- referenced here (additional use) | -- first non-auto trait comes from this alias
... ...
LL | trait _5 = Obj + Send; LL | trait _5 = Obj + Send;
| --- first non-auto trait | --- additional non-auto trait
... ...
LL | trait _7 = _5 + Sync; LL | trait _7 = _5 + Sync;
| -- referenced here (first use) | -- second non-auto trait comes from this alias
LL | trait _8 = Unpin + _7; LL | trait _8 = Unpin + _7;
| -- referenced here (first use) | -- second non-auto trait comes from this alias
... ...
LL | type _T42 = dyn _8 + _4; LL | type _T42 = dyn _8 + _4;
| -- ^^ trait alias used in trait object type (additional use) | ^^ -- first non-auto trait comes from this alias
| | | |
| trait alias used in trait object type (first use) | second non-auto trait comes from this alias
| |
= help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj {}` = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits> = note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
@ -450,20 +436,20 @@ error[E0225]: only auto traits can be used as additional traits in a trait objec
LL | trait _3 = Obj; LL | trait _3 = Obj;
| --- first non-auto trait | --- first non-auto trait
LL | trait _4 = _3; LL | trait _4 = _3;
| -- referenced here (first use) | -- first non-auto trait comes from this alias
... ...
LL | trait _5 = Obj + Send; LL | trait _5 = Obj + Send;
| --- additional non-auto trait | --- additional non-auto trait
... ...
LL | trait _7 = _5 + Sync; LL | trait _7 = _5 + Sync;
| -- referenced here (additional use) | -- second non-auto trait comes from this alias
LL | trait _8 = Unpin + _7; LL | trait _8 = Unpin + _7;
| -- referenced here (additional use) | -- second non-auto trait comes from this alias
... ...
LL | type _T43 = dyn _4 + _8; LL | type _T43 = dyn _4 + _8;
| -- ^^ trait alias used in trait object type (additional use) | -- ^^ second non-auto trait comes from this alias
| | | |
| trait alias used in trait object type (first use) | first non-auto trait comes from this alias
| |
= help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj {}` = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits> = note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
@ -474,20 +460,20 @@ error[E0225]: only auto traits can be used as additional traits in a trait objec
LL | trait _3 = Obj; LL | trait _3 = Obj;
| --- first non-auto trait | --- first non-auto trait
LL | trait _4 = _3; LL | trait _4 = _3;
| -- referenced here (first use) | -- first non-auto trait comes from this alias
... ...
LL | trait _5 = Obj + Send; LL | trait _5 = Obj + Send;
| --- additional non-auto trait | --- additional non-auto trait
... ...
LL | trait _7 = _5 + Sync; LL | trait _7 = _5 + Sync;
| -- referenced here (additional use) | -- second non-auto trait comes from this alias
LL | trait _8 = Unpin + _7; LL | trait _8 = Unpin + _7;
| -- referenced here (additional use) | -- second non-auto trait comes from this alias
... ...
LL | type _T44 = dyn _4 + Send + Sync + _8; LL | type _T44 = dyn _4 + Send + Sync + _8;
| -- ^^ trait alias used in trait object type (additional use) | -- ^^ second non-auto trait comes from this alias
| | | |
| trait alias used in trait object type (first use) | first non-auto trait comes from this alias
| |
= help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj {}` = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Obj + Obj {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits> = note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
@ -500,9 +486,9 @@ LL | trait _9 = for<'a> ObjL<'a>;
LL | trait _10 = for<'b> ObjL<'b>; LL | trait _10 = for<'b> ObjL<'b>;
| ---------------- additional non-auto trait | ---------------- additional non-auto trait
LL | type _T50 = dyn _9 + _10; LL | type _T50 = dyn _9 + _10;
| -- ^^^ trait alias used in trait object type (additional use) | -- ^^^ second non-auto trait comes from this alias
| | | |
| trait alias used in trait object type (first use) | first non-auto trait comes from this alias
| |
= help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: for<'a> ObjL<'a> + for<'b> ObjL<'b> {}` = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: for<'a> ObjL<'a> + for<'b> ObjL<'b> {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits> = note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
@ -515,9 +501,9 @@ LL | trait _11 = ObjT<for<'a> fn(&'a u8)>;
LL | trait _12 = ObjT<for<'b> fn(&'b u8)>; LL | trait _12 = ObjT<for<'b> fn(&'b u8)>;
| ------------------------ additional non-auto trait | ------------------------ additional non-auto trait
LL | type _T60 = dyn _11 + _12; LL | type _T60 = dyn _11 + _12;
| --- ^^^ trait alias used in trait object type (additional use) | --- ^^^ second non-auto trait comes from this alias
| | | |
| trait alias used in trait object type (first use) | first non-auto trait comes from this alias
| |
= help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjT<for<'a> fn(&'a u8)> + ObjT<for<'b> fn(&'b u8)> {}` = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjT<for<'a> fn(&'a u8)> + ObjT<for<'b> fn(&'b u8)> {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits> = note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>

362
tests/ui/traits/alias/no-extra-traits.stderr
View file

@ -1,15 +1,15 @@
error[E0225]: only auto traits can be used as additional traits in a trait object error[E0225]: only auto traits can be used as additional traits in a trait object
--> $DIR/no-extra-traits.rs:16:22 --> $DIR/no-extra-traits.rs:16:17
| |
LL | trait _0 = ObjA; LL | trait _0 = ObjA;
| ---- first non-auto trait | ---- additional non-auto trait
... ...
LL | type _T00 = dyn _0 + ObjB; LL | type _T00 = dyn _0 + ObjB;
| -- ^^^^ additional non-auto trait | ^^ ---- first non-auto trait
| | | |
| trait alias used in trait object type (first use) | second non-auto trait comes from this alias
| |
= help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjA + ObjB {}` = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjB + ObjA {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits> = note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object error[E0225]: only auto traits can be used as additional traits in a trait object
@ -19,7 +19,7 @@ LL | trait _0 = ObjA;
| ---- additional non-auto trait | ---- additional non-auto trait
... ...
LL | type _T01 = dyn ObjB + _0; LL | type _T01 = dyn ObjB + _0;
| ---- ^^ trait alias used in trait object type (additional use) | ---- ^^ second non-auto trait comes from this alias
| | | |
| first non-auto trait | first non-auto trait
| |
@ -32,10 +32,10 @@ error[E0225]: only auto traits can be used as additional traits in a trait objec
LL | trait _0 = ObjA; LL | trait _0 = ObjA;
| ---- additional non-auto trait | ---- additional non-auto trait
LL | trait _1 = _0; LL | trait _1 = _0;
| -- referenced here (additional use) | -- second non-auto trait comes from this alias
... ...
LL | type _T02 = dyn ObjB + _1; LL | type _T02 = dyn ObjB + _1;
| ---- ^^ trait alias used in trait object type (additional use) | ---- ^^ second non-auto trait comes from this alias
| | | |
| first non-auto trait | first non-auto trait
| |
@ -43,19 +43,19 @@ LL | type _T02 = dyn ObjB + _1;
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits> = note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object error[E0225]: only auto traits can be used as additional traits in a trait object
--> $DIR/no-extra-traits.rs:25:22 --> $DIR/no-extra-traits.rs:25:17
| |
LL | trait _0 = ObjA; LL | trait _0 = ObjA;
| ---- first non-auto trait | ---- additional non-auto trait
LL | trait _1 = _0; LL | trait _1 = _0;
| -- referenced here (first use) | -- second non-auto trait comes from this alias
... ...
LL | type _T03 = dyn _1 + ObjB; LL | type _T03 = dyn _1 + ObjB;
| -- ^^^^ additional non-auto trait | ^^ ---- first non-auto trait
| | | |
| trait alias used in trait object type (first use) | second non-auto trait comes from this alias
| |
= help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjA + ObjB {}` = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjB + ObjA {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits> = note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object error[E0225]: only auto traits can be used as additional traits in a trait object
@ -64,34 +64,34 @@ error[E0225]: only auto traits can be used as additional traits in a trait objec
LL | trait _2 = ObjB; LL | trait _2 = ObjB;
| ---- | ----
| | | |
| additional non-auto trait
| first non-auto trait | first non-auto trait
| additional non-auto trait
LL | trait _3 = _2; LL | trait _3 = _2;
| -- referenced here (additional use) | -- second non-auto trait comes from this alias
... ...
LL | type _T10 = dyn _2 + _3; LL | type _T10 = dyn _2 + _3;
| -- ^^ trait alias used in trait object type (additional use) | -- ^^ second non-auto trait comes from this alias
| | | |
| trait alias used in trait object type (first use) | first non-auto trait comes from this alias
| |
= help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjB + ObjB {}` = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjB + ObjB {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits> = note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object error[E0225]: only auto traits can be used as additional traits in a trait object
--> $DIR/no-extra-traits.rs:37:22 --> $DIR/no-extra-traits.rs:37:17
| |
LL | trait _2 = ObjB; LL | trait _2 = ObjB;
| ---- | ----
| | | |
| additional non-auto trait
| first non-auto trait | first non-auto trait
| additional non-auto trait
LL | trait _3 = _2; LL | trait _3 = _2;
| -- referenced here (first use) | -- second non-auto trait comes from this alias
... ...
LL | type _T11 = dyn _3 + _2; LL | type _T11 = dyn _3 + _2;
| -- ^^ trait alias used in trait object type (additional use) | ^^ -- first non-auto trait comes from this alias
| | | |
| trait alias used in trait object type (first use) | second non-auto trait comes from this alias
| |
= help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjB + ObjB {}` = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjB + ObjB {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits> = note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
@ -102,38 +102,38 @@ error[E0225]: only auto traits can be used as additional traits in a trait objec
LL | trait _2 = ObjB; LL | trait _2 = ObjB;
| ---- | ----
| | | |
| additional non-auto trait
| first non-auto trait | first non-auto trait
| additional non-auto trait
LL | trait _3 = _2; LL | trait _3 = _2;
| -- referenced here (additional use) | -- second non-auto trait comes from this alias
LL | trait _4 = _3; LL | trait _4 = _3;
| -- referenced here (additional use) | -- second non-auto trait comes from this alias
... ...
LL | type _T12 = dyn _2 + _4; LL | type _T12 = dyn _2 + _4;
| -- ^^ trait alias used in trait object type (additional use) | -- ^^ second non-auto trait comes from this alias
| | | |
| trait alias used in trait object type (first use) | first non-auto trait comes from this alias
| |
= help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjB + ObjB {}` = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjB + ObjB {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits> = note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object error[E0225]: only auto traits can be used as additional traits in a trait object
--> $DIR/no-extra-traits.rs:43:22 --> $DIR/no-extra-traits.rs:43:17
| |
LL | trait _2 = ObjB; LL | trait _2 = ObjB;
| ---- | ----
| | | |
| additional non-auto trait
| first non-auto trait | first non-auto trait
| additional non-auto trait
LL | trait _3 = _2; LL | trait _3 = _2;
| -- referenced here (first use) | -- second non-auto trait comes from this alias
LL | trait _4 = _3; LL | trait _4 = _3;
| -- referenced here (first use) | -- second non-auto trait comes from this alias
... ...
LL | type _T13 = dyn _4 + _2; LL | type _T13 = dyn _4 + _2;
| -- ^^ trait alias used in trait object type (additional use) | ^^ -- first non-auto trait comes from this alias
| | | |
| trait alias used in trait object type (first use) | second non-auto trait comes from this alias
| |
= help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjB + ObjB {}` = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjB + ObjB {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits> = note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
@ -144,52 +144,52 @@ error[E0225]: only auto traits can be used as additional traits in a trait objec
LL | trait _0 = ObjA; LL | trait _0 = ObjA;
| ---- additional non-auto trait | ---- additional non-auto trait
LL | trait _1 = _0; LL | trait _1 = _0;
| -- referenced here (additional use) | -- second non-auto trait comes from this alias
... ...
LL | trait _5 = Sync + ObjB + Send; LL | trait _5 = Sync + ObjB + Send;
| ---- first non-auto trait | ---- first non-auto trait
LL | LL |
LL | type _T20 = dyn _5 + _1; LL | type _T20 = dyn _5 + _1;
| -- ^^ trait alias used in trait object type (additional use) | -- ^^ second non-auto trait comes from this alias
| | | |
| trait alias used in trait object type (first use) | first non-auto trait comes from this alias
| |
= help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjB + ObjA {}` = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjB + ObjA {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits> = note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object error[E0225]: only auto traits can be used as additional traits in a trait object
--> $DIR/no-extra-traits.rs:53:22 --> $DIR/no-extra-traits.rs:53:17
| |
LL | trait _0 = ObjA; LL | trait _0 = ObjA;
| ---- first non-auto trait | ---- additional non-auto trait
LL | trait _1 = _0; LL | trait _1 = _0;
| -- referenced here (first use) | -- second non-auto trait comes from this alias
... ...
LL | trait _5 = Sync + ObjB + Send;
| ---- additional non-auto trait
...
LL | type _T21 = dyn _1 + _5;
| -- ^^ trait alias used in trait object type (additional use)
| |
| trait alias used in trait object type (first use)
|
= help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjA + ObjB {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
--> $DIR/no-extra-traits.rs:56:22
|
LL | trait _5 = Sync + ObjB + Send; LL | trait _5 = Sync + ObjB + Send;
| ---- first non-auto trait | ---- first non-auto trait
... ...
LL | type _T22 = dyn _5 + ObjA; LL | type _T21 = dyn _1 + _5;
| -- ^^^^ additional non-auto trait | ^^ -- first non-auto trait comes from this alias
| | | |
| trait alias used in trait object type (first use) | second non-auto trait comes from this alias
| |
= help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjB + ObjA {}` = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjB + ObjA {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits> = note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
--> $DIR/no-extra-traits.rs:56:17
|
LL | trait _5 = Sync + ObjB + Send;
| ---- additional non-auto trait
...
LL | type _T22 = dyn _5 + ObjA;
| ^^ ---- first non-auto trait
| |
| second non-auto trait comes from this alias
|
= help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjA + ObjB {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object error[E0225]: only auto traits can be used as additional traits in a trait object
--> $DIR/no-extra-traits.rs:59:24 --> $DIR/no-extra-traits.rs:59:24
| |
@ -197,7 +197,7 @@ LL | trait _5 = Sync + ObjB + Send;
| ---- additional non-auto trait | ---- additional non-auto trait
... ...
LL | type _T23 = dyn ObjA + _5; LL | type _T23 = dyn ObjA + _5;
| ---- ^^ trait alias used in trait object type (additional use) | ---- ^^ second non-auto trait comes from this alias
| | | |
| first non-auto trait | first non-auto trait
| |
@ -210,52 +210,52 @@ error[E0225]: only auto traits can be used as additional traits in a trait objec
LL | trait _0 = ObjA; LL | trait _0 = ObjA;
| ---- additional non-auto trait | ---- additional non-auto trait
LL | trait _1 = _0; LL | trait _1 = _0;
| -- referenced here (additional use) | -- second non-auto trait comes from this alias
... ...
LL | trait _5 = Sync + ObjB + Send; LL | trait _5 = Sync + ObjB + Send;
| ---- first non-auto trait | ---- first non-auto trait
... ...
LL | type _T24 = dyn Send + _5 + _1 + Sync; LL | type _T24 = dyn Send + _5 + _1 + Sync;
| -- ^^ trait alias used in trait object type (additional use) | -- ^^ second non-auto trait comes from this alias
| | | |
| trait alias used in trait object type (first use) | first non-auto trait comes from this alias
| |
= help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjB + ObjA {}` = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjB + ObjA {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits> = note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object error[E0225]: only auto traits can be used as additional traits in a trait object
--> $DIR/no-extra-traits.rs:65:29 --> $DIR/no-extra-traits.rs:65:17
| |
LL | trait _0 = ObjA; LL | trait _0 = ObjA;
| ---- first non-auto trait | ---- additional non-auto trait
LL | trait _1 = _0; LL | trait _1 = _0;
| -- referenced here (first use) | -- second non-auto trait comes from this alias
... ...
LL | trait _5 = Sync + ObjB + Send;
| ---- additional non-auto trait
...
LL | type _T25 = dyn _1 + Sync + _5 + Send;
| -- ^^ trait alias used in trait object type (additional use)
| |
| trait alias used in trait object type (first use)
|
= help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjA + ObjB {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
--> $DIR/no-extra-traits.rs:68:36
|
LL | trait _5 = Sync + ObjB + Send; LL | trait _5 = Sync + ObjB + Send;
| ---- first non-auto trait | ---- first non-auto trait
... ...
LL | type _T26 = dyn Sync + Send + _5 + ObjA; LL | type _T25 = dyn _1 + Sync + _5 + Send;
| -- ^^^^ additional non-auto trait | ^^ -- first non-auto trait comes from this alias
| | | |
| trait alias used in trait object type (first use) | second non-auto trait comes from this alias
| |
= help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjB + ObjA {}` = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjB + ObjA {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits> = note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object
--> $DIR/no-extra-traits.rs:68:31
|
LL | trait _5 = Sync + ObjB + Send;
| ---- additional non-auto trait
...
LL | type _T26 = dyn Sync + Send + _5 + ObjA;
| ^^ ---- first non-auto trait
| |
| second non-auto trait comes from this alias
|
= help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjA + ObjB {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object error[E0225]: only auto traits can be used as additional traits in a trait object
--> $DIR/no-extra-traits.rs:71:38 --> $DIR/no-extra-traits.rs:71:38
| |
@ -263,7 +263,7 @@ LL | trait _5 = Sync + ObjB + Send;
| ---- additional non-auto trait | ---- additional non-auto trait
... ...
LL | type _T27 = dyn Send + Sync + ObjA + _5; LL | type _T27 = dyn Send + Sync + ObjA + _5;
| ---- ^^ trait alias used in trait object type (additional use) | ---- ^^ second non-auto trait comes from this alias
| | | |
| first non-auto trait | first non-auto trait
| |
@ -274,199 +274,199 @@ error[E0225]: only auto traits can be used as additional traits in a trait objec
--> $DIR/no-extra-traits.rs:80:17 --> $DIR/no-extra-traits.rs:80:17
| |
LL | trait _0 = ObjA; LL | trait _0 = ObjA;
| ---- first non-auto trait | ---- additional non-auto trait
LL | trait _1 = _0; LL | trait _1 = _0;
| -- referenced here (first use) | -- second non-auto trait comes from this alias
... ...
LL | trait _5 = Sync + ObjB + Send; LL | trait _5 = Sync + ObjB + Send;
| ---- additional non-auto trait | ---- first non-auto trait
... ...
LL | trait _6 = _1 + _5; LL | trait _6 = _1 + _5;
| -- -- referenced here (additional use) | -- -- first non-auto trait comes from this alias
| | | |
| referenced here (first use) | second non-auto trait comes from this alias
... ...
LL | type _T30 = dyn _6; LL | type _T30 = dyn _6;
| ^^ | ^^
| | | |
| trait alias used in trait object type (additional use) | first non-auto trait comes from this alias
| trait alias used in trait object type (first use) | second non-auto trait comes from this alias
| |
= help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjA + ObjB {}` = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjB + ObjA {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits> = note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object error[E0225]: only auto traits can be used as additional traits in a trait object
--> $DIR/no-extra-traits.rs:83:17 --> $DIR/no-extra-traits.rs:83:17
| |
LL | trait _0 = ObjA; LL | trait _0 = ObjA;
| ---- first non-auto trait | ---- additional non-auto trait
LL | trait _1 = _0; LL | trait _1 = _0;
| -- referenced here (first use) | -- second non-auto trait comes from this alias
... ...
LL | trait _5 = Sync + ObjB + Send; LL | trait _5 = Sync + ObjB + Send;
| ---- additional non-auto trait | ---- first non-auto trait
... ...
LL | trait _6 = _1 + _5; LL | trait _6 = _1 + _5;
| -- -- referenced here (additional use) | -- -- first non-auto trait comes from this alias
| | | |
| referenced here (first use) | second non-auto trait comes from this alias
... ...
LL | type _T31 = dyn _6 + Send; LL | type _T31 = dyn _6 + Send;
| ^^ | ^^
| | | |
| trait alias used in trait object type (additional use) | first non-auto trait comes from this alias
| trait alias used in trait object type (first use) | second non-auto trait comes from this alias
| |
= help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjA + ObjB {}` = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjB + ObjA {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits> = note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object error[E0225]: only auto traits can be used as additional traits in a trait object
--> $DIR/no-extra-traits.rs:86:24 --> $DIR/no-extra-traits.rs:86:24
| |
LL | trait _0 = ObjA; LL | trait _0 = ObjA;
| ---- first non-auto trait | ---- additional non-auto trait
LL | trait _1 = _0; LL | trait _1 = _0;
| -- referenced here (first use) | -- second non-auto trait comes from this alias
... ...
LL | trait _5 = Sync + ObjB + Send; LL | trait _5 = Sync + ObjB + Send;
| ---- additional non-auto trait | ---- first non-auto trait
... ...
LL | trait _6 = _1 + _5; LL | trait _6 = _1 + _5;
| -- -- referenced here (additional use) | -- -- first non-auto trait comes from this alias
| | | |
| referenced here (first use) | second non-auto trait comes from this alias
... ...
LL | type _T32 = dyn Send + _6; LL | type _T32 = dyn Send + _6;
| ^^ | ^^
| | | |
| trait alias used in trait object type (additional use) | first non-auto trait comes from this alias
| trait alias used in trait object type (first use) | second non-auto trait comes from this alias
| |
= help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjA + ObjB {}` = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjB + ObjA {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits> = note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object error[E0225]: only auto traits can be used as additional traits in a trait object
--> $DIR/no-extra-traits.rs:89:17 --> $DIR/no-extra-traits.rs:89:17
| |
LL | trait _0 = ObjA; LL | trait _0 = ObjA;
| ---- first non-auto trait | ---- additional non-auto trait
LL | trait _1 = _0; LL | trait _1 = _0;
| -- referenced here (first use) | -- second non-auto trait comes from this alias
... ...
LL | trait _5 = Sync + ObjB + Send; LL | trait _5 = Sync + ObjB + Send;
| ---- additional non-auto trait | ---- first non-auto trait
... ...
LL | trait _6 = _1 + _5; LL | trait _6 = _1 + _5;
| -- -- referenced here (additional use) | -- -- first non-auto trait comes from this alias
| | | |
| referenced here (first use) | second non-auto trait comes from this alias
LL | trait _7 = _6; LL | trait _7 = _6;
| -- | --
| | | |
| referenced here (additional use) | first non-auto trait comes from this alias
| referenced here (first use) | second non-auto trait comes from this alias
LL | trait _8 = _7; LL | trait _8 = _7;
| -- | --
| | | |
| referenced here (additional use) | first non-auto trait comes from this alias
| referenced here (first use) | second non-auto trait comes from this alias
... ...
LL | type _T33 = dyn _8; LL | type _T33 = dyn _8;
| ^^ | ^^
| | | |
| trait alias used in trait object type (additional use) | first non-auto trait comes from this alias
| trait alias used in trait object type (first use) | second non-auto trait comes from this alias
| |
= help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjA + ObjB {}` = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjB + ObjA {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits> = note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object error[E0225]: only auto traits can be used as additional traits in a trait object
--> $DIR/no-extra-traits.rs:92:17 --> $DIR/no-extra-traits.rs:92:17
| |
LL | trait _0 = ObjA; LL | trait _0 = ObjA;
| ---- first non-auto trait | ---- additional non-auto trait
LL | trait _1 = _0; LL | trait _1 = _0;
| -- referenced here (first use) | -- second non-auto trait comes from this alias
... ...
LL | trait _5 = Sync + ObjB + Send; LL | trait _5 = Sync + ObjB + Send;
| ---- additional non-auto trait | ---- first non-auto trait
... ...
LL | trait _6 = _1 + _5; LL | trait _6 = _1 + _5;
| -- -- referenced here (additional use) | -- -- first non-auto trait comes from this alias
| | | |
| referenced here (first use) | second non-auto trait comes from this alias
LL | trait _7 = _6; LL | trait _7 = _6;
| -- | --
| | | |
| referenced here (additional use) | first non-auto trait comes from this alias
| referenced here (first use) | second non-auto trait comes from this alias
LL | trait _8 = _7; LL | trait _8 = _7;
| -- | --
| | | |
| referenced here (additional use) | first non-auto trait comes from this alias
| referenced here (first use) | second non-auto trait comes from this alias
... ...
LL | type _T34 = dyn _8 + Send; LL | type _T34 = dyn _8 + Send;
| ^^ | ^^
| | | |
| trait alias used in trait object type (additional use) | first non-auto trait comes from this alias
| trait alias used in trait object type (first use) | second non-auto trait comes from this alias
| |
= help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjA + ObjB {}` = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjB + ObjA {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits> = note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object error[E0225]: only auto traits can be used as additional traits in a trait object
--> $DIR/no-extra-traits.rs:95:24 --> $DIR/no-extra-traits.rs:95:24
| |
LL | trait _0 = ObjA; LL | trait _0 = ObjA;
| ---- first non-auto trait | ---- additional non-auto trait
LL | trait _1 = _0; LL | trait _1 = _0;
| -- referenced here (first use) | -- second non-auto trait comes from this alias
... ...
LL | trait _5 = Sync + ObjB + Send; LL | trait _5 = Sync + ObjB + Send;
| ---- additional non-auto trait | ---- first non-auto trait
... ...
LL | trait _6 = _1 + _5; LL | trait _6 = _1 + _5;
| -- -- referenced here (additional use) | -- -- first non-auto trait comes from this alias
| | | |
| referenced here (first use) | second non-auto trait comes from this alias
LL | trait _7 = _6; LL | trait _7 = _6;
| -- | --
| | | |
| referenced here (additional use) | first non-auto trait comes from this alias
| referenced here (first use) | second non-auto trait comes from this alias
LL | trait _8 = _7; LL | trait _8 = _7;
| -- | --
| | | |
| referenced here (additional use) | first non-auto trait comes from this alias
| referenced here (first use) | second non-auto trait comes from this alias
... ...
LL | type _T35 = dyn Send + _8; LL | type _T35 = dyn Send + _8;
| ^^ | ^^
| | | |
| trait alias used in trait object type (additional use) | first non-auto trait comes from this alias
| trait alias used in trait object type (first use) | second non-auto trait comes from this alias
| |
= help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjA + ObjB {}` = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjB + ObjA {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits> = note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object error[E0225]: only auto traits can be used as additional traits in a trait object
--> $DIR/no-extra-traits.rs:103:23 --> $DIR/no-extra-traits.rs:103:17
| |
LL | trait _5 = Sync + ObjB + Send; LL | trait _5 = Sync + ObjB + Send;
| ---- first non-auto trait | ---- additional non-auto trait
... ...
LL | trait _9 = _5 + Sync; LL | trait _9 = _5 + Sync;
| -- referenced here (first use) | -- second non-auto trait comes from this alias
LL | trait _10 = Unpin + _9; LL | trait _10 = Unpin + _9;
| -- referenced here (first use) | -- second non-auto trait comes from this alias
LL | LL |
LL | type _T40 = dyn _10 + ObjA; LL | type _T40 = dyn _10 + ObjA;
| --- ^^^^ additional non-auto trait | ^^^ ---- first non-auto trait
| | | |
| trait alias used in trait object type (first use) | second non-auto trait comes from this alias
| |
= help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjB + ObjA {}` = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjA + ObjB {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits> = note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object error[E0225]: only auto traits can be used as additional traits in a trait object
@ -476,12 +476,12 @@ LL | trait _5 = Sync + ObjB + Send;
| ---- additional non-auto trait | ---- additional non-auto trait
... ...
LL | trait _9 = _5 + Sync; LL | trait _9 = _5 + Sync;
| -- referenced here (additional use) | -- second non-auto trait comes from this alias
LL | trait _10 = Unpin + _9; LL | trait _10 = Unpin + _9;
| -- referenced here (additional use) | -- second non-auto trait comes from this alias
... ...
LL | type _T41 = dyn ObjA + _10; LL | type _T41 = dyn ObjA + _10;
| ---- ^^^ trait alias used in trait object type (additional use) | ---- ^^^ second non-auto trait comes from this alias
| | | |
| first non-auto trait | first non-auto trait
| |
@ -489,46 +489,46 @@ LL | type _T41 = dyn ObjA + _10;
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits> = note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object error[E0225]: only auto traits can be used as additional traits in a trait object
--> $DIR/no-extra-traits.rs:109:23 --> $DIR/no-extra-traits.rs:109:17
| |
LL | trait _0 = ObjA; LL | trait _0 = ObjA;
| ---- additional non-auto trait | ---- first non-auto trait
LL | trait _1 = _0; LL | trait _1 = _0;
| -- referenced here (additional use) | -- first non-auto trait comes from this alias
... ...
LL | trait _5 = Sync + ObjB + Send; LL | trait _5 = Sync + ObjB + Send;
| ---- first non-auto trait | ---- additional non-auto trait
... ...
LL | trait _9 = _5 + Sync; LL | trait _9 = _5 + Sync;
| -- referenced here (first use) | -- second non-auto trait comes from this alias
LL | trait _10 = Unpin + _9; LL | trait _10 = Unpin + _9;
| -- referenced here (first use) | -- second non-auto trait comes from this alias
... ...
LL | type _T42 = dyn _10 + _1; LL | type _T42 = dyn _10 + _1;
| --- ^^ trait alias used in trait object type (additional use) | ^^^ -- first non-auto trait comes from this alias
| | | |
| trait alias used in trait object type (first use) | second non-auto trait comes from this alias
| |
= help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjB + ObjA {}` = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjA + ObjB {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits> = note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object error[E0225]: only auto traits can be used as additional traits in a trait object
--> $DIR/no-extra-traits.rs:112:37 --> $DIR/no-extra-traits.rs:112:24
| |
LL | trait _5 = Sync + ObjB + Send; LL | trait _5 = Sync + ObjB + Send;
| ---- first non-auto trait | ---- additional non-auto trait
... ...
LL | trait _9 = _5 + Sync; LL | trait _9 = _5 + Sync;
| -- referenced here (first use) | -- second non-auto trait comes from this alias
LL | trait _10 = Unpin + _9; LL | trait _10 = Unpin + _9;
| -- referenced here (first use) | -- second non-auto trait comes from this alias
... ...
LL | type _T43 = dyn Send + _10 + Sync + ObjA; LL | type _T43 = dyn Send + _10 + Sync + ObjA;
| --- ^^^^ additional non-auto trait | ^^^ ---- first non-auto trait
| | | |
| trait alias used in trait object type (first use) | second non-auto trait comes from this alias
| |
= help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjB + ObjA {}` = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjA + ObjB {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits> = note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object error[E0225]: only auto traits can be used as additional traits in a trait object
@ -538,12 +538,12 @@ LL | trait _5 = Sync + ObjB + Send;
| ---- additional non-auto trait | ---- additional non-auto trait
... ...
LL | trait _9 = _5 + Sync; LL | trait _9 = _5 + Sync;
| -- referenced here (additional use) | -- second non-auto trait comes from this alias
LL | trait _10 = Unpin + _9; LL | trait _10 = Unpin + _9;
| -- referenced here (additional use) | -- second non-auto trait comes from this alias
... ...
LL | type _T44 = dyn ObjA + _10 + Send + Sync; LL | type _T44 = dyn ObjA + _10 + Send + Sync;
| ---- ^^^ trait alias used in trait object type (additional use) | ---- ^^^ second non-auto trait comes from this alias
| | | |
| first non-auto trait | first non-auto trait
| |
@ -551,27 +551,27 @@ LL | type _T44 = dyn ObjA + _10 + Send + Sync;
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits> = note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error[E0225]: only auto traits can be used as additional traits in a trait object error[E0225]: only auto traits can be used as additional traits in a trait object
--> $DIR/no-extra-traits.rs:118:37 --> $DIR/no-extra-traits.rs:118:31
| |
LL | trait _0 = ObjA; LL | trait _0 = ObjA;
| ---- additional non-auto trait | ---- first non-auto trait
LL | trait _1 = _0; LL | trait _1 = _0;
| -- referenced here (additional use) | -- first non-auto trait comes from this alias
... ...
LL | trait _5 = Sync + ObjB + Send; LL | trait _5 = Sync + ObjB + Send;
| ---- first non-auto trait | ---- additional non-auto trait
... ...
LL | trait _9 = _5 + Sync; LL | trait _9 = _5 + Sync;
| -- referenced here (first use) | -- second non-auto trait comes from this alias
LL | trait _10 = Unpin + _9; LL | trait _10 = Unpin + _9;
| -- referenced here (first use) | -- second non-auto trait comes from this alias
... ...
LL | type _T45 = dyn Sync + Send + _10 + _1; LL | type _T45 = dyn Sync + Send + _10 + _1;
| --- ^^ trait alias used in trait object type (additional use) | ^^^ -- first non-auto trait comes from this alias
| | | |
| trait alias used in trait object type (first use) | second non-auto trait comes from this alias
| |
= help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjB + ObjA {}` = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: ObjA + ObjB {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits> = note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error: aborting due to 28 previous errors error: aborting due to 28 previous errors

2
tests/ui/traits/alias/object-fail.rs
View file

@ -5,7 +5,7 @@ trait IteratorAlias = Iterator;
fn main() { fn main() {
let _: &dyn EqAlias = &123; let _: &dyn EqAlias = &123;
//~^ ERROR the trait `Eq` cannot be made into an object [E0038] //~^ ERROR the trait alias `EqAlias` cannot be made into an object [E0038]
let _: &dyn IteratorAlias = &vec![123].into_iter(); let _: &dyn IteratorAlias = &vec![123].into_iter();
//~^ ERROR must be specified //~^ ERROR must be specified
} }

13
tests/ui/traits/alias/object-fail.stderr
View file

@ -1,13 +1,18 @@
error[E0038]: the trait `Eq` cannot be made into an object error[E0038]: the trait alias `EqAlias` cannot be made into an object
--> $DIR/object-fail.rs:7:13 --> $DIR/object-fail.rs:7:17
| |
LL | let _: &dyn EqAlias = &123; LL | let _: &dyn EqAlias = &123;
| ^^^^^^^^^^^ `Eq` cannot be made into an object | ^^^^^^^ `EqAlias` cannot be made into an object
| |
note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety> note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
--> $SRC_DIR/core/src/cmp.rs:LL:COL --> $SRC_DIR/core/src/cmp.rs:LL:COL
| |
= note: the trait cannot be made into an object because it uses `Self` as a type parameter = note: ...because it uses `Self` as a type parameter
|
::: $DIR/object-fail.rs:3:7
|
LL | trait EqAlias = Eq;
| ------- this trait cannot be made into an object...
error[E0191]: the value of the associated type `Item` in `Iterator` must be specified error[E0191]: the value of the associated type `Item` in `Iterator` must be specified
--> $DIR/object-fail.rs:9:17 --> $DIR/object-fail.rs:9:17

14
tests/ui/traits/alias/self-in-const-generics.stderr
View file

@ -2,9 +2,19 @@ error[E0038]: the trait alias `BB` cannot be made into an object
--> $DIR/self-in-const-generics.rs:9:16 --> $DIR/self-in-const-generics.rs:9:16
| |
LL | fn foo(x: &dyn BB) {} LL | fn foo(x: &dyn BB) {}
| ^^ | ^^ `BB` cannot be made into an object
| |
= note: it cannot use `Self` as a type parameter in a supertrait or `where`-clause note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
--> $DIR/self-in-const-generics.rs:7:12
|
LL | trait BB = Bar<{ 2 + 1 }>;
| -- ^^^^^^^^^^^^^^ ...because it uses `Self` as a type parameter
| |
| this trait cannot be made into an object...
help: consider using an opaque type instead
|
LL | fn foo(x: &impl BB) {}
| ~~~~
error: aborting due to 1 previous error error: aborting due to 1 previous error

16
tests/ui/traits/alias/self-in-generics.stderr
View file

@ -2,9 +2,21 @@ error[E0038]: the trait alias `SelfInput` cannot be made into an object
--> $DIR/self-in-generics.rs:8:19 --> $DIR/self-in-generics.rs:8:19
| |
LL | pub fn f(_f: &dyn SelfInput) {} LL | pub fn f(_f: &dyn SelfInput) {}
| ^^^^^^^^^ | ^^^^^^^^^ `SelfInput` cannot be made into an object
| |
= note: it cannot use `Self` as a type parameter in a supertrait or `where`-clause note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
--> $DIR/self-in-generics.rs:6:23
|
LL | pub trait SelfInput = Fn(&mut Self);
| --------- ^^^^^^^^^^^^^
| | |
| | ...because it uses `Self` as a type parameter
| | ...because it uses `Self` as a type parameter
| this trait cannot be made into an object...
help: consider using an opaque type instead
|
LL | pub fn f(_f: &impl SelfInput) {}
| ~~~~
error: aborting due to 1 previous error error: aborting due to 1 previous error

8
tests/ui/traits/bad-sized.stderr
View file

@ -1,12 +1,12 @@
error[E0225]: only auto traits can be used as additional traits in a trait object error[E0225]: only auto traits can be used as additional traits in a trait object
--> $DIR/bad-sized.rs:4:28 --> $DIR/bad-sized.rs:4:20
| |
LL | let x: Vec<dyn Trait + Sized> = Vec::new(); LL | let x: Vec<dyn Trait + Sized> = Vec::new();
| ----- ^^^^^ additional non-auto trait | ^^^^^ ----- first non-auto trait
| | | |
| first non-auto trait | additional non-auto trait
| |
= help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Trait + Sized {}` = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Sized + Trait {}`
= note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits> = note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
error: aborting due to 1 previous error error: aborting due to 1 previous error

5
tests/ui/traits/issue-28576.stderr
View file

@ -19,9 +19,10 @@ LL | pub trait Foo<RHS: ?Sized=Self> {
| ++++++++ | ++++++++
error[E0038]: the trait `Bar` cannot be made into an object error[E0038]: the trait `Bar` cannot be made into an object
--> $DIR/issue-28576.rs:9:12 --> $DIR/issue-28576.rs:9:16
| |
LL | / dyn Bar LL | dyn Bar
| ________________^
LL | | <Assoc=()> LL | | <Assoc=()>
| |________________________^ `Bar` cannot be made into an object | |________________________^ `Bar` cannot be made into an object
| |

12
tests/ui/traits/issue-38404.stderr
View file

@ -1,8 +1,8 @@
error[E0038]: the trait `B` cannot be made into an object error[E0038]: the trait `B` cannot be made into an object
--> $DIR/issue-38404.rs:3:15 --> $DIR/issue-38404.rs:3:19
| |
LL | trait C<T>: A<dyn B<T, Output = usize>> {} LL | trait C<T>: A<dyn B<T, Output = usize>> {}
| ^^^^^^^^^^^^^^^^^^^^^^^^ `B` cannot be made into an object | ^^^^^^^^^^^^^^^^^^^^ `B` cannot be made into an object
| |
note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety> note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
--> $DIR/issue-38404.rs:1:13 --> $DIR/issue-38404.rs:1:13
@ -13,10 +13,10 @@ LL | trait B<T>: A<T> {}
| - this trait cannot be made into an object... | - this trait cannot be made into an object...
error[E0038]: the trait `B` cannot be made into an object error[E0038]: the trait `B` cannot be made into an object
--> $DIR/issue-38404.rs:3:15 --> $DIR/issue-38404.rs:3:19
| |
LL | trait C<T>: A<dyn B<T, Output = usize>> {} LL | trait C<T>: A<dyn B<T, Output = usize>> {}
| ^^^^^^^^^^^^^^^^^^^^^^^^ `B` cannot be made into an object | ^^^^^^^^^^^^^^^^^^^^ `B` cannot be made into an object
| |
note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety> note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
--> $DIR/issue-38404.rs:1:13 --> $DIR/issue-38404.rs:1:13
@ -28,10 +28,10 @@ LL | trait B<T>: A<T> {}
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no` = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
error[E0038]: the trait `B` cannot be made into an object error[E0038]: the trait `B` cannot be made into an object
--> $DIR/issue-38404.rs:3:15 --> $DIR/issue-38404.rs:3:19
| |
LL | trait C<T>: A<dyn B<T, Output = usize>> {} LL | trait C<T>: A<dyn B<T, Output = usize>> {}
| ^^^^^^^^^^^^^^^^^^^^^^^^ `B` cannot be made into an object | ^^^^^^^^^^^^^^^^^^^^ `B` cannot be made into an object
| |
note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety> note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
--> $DIR/issue-38404.rs:1:13 --> $DIR/issue-38404.rs:1:13

1
tests/ui/traits/object/canonicalize-fresh-infer-vars-issue-103626.rs
View file

@ -10,7 +10,6 @@ fn w<'a, T: 'a, F: Fn(&'a T)>() {
let b: &dyn FromResidual = &(); let b: &dyn FromResidual = &();
//~^ ERROR: the trait `FromResidual` cannot be made into an object //~^ ERROR: the trait `FromResidual` cannot be made into an object
//~| ERROR: the trait `FromResidual` cannot be made into an object //~| ERROR: the trait `FromResidual` cannot be made into an object
//~| ERROR: the trait `FromResidual` cannot be made into an object
} }
fn main() {} fn main() {}

10
tests/ui/traits/object/canonicalize-fresh-infer-vars-issue-103626.stderr
View file

@ -1,11 +1,3 @@
error[E0038]: the trait `FromResidual` cannot be made into an object
--> $DIR/canonicalize-fresh-infer-vars-issue-103626.rs:10:17
|
LL | let b: &dyn FromResidual = &();
| ^^^^^^^^^^^^
|
= note: it cannot use `Self` as a type parameter in a supertrait or `where`-clause
error[E0038]: the trait `FromResidual` cannot be made into an object error[E0038]: the trait `FromResidual` cannot be made into an object
--> $DIR/canonicalize-fresh-infer-vars-issue-103626.rs:10:32 --> $DIR/canonicalize-fresh-infer-vars-issue-103626.rs:10:32
| |
@ -51,6 +43,6 @@ help: alternatively, consider constraining `from_residual` so it does not apply
LL | fn from_residual(residual: R) -> Self where Self: Sized; LL | fn from_residual(residual: R) -> Self where Self: Sized;
| +++++++++++++++++ | +++++++++++++++++
error: aborting due to 3 previous errors error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0038`. For more information about this error, try `rustc --explain E0038`.