Reject escaping generic params in the type of assoc const bindings

Author: fmease

compiler/rustc_hir_analysis/messages.ftl

@@ -289,6 +289,20 @@ hir_analysis_only_current_traits_primitive = only traits defined in the current
 
 hir_analysis_only_current_traits_ty = `{$ty}` is not defined in the current crate
 
+hir_analysis_param_in_ty_of_assoc_const_binding =
+    the type of the associated constant `{$assoc_const}` must not depend on {$synthetic ->
+        [true] `impl Trait`
+        *[false] generic parameters
+    }
+    .label = its type must not depend on {$synthetic ->
+        [true] `impl Trait`
+        *[false] the {$param_def_kind} `{$param_name}`
+    }
+    .param_defined_here_label = {$synthetic ->
+        [true] the `impl Trait` is specified here
+        *[false] the {$param_def_kind} `{$param_name}` is defined here
+    }
+
 hir_analysis_paren_sugar_attribute = the `#[rustc_paren_sugar]` attribute is a temporary means of controlling which traits can use parenthetical notation
     .help = add `#![feature(unboxed_closures)]` to the crate attributes to use it
 

compiler/rustc_hir_analysis/src/collect/type_of.rs

@@ -1,3 +1,6 @@
+use std::ops::ControlFlow;
+
+use rustc_data_structures::fx::FxIndexSet;
 use rustc_errors::{Applicability, StashKey};
 use rustc_hir as hir;
 use rustc_hir::def_id::{DefId, LocalDefId};
@@ -7,7 +10,8 @@ use rustc_middle::ty::print::with_forced_trimmed_paths;
 use rustc_middle::ty::util::IntTypeExt;
 use rustc_middle::ty::{self, ImplTraitInTraitData, IsSuggestable, Ty, TyCtxt, TypeVisitableExt};
 use rustc_span::symbol::Ident;
-use rustc_span::{Span, DUMMY_SP};
+use rustc_span::{ErrorGuaranteed, Span, Symbol, DUMMY_SP};
+use rustc_type_ir::visit::{TypeSuperVisitable, TypeVisitable, TypeVisitor};
 
 use super::bad_placeholder;
 use super::ItemCtxt;
@@ -66,10 +70,23 @@ fn anon_const_type_of<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> Ty<'tcx> {
                 .expect("const parameter types cannot be generic");
         }
 
-        Node::TypeBinding(&TypeBinding { hir_id, .. }) => {
-            // FIXME(fmease): Reject “escaping” early-bound generic parameters.
+        Node::TypeBinding(&TypeBinding { hir_id, ident, .. }) => {
+            let ty = tcx.type_of_assoc_const_binding(hir_id);
+
+            // We can't possibly catch this in the resolver, therefore we need to handle it here.
+            // FIXME(const_generics): Support generic const generics.
+            let Some(ty) = ty.no_bound_vars() else {
+                let reported = report_overly_generic_assoc_const_binding_type(
+                    tcx,
+                    ident,
+                    ty.skip_binder().skip_binder(),
+                    hir_id,
+                );
+                return Ty::new_error(tcx, reported);
+            };
+
             // FIXME(fmease): Reject escaping late-bound vars.
-            return tcx.type_of_assoc_const_binding(hir_id).skip_binder().skip_binder();
+            return ty.skip_binder();
         }
 
         // This match arm is for when the def_id appears in a GAT whose
@@ -290,6 +307,66 @@ pub(super) fn type_of_assoc_const_binding<'tcx>(
     ty::EarlyBinder::bind(ty::Binder::dummy(Ty::new_error(tcx, reported)))
 }
 
+fn report_overly_generic_assoc_const_binding_type<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    assoc_const: Ident,
+    ty: Ty<'tcx>,
+    hir_id: HirId,
+) -> ErrorGuaranteed {
+    let mut collector = GenericParamCollector { params: Default::default() };
+    ty.visit_with(&mut collector);
+
+    let mut reported = None;
+
+    let body_owner = tcx.hir().enclosing_body_owner(hir_id);
+    let generics = tcx.generics_of(body_owner);
+    for (param_index, param_name) in collector.params {
+        let param_def = generics.param_at(param_index as _, tcx);
+        reported.get_or_insert(tcx.dcx().emit_err(crate::errors::ParamInTyOfAssocConstBinding {
+            span: assoc_const.span,
+            assoc_const,
+            param_name,
+            param_def_kind: tcx.def_descr(param_def.def_id),
+            synthetic: param_def.kind.is_synthetic(),
+            param_defined_here_label: tcx.def_ident_span(param_def.def_id).unwrap(),
+        }));
+    }
+
+    struct GenericParamCollector {
+        params: FxIndexSet<(u32, Symbol)>,
+    }
+
+    impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for GenericParamCollector {
+        type BreakTy = !;
+
+        fn visit_ty(&mut self, ty: Ty<'tcx>) -> ControlFlow<Self::BreakTy> {
+            if let ty::Param(param) = ty.kind() {
+                self.params.insert((param.index, param.name));
+                return ControlFlow::Continue(());
+            }
+            ty.super_visit_with(self)
+        }
+
+        fn visit_region(&mut self, re: ty::Region<'tcx>) -> ControlFlow<Self::BreakTy> {
+            if let ty::ReEarlyParam(param) = re.kind() {
+                self.params.insert((param.index, param.name));
+                return ControlFlow::Continue(());
+            }
+            ControlFlow::Continue(())
+        }
+
+        fn visit_const(&mut self, ct: ty::Const<'tcx>) -> ControlFlow<Self::BreakTy> {
+            if let ty::ConstKind::Param(param) = ct.kind() {
+                self.params.insert((param.index, param.name));
+                return ControlFlow::Continue(());
+            }
+            ct.super_visit_with(self)
+        }
+    }
+
+    reported.unwrap_or_else(|| bug!("failed to find gen params in ty"))
+}
+
 fn get_path_containing_arg_in_pat<'hir>(
     pat: &'hir hir::Pat<'hir>,
     arg_id: HirId,

