Skip to content

Shallowly bail from coerce_unsized more #142941

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
wants to merge 3 commits into
base: master
Choose a base branch
from
Open

Shallowly bail from coerce_unsized more #142941

Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
8242b55
Assert shallow resolved args in coerce
compiler-errors Jun 26, 2025
904458f
Shallowly bail from coerce_unsized more
compiler-errors Jun 24, 2025
0d37587
Add a note and one more fast path
compiler-errors Jun 24, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
89 changes: 70 additions & 19 deletions compiler/rustc_hir_typeck/src/coercion.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -279,8 +279,8 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
/// fall back to subtyping (`unify_and`).
fn coerce_from_inference_variable(&self, a: Ty<'tcx>, b: Ty<'tcx>) -> CoerceResult<'tcx> {
debug!("coerce_from_inference_variable(a={:?}, b={:?})", a, b);
assert!(a.is_ty_var() && self.shallow_resolve(a) == a);
assert!(self.shallow_resolve(b) == b);
debug_assert!(a.is_ty_var() && self.shallow_resolve(a) == a);
debug_assert!(self.shallow_resolve(b) == b);

if b.is_ty_var() {
// Two unresolved type variables: create a `Coerce` predicate.
Expand Down Expand Up @@ -324,6 +324,8 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
mutbl_b: hir::Mutability,
) -> CoerceResult<'tcx> {
debug!("coerce_borrowed_pointer(a={:?}, b={:?})", a, b);
debug_assert!(self.shallow_resolve(a) == a);
debug_assert!(self.shallow_resolve(b) == b);

// If we have a parameter of type `&M T_a` and the value
// provided is `expr`, we will be adding an implicit borrow,
Expand Down Expand Up @@ -515,10 +517,10 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
///
/// [unsized coercion](https://doc.rust-lang.org/reference/type-coercions.html#unsized-coercions)
#[instrument(skip(self), level = "debug")]
fn coerce_unsized(&self, mut source: Ty<'tcx>, mut target: Ty<'tcx>) -> CoerceResult<'tcx> {
source = self.shallow_resolve(source);
target = self.shallow_resolve(target);
Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

why remove these, are we guaranteed that they are shallow resolved? if so, please convert them into debug asserts

Copy link
Member Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

yes, we shallowly resolve at the top of the coerce entrypoint

Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

pls debug assert then

fn coerce_unsized(&self, source: Ty<'tcx>, target: Ty<'tcx>) -> CoerceResult<'tcx> {
debug!(?source, ?target);
debug_assert!(self.shallow_resolve(source) == source);
debug_assert!(self.shallow_resolve(target) == target);

// We don't apply any coercions incase either the source or target
// aren't sufficiently well known but tend to instead just equate
Expand All @@ -532,6 +534,54 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
return Err(TypeError::Mismatch);
}

// This is an optimization because coercion is one of the most common
// operations that we do in typeck, since it happens at every assignment
// and call arg (among other positions).
//
// These targets are known to never be RHS in `LHS: CoerceUnsized<RHS>`.
// That's because these are built-in types for which a core-provided impl
// doesn't exist, and for which a user-written impl is invalid.
//
// This is technically incomplete when users write impossible bounds like
// `where T: CoerceUnsized<usize>`, for example, but that trait is unstable
// and coercion is allowed to be incomplete. The only case where this matters
// is impossible bounds.
//
// Note that some of these types implement `LHS: Unsize<RHS>`, but they
// do not implement *`CoerceUnsized`* which is the root obligation of the
// check below.
match target.kind() {
ty::Bool
| ty::Char
| ty::Int(_)
| ty::Uint(_)
| ty::Float(_)
| ty::Infer(ty::IntVar(_) | ty::FloatVar(_))
| ty::Str
| ty::Array(_, _)
| ty::Slice(_)
Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

array to slice is always Deref an not CoerceUnsized? 🤔

Copy link
Member Author

@compiler-errors compiler-errors Jun 25, 2025 •
edited
Loading

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Slices are the RHS for Unsize, not CoerceUnsized. The latter is for pointers not data.

Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

ah yeah, remember how this works again/looked it up

| ty::FnDef(_, _)
| ty::FnPtr(_, _)
| ty::Dynamic(_, _, _)
| ty::Closure(_, _)
| ty::CoroutineClosure(_, _)
| ty::Coroutine(_, _)
| ty::CoroutineWitness(_, _)
| ty::Never
| ty::Tuple(_) => return Err(TypeError::Mismatch),
_ => {}
}
// Additionally, we ignore `&str -> &str` coercions, which happen very
// commonly since strings are one of the most used argument types in Rust,
// we do coercions when type checking call expressions.
if let ty::Ref(_, source_pointee, ty::Mutability::Not) = *source.kind()
&& source_pointee.is_str()
&& let ty::Ref(_, target_pointee, ty::Mutability::Not) = *target.kind()
&& target_pointee.is_str()
{
return Err(TypeError::Mismatch);
}

