Implement precise capturing of types

Author: compiler-errors

compiler/rustc_feature/src/unstable.rs

@@ -598,8 +598,10 @@ declare_features! (
     (incomplete, pin_ergonomics, "1.83.0", Some(130494)),
     /// Allows postfix match `expr.match { ... }`
     (unstable, postfix_match, "1.79.0", Some(121618)),
-    /// Allows `use<..>` precise capturign on impl Trait in traits.
+    /// Allows `use<..>` precise capturing on impl Trait in traits.
     (unstable, precise_capturing_in_traits, "1.83.0", Some(130044)),
+    /// Allows `use<..>` precise capturing to omit type and const parameters.
+    (incomplete, precise_capturing_of_types, "1.83.0", Some(130043)),
     /// Allows macro attributes on expressions, statements and non-inline modules.
     (unstable, proc_macro_hygiene, "1.30.0", Some(54727)),
     /// Allows the use of raw-dylibs on ELF platforms

compiler/rustc_hir_analysis/messages.ftl

@@ -284,16 +284,9 @@ hir_analysis_late_bound_lifetime_in_apit = `impl Trait` can only mention lifetim
 hir_analysis_late_bound_type_in_apit = `impl Trait` can only mention type parameters from an fn or impl
     .label = type parameter declared here
 
-hir_analysis_lifetime_implicitly_captured = `impl Trait` captures lifetime parameter, but it is not mentioned in `use<...>` precise captures list
-    .param_label = all lifetime parameters originating from a trait are captured implicitly
-
 hir_analysis_lifetime_must_be_first = lifetime parameter `{$name}` must be listed before non-lifetime parameters
     .label = move the lifetime before this parameter
 
-hir_analysis_lifetime_not_captured = `impl Trait` captures lifetime parameter, but it is not mentioned in `use<...>` precise captures list
-    .label = lifetime captured due to being mentioned in the bounds of the `impl Trait`
-    .param_label = this lifetime parameter is captured
-
 hir_analysis_lifetimes_or_bounds_mismatch_on_trait =
     lifetime parameters or bounds on {$item_kind} `{$ident}` do not match the trait declaration
     .label = lifetimes do not match {$item_kind} in trait
@@ -412,6 +405,9 @@ hir_analysis_opaque_captures_higher_ranked_lifetime = `impl Trait` cannot captur
     .label = `impl Trait` implicitly captures all lifetimes in scope
     .note = lifetime declared here
 
+hir_analysis_param_implicitly_captured = `impl Trait` captures {$kind} parameter, but it is not mentioned in `use<...>` precise captures list
+    .param_label = all parameters originating from a trait are captured implicitly
+
 hir_analysis_param_in_ty_of_assoc_const_binding =
     the type of the associated constant `{$assoc_const}` must not depend on {$param_category ->
         [self] `Self`
@@ -428,7 +424,11 @@ hir_analysis_param_in_ty_of_assoc_const_binding =
         *[normal] the {$param_def_kind} `{$param_name}` is defined here
     }
 
-hir_analysis_param_not_captured = `impl Trait` must mention all {$kind} parameters in scope in `use<...>`
+hir_analysis_param_not_captured = `impl Trait` captures {$kind} parameter, but it is not mentioned in `use<...>` precise captures list
+    .label = {$kind} captured due to being mentioned in the bounds of the `impl Trait`
+    .param_label = this {$kind} parameter is captured
+
+hir_analysis_param_not_captured_forced = `impl Trait` must mention all {$kind} parameters in scope in `use<...>`
     .label = {$kind} parameter is implicitly captured by this `impl Trait`
     .note = currently, all {$kind} parameters are required to be mentioned in the precise captures list
 

compiler/rustc_hir_analysis/src/check/check.rs

@@ -609,71 +609,108 @@ fn check_opaque_precise_captures<'tcx>(tcx: TyCtxt<'tcx>, opaque_def_id: LocalDe
             }
 
             match param.kind {
-                ty::GenericParamDefKind::Lifetime => {
-                    let use_span = tcx.def_span(param.def_id);
-                    let opaque_span = tcx.def_span(opaque_def_id);
-                    // Check if the lifetime param was captured but isn't named in the precise captures list.
-                    if variances[param.index as usize] == ty::Invariant {
-                        if let DefKind::OpaqueTy = tcx.def_kind(tcx.parent(param.def_id))
-                            && let Some(def_id) = tcx
-                                .map_opaque_lifetime_to_parent_lifetime(param.def_id.expect_local())
-                                .opt_param_def_id(tcx, tcx.parent(opaque_def_id.to_def_id()))
-                        {
-                            tcx.dcx().emit_err(errors::LifetimeNotCaptured {
-                                opaque_span,
-                                use_span,
-                                param_span: tcx.def_span(def_id),
-                            });
-                        } else {
-                            if tcx.def_kind(tcx.parent(param.def_id)) == DefKind::Trait {
-                                tcx.dcx().emit_err(errors::LifetimeImplicitlyCaptured {
-                                    opaque_span,
-                                    param_span: tcx.def_span(param.def_id),
-                                });
-                            } else {
-                                // If the `use_span` is actually just the param itself, then we must
-                                // have not duplicated the lifetime but captured the original.
-                                // The "effective" `use_span` will be the span of the opaque itself,
-                                // and the param span will be the def span of the param.
-                                tcx.dcx().emit_err(errors::LifetimeNotCaptured {
-                                    opaque_span,
-                                    use_span: opaque_span,
-                                    param_span: use_span,
-                                });
-                            }
-                        }
-                        continue;
-                    }
-                }
+                ty::GenericParamDefKind::Lifetime => check_captured_arg_is_mentioned(
+                    tcx,
+                    opaque_def_id,
+                    variances,
+                    param,
+                    "lifetime",
+                ),
                 ty::GenericParamDefKind::Type { .. } => {
-                    if matches!(tcx.def_kind(param.def_id), DefKind::Trait | DefKind::TraitAlias) {
+                    if tcx.features().precise_capturing_of_types() {
+                        check_captured_arg_is_mentioned(
+                            tcx,
+                            opaque_def_id,
+                            variances,
+                            param,
+                            "type",
+                        )
+                    } else if matches!(
+                        tcx.def_kind(param.def_id),
+                        DefKind::Trait | DefKind::TraitAlias
+                    ) {
                         // FIXME(precise_capturing): Structured suggestion for this would be useful
                         tcx.dcx().emit_err(errors::SelfTyNotCaptured {
                             trait_span: tcx.def_span(param.def_id),
                             opaque_span: tcx.def_span(opaque_def_id),
                         });
                     } else {
                         // FIXME(precise_capturing): Structured suggestion for this would be useful
-                        tcx.dcx().emit_err(errors::ParamNotCaptured {
+                        tcx.dcx().emit_err(errors::ParamNotCapturedForced {
                             param_span: tcx.def_span(param.def_id),
                             opaque_span: tcx.def_span(opaque_def_id),
                             kind: "type",
                         });
                     }
                 }
                 ty::GenericParamDefKind::Const { .. } => {
-                    // FIXME(precise_capturing): Structured suggestion for this would be useful
-                    tcx.dcx().emit_err(errors::ParamNotCaptured {
-                        param_span: tcx.def_span(param.def_id),
-                        opaque_span: tcx.def_span(opaque_def_id),
-                        kind: "const",
-                    });
+                    if tcx.features().precise_capturing_of_types() {
+                        check_captured_arg_is_mentioned(
+                            tcx,
+                            opaque_def_id,
+                            variances,
+                            param,
+                            "const",
+                        )
+                    } else {
+                        // FIXME(precise_capturing): Structured suggestion for this would be useful
+                        tcx.dcx().emit_err(errors::ParamNotCapturedForced {
+                            param_span: tcx.def_span(param.def_id),
+                            opaque_span: tcx.def_span(opaque_def_id),
+                            kind: "const",
+                        });
+                    }
                 }
             }
         }
     }
 }
 
