Use ConstArg for const param defaults

camelid · camelid · commit 1c49d406b649 · 2024-07-16T19:27:28.000-07:00
Now everything that actually affects the type system (i.e., excluding
const blocks, enum variant discriminants, etc.) *should* be using
`ConstArg`.
diff --git a/compiler/rustc_ast_lowering/src/index.rs b/compiler/rustc_ast_lowering/src/index.rs
@@ -181,7 +181,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);
         })
diff --git a/compiler/rustc_ast_lowering/src/item.rs b/compiler/rustc_ast_lowering/src/item.rs
@@ -1601,15 +1601,15 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
         if let Some((span, hir_id, def_id)) = host_param_parts {
             let const_node_id = self.next_node_id();
-            let anon_const =
+            let anon_const_did =
                 self.create_def(def_id, const_node_id, kw::Empty, DefKind::AnonConst, span);
 
             let const_id = self.next_id();
             let const_expr_id = self.next_id();
             let bool_id = self.next_id();
 
             self.children.push((def_id, hir::MaybeOwner::NonOwner(hir_id)));
-            self.children.push((anon_const, hir::MaybeOwner::NonOwner(const_id)));
+            self.children.push((anon_const_did, hir::MaybeOwner::NonOwner(const_id)));
 
             let const_body = self.lower_body(|this| {
                 (
@@ -1624,6 +1624,16 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 )
             });
 
+            let default_ac = self.arena.alloc(hir::AnonConst {
+                def_id: anon_const_did,
+                hir_id: const_id,
+                body: const_body,
+                span,
+            });
+            let default_ct = self.arena.alloc(hir::ConstArg {
+                kind: hir::ConstArgKind::Anon(default_ac),
+                is_desugared_from_effects: true,
+            });
             let param = hir::GenericParam {
                 def_id,
                 hir_id,
@@ -1647,13 +1657,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                             }),
                         )),
                     )),
-                    // FIXME(effects) we might not need a default.
-                    default: Some(self.arena.alloc(hir::AnonConst {
-                        def_id: anon_const,
-                        hir_id: const_id,
-                        body: const_body,
-                        span,
-                    })),
+                    default: Some(default_ct),
                     is_host_effect: true,
                     synthetic: true,
                 },
diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
@@ -2204,7 +2204,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                             false
                         }
                     })
-                    .map(|def| self.lower_anon_const_to_anon_const(def));
+                    .map(|def| self.lower_anon_const_to_const_arg(def));
 
                 (
                     hir::ParamName::Plain(self.lower_ident(param.ident)),
diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs
@@ -548,7 +548,7 @@ pub enum GenericParamKind<'hir> {
     Const {
         ty: &'hir Ty<'hir>,
         /// Optional default value for the const generic param
-        default: Option<&'hir AnonConst>,
+        default: Option<&'hir ConstArg<'hir>>,
         is_host_effect: bool,
         synthetic: bool,
     },
diff --git a/compiler/rustc_hir/src/intravisit.rs b/compiler/rustc_hir/src/intravisit.rs
@@ -367,7 +367,7 @@ pub trait Visitor<'v>: Sized {
     fn visit_generic_param(&mut self, p: &'v GenericParam<'v>) -> Self::Result {
         walk_generic_param(self, p)
     }
-    fn visit_const_param_default(&mut self, _param: HirId, ct: &'v AnonConst) -> Self::Result {
+    fn visit_const_param_default(&mut self, _param: HirId, ct: &'v ConstArg<'v>) -> Self::Result {
         walk_const_param_default(self, ct)
     }
     fn visit_generics(&mut self, g: &'v Generics<'v>) -> Self::Result {
@@ -940,9 +940,9 @@ pub fn walk_generic_param<'v, V: Visitor<'v>>(
 
 pub fn walk_const_param_default<'v, V: Visitor<'v>>(
     visitor: &mut V,
-    ct: &'v AnonConst,
+    ct: &'v ConstArg<'v>,
 ) -> V::Result {
-    visitor.visit_anon_const(ct)
+    visitor.visit_const_arg(ct)
 }
 
 pub fn walk_generics<'v, V: Visitor<'v>>(visitor: &mut V, generics: &'v Generics<'v>) -> V::Result {
diff --git a/compiler/rustc_hir_analysis/src/collect.rs b/compiler/rustc_hir_analysis/src/collect.rs
@@ -304,7 +304,10 @@ 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);
+                        #[allow(irrefutable_let_patterns)] // FIXME
+                        if let hir::ConstArgKind::Anon(ac) = default.kind {
+                            self.tcx.ensure().type_of(ac.def_id);
+                        }
                         self.tcx.ensure().const_param_default(param.def_id);
                     }
                 }
diff --git a/compiler/rustc_hir_analysis/src/collect/predicates_of.rs b/compiler/rustc_hir_analysis/src/collect/predicates_of.rs
@@ -388,7 +388,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.
             //
diff --git a/compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs b/compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs
@@ -954,7 +954,7 @@ impl<'a, 'tcx> Visitor<'tcx> for BoundVarContext<'a, 'tcx> {
             GenericParamKind::Const { ty, default, .. } => {
                 self.visit_ty(ty);
                 if let Some(default) = default {
-                    self.visit_body(self.tcx.hir().body(default.body));
+                    self.visit_const_arg(default);
                 }
             }
         }
diff --git a/compiler/rustc_hir_analysis/src/collect/type_of.rs b/compiler/rustc_hir_analysis/src/collect/type_of.rs
@@ -73,7 +73,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.anon_const_hir_id() == hir_id => {
             return tcx
                 .type_of(param_def_id)
                 .no_bound_vars()
diff --git a/compiler/rustc_hir_pretty/src/lib.rs b/compiler/rustc_hir_pretty/src/lib.rs
@@ -2161,7 +2161,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);
                 }
             }
         }
