Change:
A clean project with this code: Produces this error:
cc (const generics) (qualification)
I think this is possibly down to not being implemented.
cc You may want to consider this as part of the work on .
Same as , the compiler still crashes with brackets:
I don't understand, how was this fixed without running into ? Special-casing a const generic param as an array length expression? Then why do I still see the array length expression that depends on a const generic param in , causing the telltale signs of , via ICE?
I think that a full fix for this would involve adding to this (i.e. the fix for ) but only if the workaround applies (because in that case, the cyclic issues of shouldn't trigger)

Discussion:
result_ty } <ins> /// Returns the `DefId` of the constant parameter that the provided expression is a path to. pub fn const_param_def_id(&self, expr: &hir::Expr) -> Option<DefId> { match &expr.node { ExprKind::Path(hir::QPath::Resolved(_, path)) => match path.res { Res::Def(DefKind::ConstParam, did) => Some(did), _ => None, }, _ => None, } } </ins> pub fn ast_const_to_const( &self, ast_const: &hir::AnonConst,

} } <del> if let ExprKind::Path(ref qpath) = expr.node { if let hir::QPath::Resolved(_, ref path) = qpath { if let Res::Def(DefKind::ConstParam, def_id) = path.res { let node_id = tcx.hir().as_local_node_id(def_id).unwrap(); let item_id = tcx.hir().get_parent_node(node_id); let item_def_id = tcx.hir().local_def_id(item_id); let generics = tcx.generics_of(item_def_id); let index = generics.param_def_id_to_index[&tcx.hir().local_def_id(node_id)]; let name = tcx.hir().name(node_id).as_interned_str(); const_.val = ConstValue::Param(ty::ParamConst::new(index, name)); } } }; </del> <ins> if let Some(def_id) = self.const_param_def_id(expr) { // Find the name and index of the const parameter by indexing the generics of the // parent item and construct a `ParamConst`. let node_id = tcx.hir().as_local_node_id(def_id).unwrap(); let item_id = tcx.hir().get_parent_node(node_id); let item_def_id = tcx.hir().local_def_id(item_id); let generics = tcx.generics_of(item_def_id); let index = generics.param_def_id_to_index[&tcx.hir().local_def_id(node_id)]; let name = tcx.hir().name(node_id).as_interned_str(); const_.val = ConstValue::Param(ty::ParamConst::new(index, name)); } </ins> tcx.mk_const(const_) }

ty } <ins> /// Returns the `DefId` of the constant parameter that the provided expression is a path to. pub fn const_param_def_id(&self, hir_c: &hir::AnonConst) -> Option<DefId> { AstConv::const_param_def_id(self, &self.tcx.hir().body(hir_c.body).value) } </ins> pub fn to_const(&self, ast_c: &hir::AnonConst, ty: Ty<'tcx>) -> &'tcx ty::Const<'tcx> { AstConv::ast_const_to_const(self, ast_c, ty) }

} ExprKind::Repeat(ref element, ref count) => { let count_def_id = tcx.hir().local_def_id_from_hir_id(count.hir_id); <del> let param_env = ty::ParamEnv::empty(); let substs = InternalSubsts::identity_for_item(tcx.global_tcx(), count_def_id); let instance = ty::Instance::resolve( tcx.global_tcx(), param_env, count_def_id, substs, ).unwrap(); let global_id = GlobalId { instance, promoted: None </del> <ins> let count = if self.const_param_def_id(count).is_some() { Ok(self.to_const(count, self.tcx.type_of(count_def_id))) } else { let param_env = ty::ParamEnv::empty(); let substs = InternalSubsts::identity_for_item(tcx.global_tcx(), count_def_id); let instance = ty::Instance::resolve( tcx.global_tcx(), param_env, count_def_id, substs, ).unwrap(); let global_id = GlobalId { instance, promoted: None }; tcx.const_eval(param_env.and(global_id)) </ins> }; <del> let count = tcx.const_eval(param_env.and(global_id)); </del> let uty = match expected { ExpectHasType(uty) => {

<ins> #![feature(const_generics)] //~^ WARN the feature `const_generics` is incomplete and may cause the compiler to crash fn f<T: Copy, const N: usize>(x: T) -> [T; N] { [x; N] //~^ ERROR array lengths can't depend on generic parameters } fn main() { let x: [u32; 5] = f::<u32, 5>(3); assert_eq!(x, [3u32; 5]); } </ins>

<ins> warning: the feature `const_generics` is incomplete and may cause the compiler to crash --> $DIR/issue-61336-1.rs:1:12 | LL | #![feature(const_generics)] |            ^^^^^^^^^^^^^^ error: array lengths can't depend on generic parameters --> $DIR/issue-61336-1.rs:5:9 | LL |     [x; N] |         ^ error: aborting due to previous error </ins>

<ins> #![feature(const_generics)] //~^ WARN the feature `const_generics` is incomplete and may cause the compiler to crash fn f<T: Copy, const N: usize>(x: T) -> [T; N] { [x; N] } fn g<T, const N: usize>(x: T) -> [T; N] { [x; N] //~^ ERROR the trait bound `T: std::marker::Copy` is not satisfied [E0277] } fn main() { let x: [u32; 5] = f::<u32, 5>(3); assert_eq!(x, [3u32; 5]); } </ins>

<ins> warning: the feature `const_generics` is incomplete and may cause the compiler to crash --> $DIR/issue-61336.rs:1:12 | LL | #![feature(const_generics)] |            ^^^^^^^^^^^^^^ error[E0277]: the trait bound `T: std::marker::Copy` is not satisfied --> $DIR/issue-61336.rs:9:5 | LL |     [x; N] |     ^^^^^^ the trait `std::marker::Copy` is not implemented for `T` | = help: consider adding a `where T: std::marker::Copy` bound = note: the `Copy` trait is required because the repeated element will be copied error: aborting due to previous error For more information about this error, try `rustc --explain E0277`. </ins>