Reject escaping bound vars in the type of assoc const bindings

Author: fmease

compiler/rustc_hir_analysis/messages.ftl

@@ -122,6 +122,11 @@ hir_analysis_enum_discriminant_overflowed = enum discriminant overflowed
     .label = overflowed on value after {$discr}
     .note = explicitly set `{$item_name} = {$wrapped_discr}` if that is desired outcome
 
+hir_analysis_escaping_bound_var_in_ty_of_assoc_const_binding =
+    the type of the associated constant `{$assoc_const}` cannot capture late-bound generic parameters
+    .label = its type cannot capture the late-bound {$var_def_kind} `{$var_name}`
+    .var_defined_here_label = the late-bound {$var_def_kind} `{$var_name}` is defined here
+
 hir_analysis_field_already_declared =
     field `{$field_name}` is already declared
     .label = field already declared

compiler/rustc_hir_analysis/src/collect/type_of.rs

@@ -71,22 +71,17 @@ fn anon_const_type_of<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> Ty<'tcx> {
         }
 
         Node::TypeBinding(&TypeBinding { hir_id, ident, .. }) => {
-            let ty = tcx.type_of_assoc_const_binding(hir_id);
+            let ty = tcx.type_of_assoc_const_binding(hir_id).skip_binder().skip_binder();
 
             // 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,
-                );
+            if ty.has_param() || ty.has_escaping_bound_vars() {
+                let reported =
+                    report_overly_generic_assoc_const_binding_type(tcx, ident, ty, hir_id);
                 return Ty::new_error(tcx, reported);
             };
 
-            // FIXME(fmease): Reject escaping late-bound vars.
-            return ty.skip_binder();
+            return ty;
         }
 
         // This match arm is for when the def_id appears in a GAT whose
@@ -316,8 +311,15 @@ fn report_overly_generic_assoc_const_binding_type<'tcx>(
     ty: Ty<'tcx>,
     hir_id: HirId,
 ) -> ErrorGuaranteed {
-    let mut collector = GenericParamCollector { params: Default::default() };
-    ty.visit_with(&mut collector);
+    let mut collector = GenericParamAndBoundVarCollector {
+        tcx,
+        params: Default::default(),
+        vars: Default::default(),
+        depth: ty::INNERMOST,
+    };
+    if let ControlFlow::Break(reported) = ty.visit_with(&mut collector) {
+        return reported;
+    }
 
     let mut reported = None;
 
@@ -334,40 +336,101 @@ fn report_overly_generic_assoc_const_binding_type<'tcx>(
             param_defined_here_label: tcx.def_ident_span(param_def.def_id).unwrap(),
         }));
     }
+    for (var_def_id, var_name) in collector.vars {
+        reported.get_or_insert(tcx.dcx().emit_err(
+            crate::errors::EscapingBoundVarInTyOfAssocConstBinding {
+                span: assoc_const.span,
+                assoc_const,
+                var_name,
+                var_def_kind: tcx.def_descr(var_def_id),
+                var_defined_here_label: tcx.def_ident_span(var_def_id).unwrap(),
+            },
+        ));
+    }
 
-    struct GenericParamCollector {
+    struct GenericParamAndBoundVarCollector<'tcx> {
+        tcx: TyCtxt<'tcx>,
         params: FxIndexSet<(u32, Symbol)>,
+        vars: FxIndexSet<(DefId, Symbol)>,
+        depth: ty::DebruijnIndex,
     }
 
-    impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for GenericParamCollector {
-        type BreakTy = !;
+    impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for GenericParamAndBoundVarCollector<'tcx> {
+        type BreakTy = ErrorGuaranteed;
+
+        fn visit_binder<T: TypeVisitable<TyCtxt<'tcx>>>(
+            &mut self,
+            binder: &ty::Binder<'tcx, T>,
+        ) -> ControlFlow<Self::BreakTy> {
+            self.depth.shift_in(1);
+            let binder = binder.super_visit_with(self);
+            self.depth.shift_out(1);
+            binder
+        }
 
         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(());
