Add has_default to GenericParamDefKind::Const

This currently creates a field which is always false on GenericParamDefKind for future use when
consts are permitted to have defaults

Update const_generics:default locations

Previously just ignored them, now actually do something about them.

Fix using type check instead of value

Add parsing

This adds all the necessary changes to lower const-generics defaults from parsing.

Change P<Expr> to AnonConst

This matches the arguments passed to instantiations of const generics, and makes it specific to
just anonymous constants.

Attempt to fix lowering bugs

Author: JulianKnodt

compiler/rustc_ast/src/ast.rs

@@ -368,6 +368,7 @@ pub enum GenericParamKind {
         ty: P<Ty>,
         /// Span of the `const` keyword.
         kw_span: Span,
+        default: Option<AnonConst>,
     },
 }
 

compiler/rustc_ast/src/mut_visit.rs

@@ -790,7 +790,8 @@ pub fn noop_flat_map_generic_param<T: MutVisitor>(
         GenericParamKind::Type { default } => {
             visit_opt(default, |default| vis.visit_ty(default));
         }
-        GenericParamKind::Const { ty, kw_span: _ } => {
+        GenericParamKind::Const { ty, kw_span: _, default } => {
+            visit_opt(default, |default| vis.visit_anon_const(default));
             vis.visit_ty(ty);
         }
     }

compiler/rustc_ast/src/visit.rs

@@ -578,7 +578,12 @@ pub fn walk_generic_param<'a, V: Visitor<'a>>(visitor: &mut V, param: &'a Generi
     match param.kind {
         GenericParamKind::Lifetime => (),
         GenericParamKind::Type { ref default } => walk_list!(visitor, visit_ty, default),
-        GenericParamKind::Const { ref ty, .. } => visitor.visit_ty(ty),
+        GenericParamKind::Const { ref ty, ref default, .. } => {
+            if let Some(default) = default {
+                visitor.visit_anon_const(default);
+            }
+            visitor.visit_ty(ty);
+        }
     }
 }
 

compiler/rustc_ast_lowering/src/lib.rs

@@ -2242,13 +2242,15 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
 
                 (hir::ParamName::Plain(param.ident), kind)
             }
-            GenericParamKind::Const { ref ty, kw_span: _ } => {
+            GenericParamKind::Const { ref ty, kw_span: _, ref default } => {
                 let ty = self
                     .with_anonymous_lifetime_mode(AnonymousLifetimeMode::ReportError, |this| {
                         this.lower_ty(&ty, ImplTraitContext::disallowed())
                     });
 
-                (hir::ParamName::Plain(param.ident), hir::GenericParamKind::Const { ty })
+                let default = default.as_ref().map(|def| self.lower_anon_const(def));
+
+                (hir::ParamName::Plain(param.ident), hir::GenericParamKind::Const { ty, default })
             }
         };
 

compiler/rustc_ast_passes/src/ast_validation.rs

@@ -1145,6 +1145,17 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
                     }
                 }
             }
+            if !self.session.features_untracked().const_generic_defaults {
+                if let GenericParamKind::Const { default: Some(ref default), .. } = param.kind {
+                    let mut err = self.err_handler().struct_span_err(
+                        default.value.span,
+                        "default values for const generic parameters are unstable",
+                    );
+                    err.note("to enable them use #![feature(const_generic_defaults)]");
+                    err.emit();
+                    break;
+                }
+            }
         }
 
         validate_generic_param_order(
@@ -1155,7 +1166,7 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
                 let (kind, ident) = match &param.kind {
                     GenericParamKind::Lifetime => (ParamKindOrd::Lifetime, ident),
                     GenericParamKind::Type { default: _ } => (ParamKindOrd::Type, ident),
-                    GenericParamKind::Const { ref ty, kw_span: _ } => {
+                    GenericParamKind::Const { ref ty, kw_span: _, default: _ } => {
                         let ty = pprust::ty_to_string(ty);
                         let unordered = self.session.features_untracked().const_generics;
                         (

compiler/rustc_ast_pretty/src/pprust/state.rs

@@ -2668,13 +2668,18 @@ impl<'a> State<'a> {
                         s.print_type(default)
                     }
                 }
-                ast::GenericParamKind::Const { ref ty, kw_span: _ } => {
+                ast::GenericParamKind::Const { ref ty, kw_span: _, ref default } => {
                     s.word_space("const");
                     s.print_ident(param.ident);
                     s.s.space();
                     s.word_space(":");
                     s.print_type(ty);
-                    s.print_type_bounds(":", &param.bounds)
+                    s.print_type_bounds(":", &param.bounds);
+                    if let Some(ref _default) = default {
+                        s.s.space();
+                        s.word_space("=");
+                        // s.print_anon_const(&default);
+                    }
                 }
             }
         });

compiler/rustc_builtin_macros/src/deriving/mod.rs

@@ -145,7 +145,8 @@ fn inject_impl_of_structural_trait(
                 *default = None;
                 ast::GenericArg::Type(cx.ty_ident(span, param.ident))
             }
-            ast::GenericParamKind::Const { ty: _, kw_span: _ } => {
+            ast::GenericParamKind::Const { ty: _, kw_span: _, default } => {
+                *default = None;
                 ast::GenericArg::Const(cx.const_ident(span, param.ident))
             }
         })

compiler/rustc_feature/src/active.rs

@@ -620,6 +620,9 @@ declare_features! (
     /// Allows arbitrary expressions in key-value attributes at parse time.
     (active, extended_key_value_attributes, "1.50.0", Some(78835), None),
 
+    /// Allows defaults const generics (e.g. `struct Foo<const N: usize = 3>(...);`).
+    (active, const_generic_defaults, "1.51.0", Some(44580), None),
+
     // -------------------------------------------------------------------------
     // feature-group-end: actual feature gates
     // -------------------------------------------------------------------------

compiler/rustc_hir/src/hir.rs

@@ -418,6 +418,7 @@ pub enum GenericParamKind<'hir> {
     },
     Const {
         ty: &'hir Ty<'hir>,
+        default: Option<AnonConst>,
     },
 }
 

compiler/rustc_hir/src/intravisit.rs

@@ -877,7 +877,12 @@ pub fn walk_generic_param<'v, V: Visitor<'v>>(visitor: &mut V, param: &'v Generi
     match param.kind {
         GenericParamKind::Lifetime { .. } => {}
         GenericParamKind::Type { ref default, .. } => walk_list!(visitor, visit_ty, default),
-        GenericParamKind::Const { ref ty } => visitor.visit_ty(ty),
+        GenericParamKind::Const { ref ty, ref default } => {
+            visitor.visit_ty(ty);
+            if let Some(ref default) = default {
+                visitor.visit_anon_const(default);
+            }
+        }
     }
     walk_list!(visitor, visit_param_bound, param.bounds);
 }