implement ast->hir and astconv for defaulted const params

Author: BoxyUwU

compiler/rustc_ast_lowering/src/index.rs

@@ -168,7 +168,7 @@ impl<'a, 'hir> Visitor<'hir> for NodeCollector<'a, 'hir> {
         intravisit::walk_generic_param(self, param);
     }
 
-    fn visit_const_param_default(&mut self, param: HirId, ct: &'hir AnonConst) {
+    fn visit_const_param_default(&mut self, param: HirId, ct: &'hir ConstArg<'hir>) {
         self.with_parent(param, |this| {
             intravisit::walk_const_param_default(this, ct);
         })

compiler/rustc_ast_lowering/src/lib.rs

@@ -2287,7 +2287,12 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                     &ty,
                     &ImplTraitContext::Disallowed(ImplTraitPosition::GenericDefault),
                 );
-                let default = default.as_ref().map(|def| self.lower_anon_const(def));
+                let default = default.as_ref().map(|def| {
+                    self.lower_const_arg(
+                        def,
+                        &ImplTraitContext::Disallowed(ImplTraitPosition::GenericDefault),
+                    )
+                });
                 (
                     hir::ParamName::Plain(self.lower_ident(param.ident)),
                     hir::GenericParamKind::Const { ty, default },

compiler/rustc_hir/src/hir.rs

@@ -522,7 +522,7 @@ pub enum GenericParamKind<'hir> {
     Const {
         ty: &'hir Ty<'hir>,
         /// Optional default value for the const generic param
-        default: Option<AnonConst>,
+        default: Option<&'hir ConstArg<'hir>>,
     },
 }
 

compiler/rustc_hir/src/intravisit.rs

@@ -350,7 +350,7 @@ pub trait Visitor<'v>: Sized {
     fn visit_generic_param(&mut self, p: &'v GenericParam<'v>) {
         walk_generic_param(self, p)
     }
-    fn visit_const_param_default(&mut self, _param: HirId, ct: &'v AnonConst) {
+    fn visit_const_param_default(&mut self, _param: HirId, ct: &'v ConstArg<'v>) {
         walk_const_param_default(self, ct)
     }
     fn visit_generics(&mut self, g: &'v Generics<'v>) {
@@ -877,8 +877,8 @@ pub fn walk_generic_param<'v, V: Visitor<'v>>(visitor: &mut V, param: &'v Generi
     }
 }
 
-pub fn walk_const_param_default<'v, V: Visitor<'v>>(visitor: &mut V, ct: &'v AnonConst) {
-    visitor.visit_anon_const(ct)
+pub fn walk_const_param_default<'v, V: Visitor<'v>>(visitor: &mut V, ct: &'v ConstArg<'v>) {
+    visitor.visit_const_arg(ct)
 }
 
 pub fn walk_generics<'v, V: Visitor<'v>>(visitor: &mut V, generics: &'v Generics<'v>) {

compiler/rustc_hir_analysis/src/collect.rs

@@ -77,6 +77,7 @@ pub fn provide(providers: &mut Providers) {
         generator_kind,
         collect_mod_item_types,
         is_type_alias_impl_trait,
+        const_param_default,
         ..*providers
     };
 }
@@ -291,7 +292,9 @@ impl<'tcx> Visitor<'tcx> for CollectItemTypesVisitor<'tcx> {
                     self.tcx.ensure().type_of(param.def_id);
                     if let Some(default) = default {
                         // need to store default and type of default
-                        self.tcx.ensure().type_of(default.def_id);
+                        if let hir::ConstArgKind::AnonConst(_, anon_ct) = default.kind {
+                            self.tcx.ensure().type_of(anon_ct.def_id);
+                        }
                         self.tcx.ensure().const_param_default(param.def_id);
                     }
                 }
@@ -1488,3 +1491,19 @@ fn is_type_alias_impl_trait<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> bool
         _ => bug!("tried getting opaque_ty_origin for non-opaque: {:?}", def_id),
     }
 }