+            match ty.kind() {
+                ty::Param(param) => {
+                    self.params.insert((param.index, param.name));
+                }
+                ty::Bound(db, bt) if *db >= self.depth => {
+                    self.vars.insert(match bt.kind {
+                        ty::BoundTyKind::Param(def_id, name) => (def_id, name),
+                        ty::BoundTyKind::Anon => {
+                            let reported = self.tcx.dcx().span_delayed_bug(
+                                DUMMY_SP,
+                                format!("unexpected anon bound ty: {:?}", bt.var),
+                            );
+                            return ControlFlow::Break(reported);
+                        }
+                    });
+                }
+                _ => return ty.super_visit_with(self),
             }
-            ty.super_visit_with(self)
+            ControlFlow::Continue(())
         }
 
         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(());
+            match re.kind() {
+                ty::ReEarlyParam(param) => {
+                    self.params.insert((param.index, param.name));
+                }
+                ty::ReBound(db, br) if db >= self.depth => {
+                    self.vars.insert(match br.kind {
+                        ty::BrNamed(def_id, name) => (def_id, name),
+                        ty::BrAnon | ty::BrEnv => {
+                            let reported = self.tcx.dcx().span_delayed_bug(
+                                DUMMY_SP,
+                                format!("unexpected bound region kind: {:?}", br.kind),
+                            );
+                            return ControlFlow::Break(reported);
+                        }
+                    });
+                }
+                _ => {}
             }
             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(());
+            match ct.kind() {
+                ty::ConstKind::Param(param) => {
+                    self.params.insert((param.index, param.name));
+                    ControlFlow::Continue(())
+                }
+                ty::ConstKind::Bound(db, ty::BoundVar { .. }) if db >= self.depth => {
+                    let reported = self.tcx.dcx().span_delayed_bug(
+                        DUMMY_SP,
+                        "late-bound const params are not supported yet",
+                    );
+                    ControlFlow::Break(reported)
+                }
+                _ => ct.super_visit_with(self),
             }
-            ct.super_visit_with(self)
         }
     }
 
-    reported.unwrap_or_else(|| bug!("failed to find gen params in ty"))
+    reported.unwrap_or_else(|| bug!("failed to find gen params or bound vars in ty"))
 }
 
 fn get_path_containing_arg_in_pat<'hir>(

compiler/rustc_hir_analysis/src/errors.rs

@@ -268,6 +268,19 @@ pub(crate) struct ParamInTyOfAssocConstBinding {
     pub param_defined_here_label: Span,
 }
 
+#[derive(Diagnostic)]
+#[diag(hir_analysis_escaping_bound_var_in_ty_of_assoc_const_binding)]
+pub(crate) struct EscapingBoundVarInTyOfAssocConstBinding {
+    #[primary_span]
+    #[label]
+    pub span: Span,
+    pub assoc_const: Ident,
+    pub var_name: Symbol,
+    pub var_def_kind: &'static str,
+    #[label(hir_analysis_var_defined_here_label)]
+    pub var_defined_here_label: Span,
+}
+
 #[derive(Subdiagnostic)]
 #[help(hir_analysis_parenthesized_fn_trait_expansion)]
 pub struct ParenthesizedFnTraitExpansion {

tests/ui/associated-consts/assoc-const-eq-esc-bound-var-in-ty.rs

@@ -0,0 +1,14 @@
+// Detect and reject escaping late-bound generic params in
+// the type of assoc consts used in an equality bound.
+#![feature(associated_const_equality)]
+
+trait Trait<'a> {
+    const K: &'a ();
+}
+
+fn take(_: impl for<'r> Trait<'r, K = { &() }>) {}
+//~^ ERROR the type of the associated constant `K` cannot capture late-bound generic parameters
+//~| NOTE its type cannot capture the late-bound lifetime parameter `'r`
+//~| NOTE the late-bound lifetime parameter `'r` is defined here
+
+fn main() {}

tests/ui/associated-consts/assoc-const-eq-esc-bound-var-in-ty.stderr

@@ -0,0 +1,10 @@
+error: the type of the associated constant `K` cannot capture late-bound generic parameters
+  --> $DIR/assoc-const-eq-esc-bound-var-in-ty.rs:9:35
+   |
+LL | fn take(_: impl for<'r> Trait<'r, K = { &() }>) {}
+   |                     --            ^ its type cannot capture the late-bound lifetime parameter `'r`
+   |                     |
+   |                     the late-bound lifetime parameter `'r` is defined here
+
+error: aborting due to 1 previous error
+