compiler/rustc_hir_analysis/src/errors.rs

@@ -254,6 +254,20 @@ pub struct AssocTypeBindingNotAllowed {
     pub fn_trait_expansion: Option<ParenthesizedFnTraitExpansion>,
 }
 
+#[derive(Diagnostic)]
+#[diag(hir_analysis_param_in_ty_of_assoc_const_binding)]
+pub(crate) struct ParamInTyOfAssocConstBinding {
+    #[primary_span]
+    #[label]
+    pub span: Span,
+    pub assoc_const: Ident,
+    pub param_name: Symbol,
+    pub param_def_kind: &'static str,
+    pub synthetic: bool,
+    #[label(hir_analysis_param_defined_here_label)]
+    pub param_defined_here_label: Span,
+}
+
 #[derive(Subdiagnostic)]
 #[help(hir_analysis_parenthesized_fn_trait_expansion)]
 pub struct ParenthesizedFnTraitExpansion {

tests/ui/associated-consts/assoc-const-eq-param-in-ty.rs

@@ -0,0 +1,34 @@
+// Regression test for issue #108271.
+// Detect and reject generic params in the type of assoc consts used in an equality bound.
+#![feature(associated_const_equality)]
+
+trait Trait<'a, T: 'a, const N: usize> {
+    const K: &'a [T; N];
+}
+
+fn take0<'r, A: 'r, const Q: usize>(_: impl Trait<'r, A, Q, K = { loop {} }>) {}
+//~^ ERROR the type of the associated constant `K` must not depend on generic parameters
+//~| NOTE its type must not depend on the lifetime parameter `'r`
+//~| NOTE the lifetime parameter `'r` is defined here
+//~| ERROR the type of the associated constant `K` must not depend on generic parameters
+//~| NOTE its type must not depend on the type parameter `A`
+//~| NOTE the type parameter `A` is defined here
+//~| ERROR the type of the associated constant `K` must not depend on generic parameters
+//~| NOTE its type must not depend on the const parameter `Q`
+//~| NOTE the const parameter `Q` is defined here
+
+trait Project {
+    const SELF: Self;
+}
+
+fn take1(_: impl Project<SELF = {}>) {}
+//~^ ERROR the type of the associated constant `SELF` must not depend on `impl Trait`
+//~| NOTE its type must not depend on `impl Trait`
+//~| NOTE the `impl Trait` is specified here
+
+fn take2<P: Project<SELF = {}>>(_: P) {}
+//~^ ERROR the type of the associated constant `SELF` must not depend on generic parameters
+//~| NOTE its type must not depend on the type parameter `P`
+//~| NOTE the type parameter `P` is defined here
+
+fn main() {}

tests/ui/associated-consts/assoc-const-eq-param-in-ty.stderr

@@ -0,0 +1,39 @@
+error: the type of the associated constant `K` must not depend on generic parameters
+  --> $DIR/assoc-const-eq-param-in-ty.rs:9:61
+   |
+LL | fn take0<'r, A: 'r, const Q: usize>(_: impl Trait<'r, A, Q, K = { loop {} }>) {}
+   |          -- the lifetime parameter `'r` is defined here     ^ its type must not depend on the lifetime parameter `'r`
+
+error: the type of the associated constant `K` must not depend on generic parameters
+  --> $DIR/assoc-const-eq-param-in-ty.rs:9:61
+   |
+LL | fn take0<'r, A: 'r, const Q: usize>(_: impl Trait<'r, A, Q, K = { loop {} }>) {}
+   |              - the type parameter `A` is defined here       ^ its type must not depend on the type parameter `A`
+
+error: the type of the associated constant `K` must not depend on generic parameters
+  --> $DIR/assoc-const-eq-param-in-ty.rs:9:61
+   |
+LL | fn take0<'r, A: 'r, const Q: usize>(_: impl Trait<'r, A, Q, K = { loop {} }>) {}
+   |                           -                                 ^ its type must not depend on the const parameter `Q`
+   |                           |
+   |                           the const parameter `Q` is defined here
+
+error: the type of the associated constant `SELF` must not depend on `impl Trait`
+  --> $DIR/assoc-const-eq-param-in-ty.rs:24:26
+   |
+LL | fn take1(_: impl Project<SELF = {}>) {}
+   |             -------------^^^^------
+   |             |            |
+   |             |            its type must not depend on `impl Trait`
+   |             the `impl Trait` is specified here
+
+error: the type of the associated constant `SELF` must not depend on generic parameters
+  --> $DIR/assoc-const-eq-param-in-ty.rs:29:21
+   |
+LL | fn take2<P: Project<SELF = {}>>(_: P) {}
+   |          -          ^^^^ its type must not depend on the type parameter `P`
+   |          |
+   |          the type parameter `P` is defined here
+
+error: aborting due to 5 previous errors
+