let traits =
(self.tcx.lang_items().unsize_trait(), self.tcx.lang_items().coerce_unsized_trait());
let (Some(unsize_did), Some(coerce_unsized_did)) = traits else {
Expand Down Expand Up @@ -801,6 +851,9 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
/// - `Pin<Box<T>>` as `Pin<&mut T>`
#[instrument(skip(self), level = "trace")]
fn coerce_pin_ref(&self, a: Ty<'tcx>, b: Ty<'tcx>) -> CoerceResult<'tcx> {
debug_assert!(self.shallow_resolve(a) == a);
debug_assert!(self.shallow_resolve(b) == b);

// We need to make sure the two types are compatible for coercion.
// Then we will build a ReborrowPin adjustment and return that as an InferOk.

Expand Down Expand Up @@ -849,6 +902,8 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
b: Ty<'tcx>,
adjustment: Option<Adjust>,
) -> CoerceResult<'tcx> {
debug_assert!(self.shallow_resolve(b) == b);

self.commit_if_ok(|snapshot| {
let outer_universe = self.infcx.universe();

Expand Down Expand Up @@ -889,24 +944,19 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
fn_ty_a: ty::PolyFnSig<'tcx>,
b: Ty<'tcx>,
) -> CoerceResult<'tcx> {
//! Attempts to coerce from the type of a Rust function item
//! into a closure or a `proc`.
//!

let b = self.shallow_resolve(b);
debug!(?fn_ty_a, ?b, "coerce_from_fn_pointer");
debug_assert!(self.shallow_resolve(b) == b);

self.coerce_from_safe_fn(fn_ty_a, b, None)
}

fn coerce_from_fn_item(&self, a: Ty<'tcx>, b: Ty<'tcx>) -> CoerceResult<'tcx> {
//! Attempts to coerce from the type of a Rust function item
//! into a closure or a `proc`.
debug!("coerce_from_fn_item(a={:?}, b={:?})", a, b);
debug_assert!(self.shallow_resolve(a) == a);
debug_assert!(self.shallow_resolve(b) == b);

let b = self.shallow_resolve(b);
let InferOk { value: b, mut obligations } =
self.at(&self.cause, self.param_env).normalize(b);
debug!("coerce_from_fn_item(a={:?}, b={:?})", a, b);

match b.kind() {
ty::FnPtr(_, b_hdr) => {
Expand Down Expand Up @@ -956,18 +1006,17 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
}
}

/// Attempts to coerce from the type of a non-capturing closure
/// into a function pointer.
fn coerce_closure_to_fn(
&self,
a: Ty<'tcx>,
closure_def_id_a: DefId,
args_a: GenericArgsRef<'tcx>,
b: Ty<'tcx>,
) -> CoerceResult<'tcx> {
//! Attempts to coerce from the type of a non-capturing closure
//! into a function pointer.
//!

let b = self.shallow_resolve(b);
debug_assert!(self.shallow_resolve(a) == a);
debug_assert!(self.shallow_resolve(b) == b);

match b.kind() {
// At this point we haven't done capture analysis, which means
Expand Down Expand Up @@ -1011,6 +1060,8 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
mutbl_b: hir::Mutability,
) -> CoerceResult<'tcx> {
debug!("coerce_raw_ptr(a={:?}, b={:?})", a, b);
debug_assert!(self.shallow_resolve(a) == a);
debug_assert!(self.shallow_resolve(b) == b);

let (is_ref, mt_a) = match *a.kind() {
ty::Ref(_, ty, mutbl) => (true, ty::TypeAndMut { ty, mutbl }),
Expand Down
Loading