Deny use<> for RPITITs

compiler/rustc_ast_lowering/messages.ftl

@@ -130,6 +130,9 @@ ast_lowering_never_pattern_with_guard =
 
 ast_lowering_no_precise_captures_on_apit = `use<...>` precise capturing syntax not allowed in argument-position `impl Trait`
 
+ast_lowering_no_precise_captures_on_rpitit = `use<...>` precise capturing syntax is currently not allowed in return-position `impl Trait` in traits
+    .note = currently, return-position `impl Trait` in traits and trait implementations capture all lifetimes in scope
+
 ast_lowering_previously_used_here = previously used here
 
 ast_lowering_register1 = register `{$reg1_name}`

compiler/rustc_ast_lowering/src/errors.rs

@@ -424,6 +424,14 @@ pub(crate) struct NoPreciseCapturesOnApit {
     pub span: Span,
 }
 
+#[derive(Diagnostic)]
+#[diag(ast_lowering_no_precise_captures_on_rpitit)]
+#[note]
+pub(crate) struct NoPreciseCapturesOnRpitit {
+    #[primary_span]
+    pub span: Span,
+}
+
 #[derive(Diagnostic)]
 #[diag(ast_lowering_yield_in_closure)]
 pub(crate) struct YieldInClosure {

compiler/rustc_ast_lowering/src/lib.rs

@@ -1594,6 +1594,26 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         };
         debug!(?captured_lifetimes_to_duplicate);
 
+        match fn_kind {
+            // Deny `use<>` on RPITIT in trait/trait-impl for now.
+            Some(FnDeclKind::Trait | FnDeclKind::Impl) => {
+                if let Some(span) = bounds.iter().find_map(|bound| match *bound {
+                    ast::GenericBound::Use(_, span) => Some(span),
+                    _ => None,
+                }) {
+                    self.tcx.dcx().emit_err(errors::NoPreciseCapturesOnRpitit { span });
+                }
+            }
+            None
+            | Some(
+                FnDeclKind::Fn
+                | FnDeclKind::Inherent
+                | FnDeclKind::ExternFn
+                | FnDeclKind::Closure
+                | FnDeclKind::Pointer,
+            ) => {}
+        }
+
         self.lower_opaque_inner(
             opaque_ty_node_id,
             origin,

tests/ui/impl-trait/precise-capturing/forgot-to-capture-type.rs

@@ -6,6 +6,7 @@ fn type_param<T>() -> impl Sized + use<> {}
 trait Foo {
     fn bar() -> impl Sized + use<>;
     //~^ ERROR `impl Trait` must mention the `Self` type of the trait
+    //~| ERROR `use<...>` precise capturing syntax is currently not allowed in return-position `impl Trait` in traits
 }
 
 fn main() {}

tests/ui/impl-trait/precise-capturing/forgot-to-capture-type.stderr

@@ -1,3 +1,11 @@
+error: `use<...>` precise capturing syntax is currently not allowed in return-position `impl Trait` in traits
+  --> $DIR/forgot-to-capture-type.rs:7:30
+   |
+LL |     fn bar() -> impl Sized + use<>;
+   |                              ^^^^^
+   |
+   = note: currently, return-position `impl Trait` in traits and trait implementations capture all lifetimes in scope
+
 error: `impl Trait` must mention all type parameters in scope in `use<...>`
   --> $DIR/forgot-to-capture-type.rs:3:23
    |
@@ -18,5 +26,5 @@ LL |     fn bar() -> impl Sized + use<>;
    |
    = note: currently, all type parameters are required to be mentioned in the precise captures list
 
-error: aborting due to 2 previous errors
+error: aborting due to 3 previous errors
 

tests/ui/impl-trait/precise-capturing/redundant.normal.stderr

@@ -0,0 +1,20 @@
+warning: all possible in-scope parameters are already captured, so `use<...>` syntax is redundant
+  --> $DIR/redundant.rs:7:19
+   |
+LL | fn hello<'a>() -> impl Sized + use<'a> {}
+   |                   ^^^^^^^^^^^^^-------
+   |                                |
+   |                                help: remove the `use<...>` syntax
+   |
+   = note: `#[warn(impl_trait_redundant_captures)]` on by default
+
+warning: all possible in-scope parameters are already captured, so `use<...>` syntax is redundant
+  --> $DIR/redundant.rs:12:27
+   |
+LL |     fn inherent(&self) -> impl Sized + use<'_> {}
+   |                           ^^^^^^^^^^^^^-------
+   |                                        |
+   |                                        help: remove the `use<...>` syntax
+
+warning: 2 warnings emitted
+

tests/ui/impl-trait/precise-capturing/redundant.rpitit.stderr

@@ -0,0 +1,18 @@
+error: `use<...>` precise capturing syntax is currently not allowed in return-position `impl Trait` in traits
+  --> $DIR/redundant.rs:18:35
+   |
+LL |     fn in_trait() -> impl Sized + use<'a, Self>;
+   |                                   ^^^^^^^^^^^^^
+   |
+   = note: currently, return-position `impl Trait` in traits and trait implementations capture all lifetimes in scope
+
+error: `use<...>` precise capturing syntax is currently not allowed in return-position `impl Trait` in traits
+  --> $DIR/redundant.rs:23:35
+   |
+LL |     fn in_trait() -> impl Sized + use<'a> {}
+   |                                   ^^^^^^^
+   |
+   = note: currently, return-position `impl Trait` in traits and trait implementations capture all lifetimes in scope
+
+error: aborting due to 2 previous errors
+

tests/ui/impl-trait/precise-capturing/redundant.rs

@@ -1,24 +1,27 @@
 //@ compile-flags: -Zunstable-options --edition=2024
-//@ check-pass
+//@ revisions: normal rpitit
+//@[normal] check-pass
 
 #![feature(precise_capturing)]
 
 fn hello<'a>() -> impl Sized + use<'a> {}
-//~^ WARN all possible in-scope parameters are already captured
+//[normal]~^ WARN all possible in-scope parameters are already captured
 
 struct Inherent;
 impl Inherent {
     fn inherent(&self) -> impl Sized + use<'_> {}
-    //~^ WARN all possible in-scope parameters are already captured
+    //[normal]~^ WARN all possible in-scope parameters are already captured
 }
 
+#[cfg(rpitit)]
 trait Test<'a> {
     fn in_trait() -> impl Sized + use<'a, Self>;
-    //~^ WARN all possible in-scope parameters are already captured
+    //[rpitit]~^ ERROR `use<...>` precise capturing syntax is currently not allowed in return-position `impl Trait` in traits
 }
