stepping into where-clauses during normalization may be productive

[lcnr]

fixes rust-lang/trait-system-refactor-initiative#273, see that issue for more info.

Whether stepping into a where-clause is productive depends not on whether we're proving a NormalizesTo or Trait goal, but instead on how both the impl and the cycle rely on it.

In the example in tests/ui/traits/next-solver/cycles/normalizes-to-is-not-productive-2.rs this is just a productive use given the way @Nadrieril and I are thinking about it right now.

We're changing such cycles to be ambiguous for now, so this does not commit us to anything.

This previously caused a lot of breakage when normalizing where-clauses, e.g. rust-lang/trait-system-refactor-initiative#176, however with #158643 that is no longer an issue. We will need to figure out what to do here if we want to properly fix ParamEnv normalization in the future

r? @BoxyUwU or @nikomatsakis

[BoxyUwU]

@rustbot author

pending figuring out how breaking this is

[rustbot]

Reminder, once the PR becomes ready for a review, use @rustbot ready.

[Randl]

Not sure if you're already aware but this PR ICEs on the following

//@ revisions: current next
//@ ignore-compare-mode-next-solver (explicit revisions)
//@[next] compile-flags: -Znext-solver
//@ edition: 2021
//@ compile-flags: --crate-type=lib
//@ build-pass

use std::future::Future;
use std::pin::Pin;
use std::sync::Arc;
use std::task::Context;
use std::task::Poll;

struct Buffer;
type Result<T> = std::result::Result<T, ()>;
type BoxedFuture<'a, T> = Pin<Box<dyn Future<Output = T> + Send + 'a>>;

trait Read: Unpin + Send {
    fn read(&mut self) -> impl Future<Output = Result<Buffer>>;
}

trait ReadDyn: Unpin + Send + Sync {}
type Reader = Box<dyn ReadDyn>;

trait Access: Send + Sync + Unpin {
    type Reader;
    fn read(&self) -> impl Future<Output = Result<(u32, Self::Reader)>> + Send;
}

trait AccessDyn: Send + Sync + Unpin {
    fn read_dyn(&self) -> BoxedFuture<'_, Result<(u32, Reader)>>;
}

impl Access for dyn AccessDyn {
    type Reader = Reader;
    async fn read(&self) -> Result<(u32, Self::Reader)> {
        self.read_dyn().await
    }
}

impl<T: Access + ?Sized> Access for Arc<T> {
    type Reader = T::Reader;
    fn read(&self) -> impl Future<Output = Result<(u32, Self::Reader)>> + Send {
        async { self.as_ref().read().await }
    }
}

struct ReadContext {
    acc: Arc<dyn AccessDyn>,
}

struct ReadGenerator {
    ctx: Arc<ReadContext>,
}

impl ReadGenerator {
    async fn next_reader(&self) -> Result<Option<Reader>> {
        let (_, r) = self.ctx.acc.read().await?;
        Ok(Some(r))
    }
}

trait Stream {
    type Item;
    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>>;
}

enum TwoWays<A, B> {
    One(A),
    Two(B),
}

impl<A: Read, B: Read> Read for TwoWays<A, B> {
    async fn read(&mut self) -> Result<Buffer> {
        match self {
            TwoWays::One(v) => v.read().await,
            TwoWays::Two(v) => v.read().await,
        }
    }
}

struct StreamingReader {
    generator: ReadGenerator,
}

impl Read for StreamingReader {
    async fn read(&mut self) -> Result<Buffer> {
        let _ = self.generator.next_reader().await;
        loop {}
    }
}

struct ChunkedReader;

impl Read for ChunkedReader {
    async fn read(&mut self) -> Result<Buffer> {
        loop {}
    }
}

enum State {
    Idle(Option<TwoWays<StreamingReader, ChunkedReader>>),
    Reading(Pin<Box<dyn Future<Output = (TwoWays<StreamingReader, ChunkedReader>, Result<Buffer>)> + Send>>),
}

struct BufferStream {
    state: State,
}

impl Stream for BufferStream {
    type Item = Result<()>;

    fn poll_next(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
        let this = unsafe { self.get_unchecked_mut() };
        loop {
            match &mut this.state {
                State::Idle(reader) => {
                    let mut reader = reader.take().unwrap();
                    let fut = async {
                        let ret = reader.read().await;
                        (reader, ret)
                    };
                    this.state = State::Reading(Box::pin(fut));
                }
                State::Reading(_) => return Poll::Pending,
            }
        }
    }
}

with

error: internal compiler error: compiler/rustc_mir_transform/src/validate.rs:81:25: broken MIR in Item(DefId(0:86 ~ async_block_box_pin_unsize_broken_mir[e897]::{impl#6}::poll_next)) (after phase change to runtime-optimized) at bb8[0]:
                                Unsize coercion, but `std::pin::Pin<std::boxed::Box<{async block@/Users/evgeniizh/RustroverProjects/rust/tests/ui/traits/next-solver/async-block-box-pin-unsize-broken-mir.rs:131:31: 131:36}>>` isn't coercible to `std::pin::Pin<std::boxed::Box<dyn std::future::Future<Output = (TwoWays<StreamingReader, ChunkedReader>, std::result::Result<Buffer, ()>)> + std::marker::Send>>`
  --> /Users/evgeniizh/RustroverProjects/rust/tests/ui/traits/next-solver/async-block-box-pin-unsize-broken-mir.rs:135:49
   |
LL |                     this.state = State::Reading(Box::pin(fut));
   |                                                 ^^^^^^^^^^^^^


thread 'rustc' (4832989) panicked at compiler/rustc_mir_transform/src/validate.rs:81:25:

while current main doesn't.

[Randl]

Hm never mind looks like it passes after rebase on main

[BoxyUwU]

@bors delegate+

r=me after rebasing

@rustbot author

[rust-bors]

✌️ @lcnr, you can now approve this pull request!

If @BoxyUwU told you to "r=me" after making some further change, then please make that change and post @bors r=BoxyUwU.

View changes since this delegation.

[rustbot]

This PR was rebased onto a different main commit. Here's a range-diff highlighting what actually changed.

Rebasing is a normal part of keeping PRs up to date, so no action is needed—this note is just to help reviewers.