diff --git a/compiler/rustc_middle/src/ty/consts.rs b/compiler/rustc_middle/src/ty/consts.rs
@@ -505,15 +505,15 @@ pub fn const_param_default<'tcx>(
     tcx: TyCtxt<'tcx>,
     def_id: LocalDefId,
 ) -> ty::EarlyBinder<'tcx, Const<'tcx>> {
-    let default_def_id = match tcx.hir_node_by_def_id(def_id) {
+    let default_ct = match tcx.hir_node_by_def_id(def_id) {
         hir::Node::GenericParam(hir::GenericParam {
-            kind: hir::GenericParamKind::Const { default: Some(ac), .. },
+            kind: hir::GenericParamKind::Const { default: Some(ct), .. },
             ..
-        }) => ac.def_id,
+        }) => ct,
         _ => span_bug!(
             tcx.def_span(def_id),
             "`const_param_default` expected a generic parameter with a constant"
         ),
     };
-    ty::EarlyBinder::bind(Const::from_anon_const(tcx, default_def_id))
+    ty::EarlyBinder::bind(Const::from_const_arg(tcx, default_ct, FeedConstTy::No))
 }
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
@@ -635,8 +635,9 @@ fn clean_generic_param<'tcx>(
             param.name.ident().name,
             GenericParamDefKind::Const {
                 ty: Box::new(clean_ty(ty, cx)),
-                default: default
-                    .map(|ct| Box::new(ty::Const::from_anon_const(cx.tcx, ct.def_id).to_string())),
+                default: default.map(|ct| {
+                    Box::new(ty::Const::from_const_arg(cx.tcx, ct, ty::FeedConstTy::No).to_string())
+                }),
                 synthetic,
             },
         ),

Original file line number	Diff line number	Diff line change
`@@ -181,7 +181,7 @@ impl<'a, 'hir> Visitor<'hir> for NodeCollector<'a, 'hir> {`
`181`	`181`	`intravisit::walk_generic_param(self, param);`
`182`	`182`	`}`
`183`	`183`
`184`		`- fn visit_const_param_default(&mut self, param: HirId, ct: &'hir AnonConst) {`
	`184`	`+ fn visit_const_param_default(&mut self, param: HirId, ct: &'hir ConstArg<'hir>) {`
`185`	`185`	`self.with_parent(param, \|this\| {`
`186`	`186`	`intravisit::walk_const_param_default(this, ct);`
`187`	`187`	`})`
Original file line number	Diff line number	Diff line change
`@@ -2204,7 +2204,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {`
`2204`	`2204`	`false`
`2205`	`2205`	`}`
`2206`	`2206`	`})`
`2207`		`- .map(\|def\| self.lower_anon_const_to_anon_const(def));`
	`2207`	`+ .map(\|def\| self.lower_anon_const_to_const_arg(def));`