+fn check_captured_arg_is_mentioned<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    opaque_def_id: LocalDefId,
+    variances: &[ty::Variance],
+    param: &ty::GenericParamDef,
+    kind: &'static str,
+) {
+    let use_span = tcx.def_span(param.def_id);
+    let opaque_span = tcx.def_span(opaque_def_id);
+    // Check if the lifetime param was captured but isn't named in the precise captures list.
+    if variances[param.index as usize] == ty::Invariant {
+        if let DefKind::OpaqueTy = tcx.def_kind(tcx.parent(param.def_id))
+            && let Some(def_id) = tcx
+                .map_opaque_lifetime_to_parent_lifetime(param.def_id.expect_local())
+                .opt_param_def_id(tcx, tcx.parent(opaque_def_id.to_def_id()))
+        {
+            tcx.dcx().emit_err(errors::ParamNotCaptured {
+                opaque_span,
+                use_span,
+                param_span: tcx.def_span(def_id),
+                kind,
+            });
+        } else {
+            if tcx.def_kind(tcx.parent(param.def_id)) == DefKind::Trait {
+                tcx.dcx().emit_err(errors::ParamImplicitlyCaptured {
+                    opaque_span,
+                    param_span: tcx.def_span(param.def_id),
+                    kind,
+                });
+            } else {
+                // If the `use_span` is actually just the param itself, then we must
+                // have not duplicated the lifetime but captured the original.
+                // The "effective" `use_span` will be the span of the opaque itself,
+                // and the param span will be the def span of the param.
+                tcx.dcx().emit_err(errors::ParamNotCaptured {
+                    opaque_span,
+                    use_span: opaque_span,
+                    param_span: use_span,
+                    kind,
+                });
+            }
+        }
+    }
+}
+
 fn is_enum_of_nonnullable_ptr<'tcx>(
     tcx: TyCtxt<'tcx>,
     adt_def: AdtDef<'tcx>,

