Skip to content

Recurse into args in WF even if they have escaping bound vars #122501

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.

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

Closed
wants to merge 2 commits into from
Closed
Show file tree
Hide file tree
Changes from all commits
Commits
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
101 changes: 23 additions & 78 deletions compiler/rustc_trait_selection/src/traits/wf.rs
Original file line number Diff line number Diff line change
Expand Up @@ -164,7 +164,7 @@ pub fn clause_obligations<'tcx>(
wf.compute(ty.into());
}
ty::ClauseKind::Projection(t) => {
wf.compute_projection(t.projection_ty);
wf.compute_alias(t.projection_ty);
wf.compute(match t.term.unpack() {
ty::TermKind::Ty(ty) => ty.into(),
ty::TermKind::Const(c) => c.into(),
Expand Down Expand Up @@ -396,36 +396,17 @@ impl<'a, 'tcx> WfPredicates<'a, 'tcx> {
self.out.extend(obligations);
}

self.out.extend(
trait_ref
.args
.iter()
.enumerate()
.filter(|(_, arg)| {
matches!(arg.unpack(), GenericArgKind::Type(..) | GenericArgKind::Const(..))
})
.filter(|(_, arg)| !arg.has_escaping_bound_vars())
.map(|(i, arg)| {
let mut cause = traits::ObligationCause::misc(self.span, self.body_id);
// The first arg is the self ty - use the correct span for it.
if i == 0 {
if let Some(hir::ItemKind::Impl(hir::Impl { self_ty, .. })) =
item.map(|i| &i.kind)
{
cause.span = self_ty.span;
}
}
traits::Obligation::with_depth(
tcx,
cause,
depth,
param_env,
ty::Binder::dummy(ty::PredicateKind::Clause(ty::ClauseKind::WellFormed(
arg,
))),
)
}),
);
if let Some(hir::ItemKind::Impl(hir::Impl { self_ty, .. })) = item.map(|i| &i.kind) {
// FIXME: Could generalize this hack.
let span = std::mem::replace(&mut self.span, self_ty.span);
// make sure that the trait ref is WF.
trait_ref.args[0].visit_with(self);
self.span = span;
(&trait_ref.args[1..]).visit_with(self);
} else {
// make sure that the trait ref is WF.
trait_ref.visit_with(self);
}
}

// Compute the obligations that are required for `trait_ref` to be WF,
Expand All @@ -436,9 +417,9 @@ impl<'a, 'tcx> WfPredicates<'a, 'tcx> {
}
}

/// Pushes the obligations required for `trait_ref::Item` to be WF
/// Pushes the obligations required for an alias (except inherent) to be WF
/// into `self.out`.
fn compute_projection(&mut self, data: ty::AliasTy<'tcx>) {
fn compute_alias(&mut self, data: ty::AliasTy<'tcx>) {
// A projection is well-formed if
//
// (a) its predicates hold (*)
Expand All @@ -463,9 +444,13 @@ impl<'a, 'tcx> WfPredicates<'a, 'tcx> {
let obligations = self.nominal_obligations(data.def_id, data.args);
self.out.extend(obligations);

self.compute_projection_args(data.args);
// Make sure that projection args are WF.
data.visit_with(self);
}

/// Pushes the obligations required for an inherent alias to be WF
/// into `self.out`.
// FIXME(inherent_associated_types): Merge this function with `fn compute_alias`.
fn compute_inherent_projection(&mut self, data: ty::AliasTy<'tcx>) {
// An inherent projection is well-formed if
//
Expand All @@ -490,33 +475,8 @@ impl<'a, 'tcx> WfPredicates<'a, 'tcx> {
self.out.extend(obligations);
}

self.compute_projection_args(data.args);
}

fn compute_projection_args(&mut self, args: GenericArgsRef<'tcx>) {
let tcx = self.tcx();
let cause = self.cause(traits::WellFormed(None));
let param_env = self.param_env;
let depth = self.recursion_depth;

self.out.extend(
args.iter()
.filter(|arg| {
matches!(arg.unpack(), GenericArgKind::Type(..) | GenericArgKind::Const(..))
})
.filter(|arg| !arg.has_escaping_bound_vars())
.map(|arg| {
traits::Obligation::with_depth(
tcx,
cause.clone(),
depth,
param_env,
ty::Binder::dummy(ty::PredicateKind::Clause(ty::ClauseKind::WellFormed(
arg,
))),
)
}),
);
// Make sure that projection args are WF.
data.visit_with(self);
}

fn require_sized(&mut self, subty: Ty<'tcx>, cause: traits::ObligationCauseCode<'tcx>) {
Expand Down Expand Up @@ -688,8 +648,8 @@ impl<'a, 'tcx> TypeVisitor<TyCtxt<'tcx>> for WfPredicates<'a, 'tcx> {
// Simple cases that are WF if their type args are WF.
}

ty::Alias(ty::Projection, data) => {
self.compute_projection(data);
ty::Alias(ty::Projection | ty::Opaque | ty::Weak, data) => {
self.compute_alias(data);
return; // Subtree handled by compute_projection.
}
ty::Alias(ty::Inherent, data) => {
Expand Down Expand Up @@ -791,21 +751,6 @@ impl<'a, 'tcx> TypeVisitor<TyCtxt<'tcx>> for WfPredicates<'a, 'tcx> {
// types appearing in the fn signature.
}

ty::Alias(ty::Opaque, ty::AliasTy { def_id, args, .. }) => {
// All of the requirements on type parameters
// have already been checked for `impl Trait` in
// return position. We do need to check type-alias-impl-trait though.
if self.tcx().is_type_alias_impl_trait(def_id) {
let obligations = self.nominal_obligations(def_id, args);
self.out.extend(obligations);
}
}

ty::Alias(ty::Weak, ty::AliasTy { def_id, args, .. }) => {
let obligations = self.nominal_obligations(def_id, args);
self.out.extend(obligations);
}

ty::Dynamic(data, r, _) => {
// WfObject
//
Expand Down
1 change: 1 addition & 0 deletions tests/ui/impl-trait/in-trait/return-dont-satisfy-bounds.rs
Original file line number Diff line number Diff line change
Expand Up @@ -9,6 +9,7 @@ impl Foo<char> for Bar {
//~^ ERROR: the trait bound `impl Foo<u8>: Foo<char>` is not satisfied [E0277]
//~| ERROR: the trait bound `Bar: Foo<u8>` is not satisfied [E0277]
//~| ERROR: impl has stricter requirements than trait
//~| ERROR: the trait bound `F2: Foo<u8>` is not satisfied
self
}
}
Expand Down
18 changes: 17 additions & 1 deletion tests/ui/impl-trait/in-trait/return-dont-satisfy-bounds.stderr
Original file line number Diff line number Diff line change
Expand Up @@ -11,6 +11,22 @@ note: required by a bound in `Foo::{synthetic#0}`
LL | fn foo<F2>(self) -> impl Foo<T>;
| ^^^^^^ required by this bound in `Foo::{synthetic#0}`

error[E0277]: the trait bound `F2: Foo<u8>` is not satisfied
--> $DIR/return-dont-satisfy-bounds.rs:8:34
|
LL | fn foo<F2: Foo<u8>>(self) -> impl Foo<u8> {
| ^^^^^^^^^^^^ the trait `Foo<u8>` is not implemented for `F2`
|
note: required by a bound in `<Bar as Foo<char>>::foo`
--> $DIR/return-dont-satisfy-bounds.rs:8:16
|
LL | fn foo<F2: Foo<u8>>(self) -> impl Foo<u8> {
| ^^^^^^^ required by this bound in `<Bar as Foo<char>>::foo`
help: consider further restricting this bound
|
LL | fn foo<F2: Foo<u8> + Foo<u8>>(self) -> impl Foo<u8> {
| +++++++++

error[E0276]: impl has stricter requirements than trait
--> $DIR/return-dont-satisfy-bounds.rs:8:16
|
Expand All @@ -32,7 +48,7 @@ LL | self
= help: the trait `Foo<char>` is implemented for `Bar`
= help: for that trait implementation, expected `char`, found `u8`

error: aborting due to 3 previous errors
error: aborting due to 4 previous errors

Some errors have detailed explanations: E0276, E0277.
For more information about an error, try `rustc --explain E0276`.
10 changes: 5 additions & 5 deletions tests/ui/implied-bounds/from-trait-impl.stderr
Original file line number Diff line number Diff line change
Expand Up @@ -7,13 +7,13 @@ LL | fn func1(foo: Foo<(&str,)>) {
= note: type must satisfy the static lifetime

error[E0310]: the parameter type `X` may not live long enough
--> $DIR/from-trait-impl.rs:20:23
--> $DIR/from-trait-impl.rs:20:9
|
LL | impl<X> TestTrait for [Foo<(X,)>; 1] {}
| ^^^^^^^^^^^^^^
| |
| the parameter type `X` must be valid for the static lifetime...
| ...so that the type `X` will meet its required lifetime bounds
| ^^^^^^^^^
| |
| the parameter type `X` must be valid for the static lifetime...
| ...so that the type `X` will meet its required lifetime bounds
|
help: consider adding an explicit lifetime bound
|
Expand Down
14 changes: 0 additions & 14 deletions tests/ui/inference/issue-80409.no-compat.stderr

This file was deleted.

17 changes: 1 addition & 16 deletions tests/ui/inference/issue-80409.rs
Original file line number Diff line number Diff line change
@@ -1,19 +1,3 @@
// This should not pass, because `usize: Fsm` does not hold. However, it currently ICEs.

// ignore-tidy-linelength

//@ revisions: compat no-compat
//@[compat] check-pass
//@[no-compat] compile-flags: -Zno-implied-bounds-compat
//@[no-compat] check-fail
//@[no-compat] known-bug: #80409
//@[no-compat] failure-status: 101
//@[no-compat] normalize-stderr-test "delayed at.*" -> ""
//@[no-compat] normalize-stderr-test "note: .*\n\n" -> ""
//@[no-compat] normalize-stderr-test "thread 'rustc' panicked.*\n" -> ""
//@[no-compat] normalize-stderr-test "(error: internal compiler error: [^:]+):\d+:\d+: " -> "$1:LL:CC: "
//@[no-compat] rustc-env:RUST_BACKTRACE=0

#![allow(unreachable_code, unused)]

use std::marker::PhantomData;
Expand All @@ -34,6 +18,7 @@ struct FsmStateBuilder<TFsm> {

impl<TFsm> FsmStateBuilder<TFsm> {
fn on_entry<TAction: Fn(&mut StateContext<'_, TFsm>)>(&self, _action: TAction) {}
//~^ ERROR the trait bound `TFsm: Fsm` is not satisfied
}

trait Fsm {
Expand Down
1 change: 1 addition & 0 deletions tests/ui/lifetimes/issue-76168-hr-outlives-3.rs
Original file line number Diff line number Diff line change
Expand Up @@ -7,6 +7,7 @@ async fn wrapper<F>(f: F)
//~^ ERROR: expected a `FnOnce(&'a mut i32)` closure, found `i32`
//~| ERROR: expected a `FnOnce(&'a mut i32)` closure, found `i32`
//~| ERROR: expected a `FnOnce(&'a mut i32)` closure, found `i32`
//~| ERROR: expected a `FnOnce(&'a mut i32)` closure, found `i32`
where
F:,
for<'a> <i32 as FnOnce<(&'a mut i32,)>>::Output: Future<Output = ()> + 'a,
Expand Down
23 changes: 19 additions & 4 deletions tests/ui/lifetimes/issue-76168-hr-outlives-3.stderr
Original file line number Diff line number Diff line change
Expand Up @@ -5,7 +5,7 @@ LL | / async fn wrapper<F>(f: F)
LL | |
LL | |
LL | |
LL | | where
... |
LL | | F:,
LL | | for<'a> <i32 as FnOnce<(&'a mut i32,)>>::Output: Future<Output = ()> + 'a,
| |__________________________________________________________________________^ expected an `FnOnce(&'a mut i32)` closure, found `i32`
Expand All @@ -27,15 +27,30 @@ LL | / async fn wrapper<F>(f: F)
LL | |
LL | |
LL | |
LL | | where
... |
LL | | F:,
LL | | for<'a> <i32 as FnOnce<(&'a mut i32,)>>::Output: Future<Output = ()> + 'a,
| |__________________________________________________________________________^ expected an `FnOnce(&'a mut i32)` closure, found `i32`
|
= help: the trait `for<'a> FnOnce<(&'a mut i32,)>` is not implemented for `i32`

error[E0277]: expected a `FnOnce(&'a mut i32)` closure, found `i32`
--> $DIR/issue-76168-hr-outlives-3.rs:13:1
--> $DIR/issue-76168-hr-outlives-3.rs:6:1
|
LL | / async fn wrapper<F>(f: F)
LL | |
LL | |
LL | |
... |
LL | | F:,
LL | | for<'a> <i32 as FnOnce<(&'a mut i32,)>>::Output: Future<Output = ()> + 'a,
| |__________________________________________________________________________^ expected an `FnOnce(&'a mut i32)` closure, found `i32`
|
= help: the trait `for<'a> FnOnce<(&'a mut i32,)>` is not implemented for `i32`
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`

error[E0277]: expected a `FnOnce(&'a mut i32)` closure, found `i32`
--> $DIR/issue-76168-hr-outlives-3.rs:14:1
|
LL | / {
LL | |
Expand All @@ -46,6 +61,6 @@ LL | | }
|
= help: the trait `for<'a> FnOnce<(&'a mut i32,)>` is not implemented for `i32`

error: aborting due to 4 previous errors
error: aborting due to 5 previous errors

For more information about this error, try `rustc --explain E0277`.
Loading