regression: non-defining opaque type use in defining scope

[digama0]

Here is an example which uses a RPIT on a borrowed type in three different ways:

use std::io::Write;

struct A(Vec<u8>);

struct B<'a> {
  one: &'a mut A,
  two: &'a mut Vec<u8>,
  three: Vec<u8>,
}

impl<'a> B<'a> {
  fn one(&mut self) -> &mut impl Write { &mut self.one.0 }
  fn two(&mut self) -> &mut impl Write { &mut self.two } // fail
  fn three(&mut self) -> &mut impl Write { &mut self.three }
}

struct C<'a>(B<'a>);

impl<'a> C<'a> {
  fn one(&mut self) -> &mut impl Write { self.0.one() } // fail on beta
  fn two(&mut self) -> &mut impl Write { self.0.two() } // fail on beta
  fn three(&mut self) -> &mut impl Write { self.0.three() } // fail on beta
}

IMO this is perfectly reasonable code and there should be no errors (EDIT: see below). On stable (rustc 1.66.0 (69f9c33d7 2022-12-12)) we have the following:

error[E0700]: hidden type for `impl std::io::Write` captures lifetime that does not appear in bounds
  --> src/main.rs:13:42
   |
11 | impl<'a> B<'a> {
   |      -- hidden type `&'a mut Vec<u8>` captures the lifetime `'a` as defined here
12 |   fn one(&mut self) -> &mut impl Write { &mut self.one.0 }
13 |   fn two(&mut self) -> &mut impl Write { &mut self.two } // fail
   |                                          ^^^^^^^^^^^^^

And on beta (rustc 1.67.0-beta.2 (352eb59a4 2022-12-13)) and nightly (rustc 1.68.0-nightly (b70baa4f9 2022-12-14)) we get some additional errors:

error[E0700]: hidden type for `impl std::io::Write` captures lifetime that does not appear in bounds
  --> src/main.rs:13:42
   |
11 | impl<'a> B<'a> {
   |      -- hidden type `&'a mut Vec<u8>` captures the lifetime `'a` as defined here
12 |   fn one(&mut self) -> &mut impl Write { &mut self.one.0 }
13 |   fn two(&mut self) -> &mut impl Write { &mut self.two } // fail
   |                                          ^^^^^^^^^^^^^

error: non-defining opaque type use in defining scope
  --> src/main.rs:20:42
   |
20 |   fn one(&mut self) -> &mut impl Write { self.0.one() } // fail on beta
   |                                          ^^^^^^^^^^^^ lifetime `'a` is part of concrete type but not used in parameter list of the `impl Trait` type alias

error: non-defining opaque type use in defining scope
  --> src/main.rs:21:42
   |
21 |   fn two(&mut self) -> &mut impl Write { self.0.two() } // fail on beta
   |                                          ^^^^^^^^^^^^ lifetime `'a` is part of concrete type but not used in parameter list of the `impl Trait` type alias

error: non-defining opaque type use in defining scope
  --> src/main.rs:22:44
   |
22 |   fn three(&mut self) -> &mut impl Write { self.0.three() } // fail on beta
   |                                            ^^^^^^^^^^^^^^ lifetime `'a` is part of concrete type but not used in parameter list of the `impl Trait` type alias

EDIT: On second thought, I guess the first error (on stable) is reasonable, since we are actually returning a &mut &'a mut Vec<u8> in that case. If you either use &mut *self.two in the body or &mut (impl Write + 'a) in the return type then the error goes away. But the second error is still a regression.

Version it worked on

It most recently worked on: rustc 1.66.0 (69f9c33 2022-12-12)

Version with regression

rustc --version --verbose:

rustc 1.67.0-beta.2 (352eb59a4 2022-12-13)
binary: rustc
commit-hash: 352eb59a4c33abf739914422f2ad975925750146
commit-date: 2022-12-13
host: x86_64-unknown-linux-gnu
release: 1.67.0-beta.2
LLVM version: 15.0.6

@rustbot modify labels: +regression-from-stable-to-beta -regression-untriaged

[aliemjay]

This is #103491. Cc @cjgillot. It is related to the invariance:

fn absurd<T>() -> T { todo!() }
fn one<'a: 'a>() -> *mut impl Sized {
    absurd::<*mut ()>()
}
fn two<'a: 'a>() -> *mut impl Sized {
    one::<'a>()
    //~^ ERROR non-defining opaque type use in defining scope
}

Another case that doesn't rely on member constraints in the second function and yields a different error message:

fn absurd<T>() -> T { todo!() }
fn assert_static<T: 'static>(_: T) {}
fn one<'a: 'a>() -> *mut impl Sized {
    absurd::<*mut ()>()
}
fn two<'a>() {
    assert_static(one::<'a>());
    //~^ ERROR lifetime may not live long enough
}

I also found a distantly related regression that doesn't require invariance. It looks like a missed subtyping opportunity:

fn one<'a, 'b: 'b>() -> &'a impl Sized {
    &()
}
fn two<'a, 'b>() {
    one::<'a, 'b>();
    //~^ ERROR lifetime may not live long enough
}

[aliemjay]

I also found a distantly related regression that doesn't require invariance. It looks like a missed subtyping opportunity:

Another version using TAIT:

#![feature(type_alias_impl_trait)]
type Opaque<'a> = impl Sized;
fn define<'a>() -> Opaque<'a> {}
fn test<'a>() {
    None::<&'static Opaque<'a>>;
}

At this point there are two classes of regression: The first is related to the fact that Invariant * Bivariant = Invariant and the the second requires more subtyping relations.

@rustbot label I-types-nominated T-types T-compiler

[apiraino]

WG-prioritization assigning priority (Zulip discussion).

@rustbot label -I-prioritize +P-critical

[Mark-Simulacrum]

From beta crater:

• https://crater-reports.s3.amazonaws.com/beta-1.67-2.4/beta-2022-12-29/gh/HadrienG2.crofiler/log.txt
• https://crater-reports.s3.amazonaws.com/beta-1.67-2.4/beta-2022-12-29/gh/mickjohn.friendly_file_server_rust/log.txt
• https://crater-reports.s3.amazonaws.com/beta-1.67-2.4/beta-2022-12-29/gh/vringar.sprenkler_web_server/log.txt
• https://crater-reports.s3.amazonaws.com/beta-1.67-2.4/beta-2022-12-29/reg/mm0b_parser-0.1.4/log.txt
• https://crater-reports.s3.amazonaws.com/beta-1.67-2.4/beta-2022-12-29/reg/scoped-0.1.2/log.txt

[lcnr]

unnominating as it will get fixed by #106503 which is approved again. Have to try to get this into beta though, only have 1 more day for that