`2208`	`2208`
`2209`	`2209`	`(`
`2210`	`2210`	`hir::ParamName::Plain(self.lower_ident(param.ident)),`
Original file line number	Diff line number	Diff line change
`@@ -367,7 +367,7 @@ pub trait Visitor<'v>: Sized {`
`367`	`367`	`fn visit_generic_param(&mut self, p: &'v GenericParam<'v>) -> Self::Result {`
`368`	`368`	`walk_generic_param(self, p)`
`369`	`369`	`}`
`370`		`- fn visit_const_param_default(&mut self, _param: HirId, ct: &'v AnonConst) -> Self::Result {`
	`370`	`+ fn visit_const_param_default(&mut self, _param: HirId, ct: &'v ConstArg<'v>) -> Self::Result {`
`371`	`371`	`walk_const_param_default(self, ct)`
`372`	`372`	`}`
`373`	`373`	`fn visit_generics(&mut self, g: &'v Generics<'v>) -> Self::Result {`
`@@ -940,9 +940,9 @@ pub fn walk_generic_param<'v, V: Visitor<'v>>(`
`940`	`940`
`941`	`941`	`pub fn walk_const_param_default<'v, V: Visitor<'v>>(`
`942`	`942`	`visitor: &mut V,`
`943`		`- ct: &'v AnonConst,`
	`943`	`+ ct: &'v ConstArg<'v>,`
`944`	`944`	`) -> V::Result {`
`945`		`- visitor.visit_anon_const(ct)`
	`945`	`+ visitor.visit_const_arg(ct)`
`946`	`946`	`}`
`947`	`947`
`948`	`948`	`pub fn walk_generics<'v, V: Visitor<'v>>(visitor: &mut V, generics: &'v Generics<'v>) -> V::Result {`
Original file line number	Diff line number	Diff line change
`@@ -304,7 +304,10 @@ impl<'tcx> Visitor<'tcx> for CollectItemTypesVisitor<'tcx> {`
`304`	`304`	`self.tcx.ensure().type_of(param.def_id);`
`305`	`305`	`if let Some(default) = default {`
`306`	`306`	`// need to store default and type of default`
`307`		`- self.tcx.ensure().type_of(default.def_id);`
	`307`	`+ #[allow(irrefutable_let_patterns)] // FIXME`
	`308`	`+ if let hir::ConstArgKind::Anon(ac) = default.kind {`
	`309`	`+ self.tcx.ensure().type_of(ac.def_id);`
	`310`	`+ }`
`308`	`311`	`self.tcx.ensure().const_param_default(param.def_id);`
`309`	`312`	`}`
`310`	`313`	`}`
Original file line number	Diff line number	Diff line change
`@@ -388,7 +388,7 @@ fn const_evaluatable_predicates_of(`
`388`	`388`	`}`
`389`	`389`	`}`
`390`	`390`
`391`		`- fn visit_const_param_default(&mut self, _param: HirId, _ct: &'tcx hir::AnonConst) {`
	`391`	`+ fn visit_const_param_default(&mut self, _param: HirId, _ct: &'tcx hir::ConstArg<'tcx>) {`
`392`	`392`	`// Do not look into const param defaults,`
`393`	`393`	`// these get checked when they are actually instantiated.`
`394`	`394`	`//`
Original file line number	Diff line number	Diff line change
`@@ -954,7 +954,7 @@ impl<'a, 'tcx> Visitor<'tcx> for BoundVarContext<'a, 'tcx> {`
`954`	`954`	`GenericParamKind::Const { ty, default, .. } => {`
`955`	`955`	`self.visit_ty(ty);`
`956`	`956`	`if let Some(default) = default {`
`957`		`- self.visit_body(self.tcx.hir().body(default.body));`
	`957`	`+ self.visit_const_arg(default);`
`958`	`958`	`}`
`959`	`959`	`}`
`960`	`960`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2161,7 +2161,7 @@ impl<'a> State<'a> {`
`2161`	`2161`	`if let Some(default) = default {`
`2162`	`2162`	`self.space();`
`2163`	`2163`	`self.word_space("=");`
`2164`		`- self.print_anon_const(default);`
	`2164`	`+ self.print_const_arg(default);`
`2165`	`2165`	`}`
`2166`	`2166`	`}`
`2167`	`2167`	`}`