+#[cfg(rpitit)]
 impl<'a> Test<'a> for () {
     fn in_trait() -> impl Sized + use<'a> {}
-    //~^ WARN all possible in-scope parameters are already captured
+    //[rpitit]~^ ERROR `use<...>` precise capturing syntax is currently not allowed in return-position `impl Trait` in traits
 }
 
 fn main() {}

tests/ui/impl-trait/precise-capturing/rpitit.rs

@@ -0,0 +1,21 @@
+//@ known-bug: unknown
+
+// RPITITs don't have variances in their GATs, so they always relate invariantly
+// and act as if they capture all their args.
+// To fix this soundly, we need to make sure that all the trait header args
+// remain captured, since they affect trait selection.
+
+#![feature(precise_capturing)]
+
+trait Foo<'a> {
+    fn hello() -> impl PartialEq + use<Self>;
+}
+
+fn test<'a, 'b, T: for<'r> Foo<'r>>() {
+    PartialEq::eq(
+        &<T as Foo<'a>>::hello(),
+        &<T as Foo<'b>>::hello(),
+    );
+}
+
+fn main() {}

tests/ui/impl-trait/precise-capturing/rpitit.stderr

@@ -0,0 +1,50 @@
+error: `use<...>` precise capturing syntax is currently not allowed in return-position `impl Trait` in traits
+  --> $DIR/rpitit.rs:11:36
+   |
+LL |     fn hello() -> impl PartialEq + use<Self>;
+   |                                    ^^^^^^^^^
+   |
+   = note: currently, return-position `impl Trait` in traits and trait implementations capture all lifetimes in scope
+
+error: `impl Trait` captures lifetime parameter, but it is not mentioned in `use<...>` precise captures list
+  --> $DIR/rpitit.rs:11:19
+   |
+LL | trait Foo<'a> {
+   |           -- this lifetime parameter is captured
+LL |     fn hello() -> impl PartialEq + use<Self>;
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^ lifetime captured due to being mentioned in the bounds of the `impl Trait`
+
+error: lifetime may not live long enough
+  --> $DIR/rpitit.rs:15:5
+   |
+LL |   fn test<'a, 'b, T: for<'r> Foo<'r>>() {
+   |           --  -- lifetime `'b` defined here
+   |           |
+   |           lifetime `'a` defined here
+LL | /     PartialEq::eq(
+LL | |         &<T as Foo<'a>>::hello(),
+LL | |         &<T as Foo<'b>>::hello(),
+LL | |     );
+   | |_____^ argument requires that `'a` must outlive `'b`
+   |
+   = help: consider adding the following bound: `'a: 'b`
+
+error: lifetime may not live long enough
+  --> $DIR/rpitit.rs:15:5
+   |
+LL |   fn test<'a, 'b, T: for<'r> Foo<'r>>() {
+   |           --  -- lifetime `'b` defined here
+   |           |
+   |           lifetime `'a` defined here
+LL | /     PartialEq::eq(
+LL | |         &<T as Foo<'a>>::hello(),
+LL | |         &<T as Foo<'b>>::hello(),
+LL | |     );
+   | |_____^ argument requires that `'b` must outlive `'a`
+   |
+   = help: consider adding the following bound: `'b: 'a`
+
+help: `'a` and `'b` must be the same: replace one with the other
+
+error: aborting due to 4 previous errors
+

tests/ui/impl-trait/precise-capturing/self-capture.rs

@@ -1,9 +1,8 @@
-//@ check-pass
-
 #![feature(precise_capturing)]
 
 trait Foo {
     fn bar<'a>() -> impl Sized + use<Self>;
+    //~^ ERROR `use<...>` precise capturing syntax is currently not allowed in return-position `impl Trait` in traits
 }
 
 fn main() {}

tests/ui/impl-trait/precise-capturing/self-capture.stderr

@@ -0,0 +1,10 @@
+error: `use<...>` precise capturing syntax is currently not allowed in return-position `impl Trait` in traits
+  --> $DIR/self-capture.rs:4:34
+   |
+LL |     fn bar<'a>() -> impl Sized + use<Self>;
+   |                                  ^^^^^^^^^
+   |
+   = note: currently, return-position `impl Trait` in traits and trait implementations capture all lifetimes in scope
+
+error: aborting due to 1 previous error
+