compiler/rustc_hir_analysis/src/errors/precise_captures.rs

@@ -3,9 +3,9 @@ use rustc_macros::Diagnostic;
 use rustc_span::{Span, Symbol};
 
 #[derive(Diagnostic)]
-#[diag(hir_analysis_param_not_captured)]
+#[diag(hir_analysis_param_not_captured_forced)]
 #[note]
-pub(crate) struct ParamNotCaptured {
+pub(crate) struct ParamNotCapturedForced {
     #[primary_span]
     pub opaque_span: Span,
     #[label]
@@ -24,23 +24,25 @@ pub(crate) struct SelfTyNotCaptured {
 }
 
 #[derive(Diagnostic)]
-#[diag(hir_analysis_lifetime_not_captured)]
-pub(crate) struct LifetimeNotCaptured {
+#[diag(hir_analysis_param_not_captured)]
+pub(crate) struct ParamNotCaptured {
     #[primary_span]
     pub use_span: Span,
     #[label(hir_analysis_param_label)]
     pub param_span: Span,
     #[label]
     pub opaque_span: Span,
+    pub kind: &'static str,
 }
 
 #[derive(Diagnostic)]
-#[diag(hir_analysis_lifetime_implicitly_captured)]
-pub(crate) struct LifetimeImplicitlyCaptured {
+#[diag(hir_analysis_param_implicitly_captured)]
+pub(crate) struct ParamImplicitlyCaptured {
     #[primary_span]
     pub opaque_span: Span,
     #[label(hir_analysis_param_label)]
     pub param_span: Span,
+    pub kind: &'static str,
 }
 
 #[derive(Diagnostic)]

compiler/rustc_hir_analysis/src/variance/mod.rs

@@ -63,7 +63,7 @@ fn variances_of(tcx: TyCtxt<'_>, item_def_id: LocalDefId) -> &[ty::Variance] {
         }
         DefKind::AssocTy => match tcx.opt_rpitit_info(item_def_id.to_def_id()) {
             Some(ty::ImplTraitInTraitData::Trait { opaque_def_id, .. }) => {
-                return variance_of_opaque(
+                return variances_of_opaque(
                     tcx,
                     opaque_def_id.expect_local(),
                     ForceCaptureTraitArgs::Yes,
@@ -83,7 +83,7 @@ fn variances_of(tcx: TyCtxt<'_>, item_def_id: LocalDefId) -> &[ty::Variance] {
                 ForceCaptureTraitArgs::No
             };
 
-            return variance_of_opaque(tcx, item_def_id, force_capture_trait_args);
+            return variances_of_opaque(tcx, item_def_id, force_capture_trait_args);
         }
         _ => {}
     }
@@ -99,7 +99,7 @@ enum ForceCaptureTraitArgs {
 }
 
 #[instrument(level = "trace", skip(tcx), ret)]
-fn variance_of_opaque(
+fn variances_of_opaque(
     tcx: TyCtxt<'_>,
     item_def_id: LocalDefId,
     force_capture_trait_args: ForceCaptureTraitArgs,
@@ -177,7 +177,11 @@ fn variance_of_opaque(
                         variances[param.index as usize] = ty::Bivariant;
                     }
                     ty::GenericParamDefKind::Type { .. }
-                    | ty::GenericParamDefKind::Const { .. } => {}
+                    | ty::GenericParamDefKind::Const { .. } => {
+                        if tcx.features().precise_capturing_of_types() {
+                            variances[param.index as usize] = ty::Bivariant;
+                        }
+                    }
                 }
             }
         }

compiler/rustc_middle/src/ty/context.rs

@@ -771,6 +771,10 @@ impl<'tcx> rustc_type_ir::inherent::Features<TyCtxt<'tcx>> for &'tcx rustc_featu
     fn associated_const_equality(self) -> bool {
         self.associated_const_equality()
     }
+
+    fn precise_capturing_of_types(self) -> bool {
+        self.precise_capturing_of_types()
+    }
 }
 
 impl<'tcx> rustc_type_ir::inherent::Span<TyCtxt<'tcx>> for Span {

compiler/rustc_span/src/symbol.rs

@@ -1570,6 +1570,7 @@ symbols! {
         pre_dash_lto: "pre-lto",
         precise_capturing,
         precise_capturing_in_traits,
+        precise_capturing_of_types,
         precise_pointer_size_matching,
         pref_align_of,
         prefetch_read_data,

compiler/rustc_type_ir/src/inherent.rs

@@ -575,6 +575,8 @@ pub trait Features<I: Interner>: Copy {
     fn coroutine_clone(self) -> bool;
 
     fn associated_const_equality(self) -> bool;
+
+    fn precise_capturing_of_types(self) -> bool;
 }
 
 pub trait DefId<I: Interner>: Copy + Debug + Hash + Eq + TypeFoldable<I> {

compiler/rustc_type_ir/src/opaque_ty.rs

@@ -20,9 +20,11 @@ pub struct OpaqueTypeKey<I: Interner> {
 impl<I: Interner> OpaqueTypeKey<I> {
     pub fn iter_captured_args(self, cx: I) -> impl Iterator<Item = (usize, I::GenericArg)> {
         let variances = cx.variances_of(self.def_id.into());
+        let precise_capturing_of_types = cx.features().precise_capturing_of_types();
         std::iter::zip(self.args.iter(), variances.iter()).enumerate().filter_map(
-            |(i, (arg, v))| match (arg.kind(), v) {
+            move |(i, (arg, v))| match (arg.kind(), v) {
                 (_, ty::Invariant) => Some((i, arg)),
+                (_, ty::Bivariant) if precise_capturing_of_types => None,
                 (ty::GenericArgKind::Lifetime(_), ty::Bivariant) => None,
                 _ => panic!("unexpected opaque type arg variance"),
             },

tests/ui/feature-gates/feature-gate-precise-capturing-of-types.rs

@@ -0,0 +1,4 @@
+fn foo<T>() -> impl Sized + use<> {}
+//~^ ERROR `impl Trait` must mention all type parameters in scope in `use<...>`
+
+fn main() {}