Auto merge of #139390 - matthiaskrgr:rollup-l64euwx, r=matthiaskrgr
Rollup of 9 pull requests Successful merges: - #139041 (Remove `rustc_middle::ty::util::ExplicitSelf`.) - #139328 (Fix 2024 edition doctest panic output) - #139339 (unstable book: document tait) - #139348 (AsyncDestructor: replace fields with impl_did) - #139353 (Fix `Debug` impl for `LateParamRegionKind`.) - #139366 (ToSocketAddrs: fix typo) - #139374 (Use the span of the whole bound when the diagnostic talks about a bound) - #139378 (Use target-agnostic LLD flags in bootstrap for `use-lld`) - #139384 (Add `compiletest` adhoc_group for `r? compiletest`) r? `@ghost` `@rustbot` modify labels: rollup
This commit is contained in:
commit
bad13a970a
32 changed files with 274 additions and 128 deletions
|
@ -969,7 +969,7 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
|
|||
}
|
||||
};
|
||||
|
||||
// If we can detect the expression to be an function or method call where the closure was
|
||||
// If we can detect the expression to be a function or method call where the closure was
|
||||
// an argument, we point at the function or method definition argument...
|
||||
if let Some((callee_def_id, call_span, call_args)) = get_call_details() {
|
||||
let arg_pos = call_args
|
||||
|
|
|
@ -12,7 +12,6 @@ use rustc_hir::{self as hir, AmbigArg, GenericParamKind, ImplItemKind, intravisi
|
|||
use rustc_infer::infer::{self, InferCtxt, TyCtxtInferExt};
|
||||
use rustc_infer::traits::util;
|
||||
use rustc_middle::ty::error::{ExpectedFound, TypeError};
|
||||
use rustc_middle::ty::util::ExplicitSelf;
|
||||
use rustc_middle::ty::{
|
||||
self, BottomUpFolder, GenericArgs, GenericParamDefKind, Ty, TyCtxt, TypeFoldable, TypeFolder,
|
||||
TypeSuperFoldable, TypeVisitableExt, TypingMode, Upcast,
|
||||
|
@ -995,6 +994,26 @@ impl<'tcx> ty::FallibleTypeFolder<TyCtxt<'tcx>> for RemapHiddenTyRegions<'tcx> {
|
|||
}
|
||||
}
|
||||
|
||||
/// Gets the string for an explicit self declaration, e.g. "self", "&self",
|
||||
/// etc.
|
||||
fn get_self_string<'tcx, P>(self_arg_ty: Ty<'tcx>, is_self_ty: P) -> String
|
||||
where
|
||||
P: Fn(Ty<'tcx>) -> bool,
|
||||
{
|
||||
if is_self_ty(self_arg_ty) {
|
||||
"self".to_owned()
|
||||
} else if let ty::Ref(_, ty, mutbl) = self_arg_ty.kind()
|
||||
&& is_self_ty(*ty)
|
||||
{
|
||||
match mutbl {
|
||||
hir::Mutability::Not => "&self".to_owned(),
|
||||
hir::Mutability::Mut => "&mut self".to_owned(),
|
||||
}
|
||||
} else {
|
||||
format!("self: {self_arg_ty}")
|
||||
}
|
||||
}
|
||||
|
||||
fn report_trait_method_mismatch<'tcx>(
|
||||
infcx: &InferCtxt<'tcx>,
|
||||
mut cause: ObligationCause<'tcx>,
|
||||
|
@ -1020,12 +1039,7 @@ fn report_trait_method_mismatch<'tcx>(
|
|||
if trait_m.fn_has_self_parameter =>
|
||||
{
|
||||
let ty = trait_sig.inputs()[0];
|
||||
let sugg = match ExplicitSelf::determine(ty, |ty| ty == impl_trait_ref.self_ty()) {
|
||||
ExplicitSelf::ByValue => "self".to_owned(),
|
||||
ExplicitSelf::ByReference(_, hir::Mutability::Not) => "&self".to_owned(),
|
||||
ExplicitSelf::ByReference(_, hir::Mutability::Mut) => "&mut self".to_owned(),
|
||||
_ => format!("self: {ty}"),
|
||||
};
|
||||
let sugg = get_self_string(ty, |ty| ty == impl_trait_ref.self_ty());
|
||||
|
||||
// When the `impl` receiver is an arbitrary self type, like `self: Box<Self>`, the
|
||||
// span points only at the type `Box<Self`>, but we want to cover the whole
|
||||
|
@ -1238,12 +1252,7 @@ fn compare_self_type<'tcx>(
|
|||
.build_with_typing_env(ty::TypingEnv::non_body_analysis(tcx, method.def_id));
|
||||
let self_arg_ty = tcx.liberate_late_bound_regions(method.def_id, self_arg_ty);
|
||||
let can_eq_self = |ty| infcx.can_eq(param_env, untransformed_self_ty, ty);
|
||||
match ExplicitSelf::determine(self_arg_ty, can_eq_self) {
|
||||
ExplicitSelf::ByValue => "self".to_owned(),
|
||||
ExplicitSelf::ByReference(_, hir::Mutability::Not) => "&self".to_owned(),
|
||||
ExplicitSelf::ByReference(_, hir::Mutability::Mut) => "&mut self".to_owned(),
|
||||
_ => format!("self: {self_arg_ty}"),
|
||||
}
|
||||
get_self_string(self_arg_ty, can_eq_self)
|
||||
};
|
||||
|
||||
match (trait_m.fn_has_self_parameter, impl_m.fn_has_self_parameter) {
|
||||
|
|
|
@ -838,7 +838,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
|
|||
| PredicateFilter::SelfOnly
|
||||
| PredicateFilter::SelfAndAssociatedTypeBounds => {
|
||||
match constness {
|
||||
hir::BoundConstness::Always(span) => {
|
||||
hir::BoundConstness::Always(_) => {
|
||||
if polarity == ty::PredicatePolarity::Positive {
|
||||
bounds.push((
|
||||
poly_trait_ref
|
||||
|
@ -864,7 +864,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
|
|||
// in `lower_assoc_item_constraint`.
|
||||
PredicateFilter::ConstIfConst | PredicateFilter::SelfConstIfConst => {
|
||||
match constness {
|
||||
hir::BoundConstness::Maybe(span) => {
|
||||
hir::BoundConstness::Maybe(_) => {
|
||||
if polarity == ty::PredicatePolarity::Positive {
|
||||
bounds.push((
|
||||
poly_trait_ref
|
||||
|
|
|
@ -1147,10 +1147,8 @@ pub struct Destructor {
|
|||
// FIXME: consider combining this definition with regular `Destructor`
|
||||
#[derive(Copy, Clone, Debug, HashStable, Encodable, Decodable)]
|
||||
pub struct AsyncDestructor {
|
||||
/// The `DefId` of the async destructor future constructor
|
||||
pub ctor: DefId,
|
||||
/// The `DefId` of the async destructor future type
|
||||
pub future: DefId,
|
||||
/// The `DefId` of the `impl AsyncDrop`
|
||||
pub impl_did: LocalDefId,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, PartialEq, Eq, HashStable, TyEncodable, TyDecodable)]
|
||||
|
|
|
@ -154,7 +154,7 @@ pub fn ty_dtor_span<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> Option<Span> {
|
|||
let dtor = if let Some(dtor) = tcx.adt_destructor(did) {
|
||||
dtor.did
|
||||
} else if let Some(dtor) = tcx.adt_async_destructor(did) {
|
||||
dtor.future
|
||||
return Some(tcx.source_span(dtor.impl_did));
|
||||
} else {
|
||||
return Some(try_local_did_span(did));
|
||||
};
|
||||
|
|
|
@ -86,15 +86,15 @@ impl fmt::Debug for ty::LateParamRegion {
|
|||
impl fmt::Debug for ty::LateParamRegionKind {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
match *self {
|
||||
ty::LateParamRegionKind::Anon(idx) => write!(f, "BrAnon({idx})"),
|
||||
ty::LateParamRegionKind::Anon(idx) => write!(f, "LateAnon({idx})"),
|
||||
ty::LateParamRegionKind::Named(did, name) => {
|
||||
if did.is_crate_root() {
|
||||
write!(f, "BrNamed({name})")
|
||||
write!(f, "LateNamed({name})")
|
||||
} else {
|
||||
write!(f, "BrNamed({did:?}, {name})")
|
||||
write!(f, "LateNamed({did:?}, {name})")
|
||||
}
|
||||
}
|
||||
ty::LateParamRegionKind::ClosureEnv => write!(f, "BrEnv"),
|
||||
ty::LateParamRegionKind::ClosureEnv => write!(f, "LateEnv"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
@ -455,26 +455,17 @@ impl<'tcx> TyCtxt<'tcx> {
|
|||
continue;
|
||||
}
|
||||
|
||||
let [future, ctor] = self.associated_item_def_ids(impl_did) else {
|
||||
self.dcx().span_delayed_bug(
|
||||
self.def_span(impl_did),
|
||||
"AsyncDrop impl without async_drop function or Dropper type",
|
||||
);
|
||||
continue;
|
||||
};
|
||||
|
||||
if let Some((_, _, old_impl_did)) = dtor_candidate {
|
||||
if let Some(old_impl_did) = dtor_candidate {
|
||||
self.dcx()
|
||||
.struct_span_err(self.def_span(impl_did), "multiple async drop impls found")
|
||||
.with_span_note(self.def_span(old_impl_did), "other impl here")
|
||||
.delay_as_bug();
|
||||
}
|
||||
|
||||
dtor_candidate = Some((*future, *ctor, impl_did));
|
||||
dtor_candidate = Some(impl_did);
|
||||
}
|
||||
|
||||
let (future, ctor, _) = dtor_candidate?;
|
||||
Some(ty::AsyncDestructor { future, ctor })
|
||||
Some(ty::AsyncDestructor { impl_did: dtor_candidate? })
|
||||
}
|
||||
|
||||
/// Returns async drop glue morphology for a definition. To get async drop
|
||||
|
@ -1561,55 +1552,6 @@ impl<'tcx> Ty<'tcx> {
|
|||
}
|
||||
}
|
||||
|
||||
pub enum ExplicitSelf<'tcx> {
|
||||
ByValue,
|
||||
ByReference(ty::Region<'tcx>, hir::Mutability),
|
||||
ByRawPointer(hir::Mutability),
|
||||
ByBox,
|
||||
Other,
|
||||
}
|
||||
|
||||
impl<'tcx> ExplicitSelf<'tcx> {
|
||||
/// Categorizes an explicit self declaration like `self: SomeType`
|
||||
/// into either `self`, `&self`, `&mut self`, `Box<Self>`, or
|
||||
/// `Other`.
|
||||
/// This is mainly used to require the arbitrary_self_types feature
|
||||
/// in the case of `Other`, to improve error messages in the common cases,
|
||||
/// and to make `Other` dyn-incompatible.
|
||||
///
|
||||
/// Examples:
|
||||
///
|
||||
/// ```ignore (illustrative)
|
||||
/// impl<'a> Foo for &'a T {
|
||||
/// // Legal declarations:
|
||||
/// fn method1(self: &&'a T); // ExplicitSelf::ByReference
|
||||
/// fn method2(self: &'a T); // ExplicitSelf::ByValue
|
||||
/// fn method3(self: Box<&'a T>); // ExplicitSelf::ByBox
|
||||
/// fn method4(self: Rc<&'a T>); // ExplicitSelf::Other
|
||||
///
|
||||
/// // Invalid cases will be caught by `check_method_receiver`:
|
||||
/// fn method_err1(self: &'a mut T); // ExplicitSelf::Other
|
||||
/// fn method_err2(self: &'static T) // ExplicitSelf::ByValue
|
||||
/// fn method_err3(self: &&T) // ExplicitSelf::ByReference
|
||||
/// }
|
||||
/// ```
|
||||
///
|
||||
pub fn determine<P>(self_arg_ty: Ty<'tcx>, is_self_ty: P) -> ExplicitSelf<'tcx>
|
||||
where
|
||||
P: Fn(Ty<'tcx>) -> bool,
|
||||
{
|
||||
use self::ExplicitSelf::*;
|
||||
|
||||
match *self_arg_ty.kind() {
|
||||
_ if is_self_ty(self_arg_ty) => ByValue,
|
||||
ty::Ref(region, ty, mutbl) if is_self_ty(ty) => ByReference(region, mutbl),
|
||||
ty::RawPtr(ty, mutbl) if is_self_ty(ty) => ByRawPointer(mutbl),
|
||||
_ if self_arg_ty.boxed_ty().is_some_and(is_self_ty) => ByBox,
|
||||
_ => Other,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns a list of types such that the given type needs drop if and only if
|
||||
/// *any* of the returned types need drop. Returns `Err(AlwaysRequiresDrop)` if
|
||||
/// this type always needs drop.
|
||||
|
|
Loading…
Add table
Add a link
Reference in a new issue