+
+fn const_param_default(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::EarlyBinder<Const<'_>> {
+    let item_def_id = tcx.parent(def_id.to_def_id()).expect_local();
+    let item_ctxt = ItemCtxt::new(tcx, item_def_id);
+
+    match tcx.hir().get_by_def_id(def_id) {
+        hir::Node::GenericParam(hir::GenericParam {
+            kind: hir::GenericParamKind::Const { default: Some(ac), .. },
+            ..
+        }) => ty::EarlyBinder(item_ctxt.astconv().ast_const_to_const(ac, def_id.to_def_id())),
+        _ => span_bug!(
+            tcx.def_span(def_id),
+            "`const_param_default` expected a generic parameter with a constant"
+        ),
+    }
+}

compiler/rustc_hir_analysis/src/collect/predicates_of.rs

@@ -357,7 +357,7 @@ fn const_evaluatable_predicates_of(
             }
         }
 
-        fn visit_const_param_default(&mut self, _param: HirId, _ct: &'tcx hir::AnonConst) {
+        fn visit_const_param_default(&mut self, _param: HirId, _ct: &'tcx hir::ConstArg<'tcx>) {
             // Do not look into const param defaults,
             // these get checked when they are actually instantiated.
             //

compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs

@@ -918,8 +918,8 @@ impl<'a, 'tcx> Visitor<'tcx> for BoundVarContext<'a, 'tcx> {
                     }
                     GenericParamKind::Const { ty, default } => {
                         this.visit_ty(ty);
-                        if let Some(default) = default {
-                            this.visit_body(this.tcx.hir().body(default.body));
+                        if let Some(arg) = default { 
+                            this.visit_const_arg(arg);
                         }
                     }
                 }

compiler/rustc_hir_analysis/src/collect/type_of.rs

@@ -63,7 +63,7 @@ fn anon_const_type_of<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> Ty<'tcx> {
             def_id: param_def_id,
             kind: GenericParamKind::Const { default: Some(ct), .. },
             ..
-        }) if ct.hir_id == hir_id => {
+        }) if ct.hir_id() == hir_id => {
             return tcx.type_of(param_def_id)
                 .no_bound_vars()
                 .expect("const parameter types cannot be generic")

compiler/rustc_hir_pretty/src/lib.rs

@@ -2168,7 +2168,7 @@ impl<'a> State<'a> {
                 if let Some(default) = default {
                     self.space();
                     self.word_space("=");
-                    self.print_anon_const(default);
+                    self.print_const_arg(default);
                 }
             }
         }

compiler/rustc_middle/src/ty/consts.rs

@@ -218,17 +218,3 @@ impl<'tcx> Const<'tcx> {
         matches!(self.kind(), ty::ConstKind::Infer(_))
     }
 }
-
-pub fn const_param_default(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::EarlyBinder<Const<'_>> {
-    let default_def_id = match tcx.hir().get_by_def_id(def_id) {
-        hir::Node::GenericParam(hir::GenericParam {
-            kind: hir::GenericParamKind::Const { default: Some(ac), .. },
-            ..
-        }) => ac.def_id,
-        _ => span_bug!(
-            tcx.def_span(def_id),
-            "`const_param_default` expected a generic parameter with a constant"
-        ),
-    };
-    ty::EarlyBinder(Const::from_anon_const(tcx, default_def_id))
-}

compiler/rustc_middle/src/ty/mod.rs

@@ -2590,7 +2590,6 @@ pub fn provide(providers: &mut ty::query::Providers) {
     *providers = ty::query::Providers {
         trait_impls_of: trait_def::trait_impls_of_provider,
         incoherent_impls: trait_def::incoherent_impls_provider,
-        const_param_default: consts::const_param_default,
         vtable_allocation: vtable::vtable_allocation_provider,
         ..*providers
     };