first pass at default values for const generics

JulianKnodt · lqd · commit 61f33bfd2940 · 2021-01-01T10:55:10.000+01:00
- Adds optional default values to const generic parameters in the AST
  and HIR
- Parses these optional default values
- Adds a `const_generics_defaults` feature gate
diff --git a/compiler/rustc_ast/src/ast.rs b/compiler/rustc_ast/src/ast.rs
@@ -368,6 +368,8 @@ pub enum GenericParamKind {
         ty: P<Ty>,
         /// Span of the `const` keyword.
         kw_span: Span,
+        /// Optional default value for the const generic param
+        default: Option<AnonConst>,
     },
 }
 
diff --git a/compiler/rustc_ast/src/mut_visit.rs b/compiler/rustc_ast/src/mut_visit.rs
@@ -790,8 +790,9 @@ 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 } => {
             vis.visit_ty(ty);
+            visit_opt(default, |default| vis.visit_anon_const(default));
         }
     }
     smallvec![param]
diff --git a/compiler/rustc_ast/src/visit.rs b/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, .. } => {
+            visitor.visit_ty(ty);
+            if let Some(default) = default {
+                visitor.visit_anon_const(default);
+            }
+        }
     }
 }
 
diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
@@ -2242,13 +2242,14 @@ 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())
                     });
+                let default = default.as_ref().map(|def| self.lower_anon_const(def));
 
-                (hir::ParamName::Plain(param.ident), hir::GenericParamKind::Const { ty })
+                (hir::ParamName::Plain(param.ident), hir::GenericParamKind::Const { ty, default })
             }
         };
 
diff --git a/compiler/rustc_ast_passes/src/ast_validation.rs b/compiler/rustc_ast_passes/src/ast_validation.rs
@@ -733,7 +733,7 @@ fn validate_generic_param_order(
         let (ord_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 = sess.features_untracked().const_generics;
                 (ParamKindOrd::Const { unordered }, Some(format!("const {}: {}", param.ident, ty)))
@@ -775,7 +775,7 @@ fn validate_generic_param_order(
                 GenericParamKind::Type { default: None } => (),
                 GenericParamKind::Lifetime => (),
                 // FIXME(const_generics:defaults)
-                GenericParamKind::Const { ty: _, kw_span: _ } => (),
+                GenericParamKind::Const { ty: _, kw_span: _, default: _ } => (),
             }
             first = false;
         }
@@ -1166,6 +1166,20 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
                     }
                 }
             }
+            if !self.session.features_untracked().const_generics_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.help(
+                        "add `#![feature(const_generics_defaults)]` \
+                         to the crate attributes to enable",
+                    );
+                    err.emit();
+                    break;
+                }
+            }
         }
 
         validate_generic_param_order(
diff --git a/compiler/rustc_ast_pretty/src/pprust/state.rs b/compiler/rustc_ast_pretty/src/pprust/state.rs
@@ -2668,13 +2668,17 @@ 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 {
+                        // FIXME(const_generics_defaults): print the `default` value here
+                        todo!();
+                    }
                 }
             }
         });
diff --git a/compiler/rustc_builtin_macros/src/deriving/mod.rs b/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))
             }
         })
diff --git a/compiler/rustc_feature/src/active.rs b/compiler/rustc_feature/src/active.rs
@@ -623,6 +623,9 @@ declare_features! (
     /// `:pat2018` and `:pat2021` macro matchers.
     (active, edition_macro_pats, "1.51.0", Some(54883), None),
 
+    /// Allows const generics to have default values (e.g. `struct Foo<const N: usize = 3>(...);`).
+    (active, const_generics_defaults, "1.51.0", Some(44580), None),
+
     // -------------------------------------------------------------------------
     // feature-group-end: actual feature gates
     // -------------------------------------------------------------------------
diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs
@@ -418,6 +418,8 @@ pub enum GenericParamKind<'hir> {
     },
     Const {
         ty: &'hir Ty<'hir>,
+        /// Optional default value for the const generic param
+        default: Option<AnonConst>,
     },
 }
 
diff --git a/compiler/rustc_hir/src/intravisit.rs b/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);
 }
diff --git a/compiler/rustc_hir_pretty/src/lib.rs b/compiler/rustc_hir_pretty/src/lib.rs
@@ -2205,9 +2205,13 @@ impl<'a> State<'a> {
                     self.print_type(&default)
                 }
             }
-            GenericParamKind::Const { ref ty } => {
+            GenericParamKind::Const { ref ty, ref default } => {
                 self.word_space(":");
-                self.print_type(ty)
+                self.print_type(ty);
+                if let Some(ref _default) = default {
+                    // FIXME(const_generics_defaults): print the `default` value here
+                    todo!();
+                }
             }
         }
     }
diff --git a/compiler/rustc_parse/src/parser/generics.rs b/compiler/rustc_parse/src/parser/generics.rs
@@ -56,12 +56,15 @@ impl<'a> Parser<'a> {
         self.expect(&token::Colon)?;
         let ty = self.parse_ty()?;
 
+        // Parse optional const generics default value.
+        let default = if self.eat(&token::Eq) { Some(self.parse_const_arg()?) } else { None };
+
         Ok(GenericParam {
             ident,
             id: ast::DUMMY_NODE_ID,
             attrs: preceding_attrs.into(),
             bounds: Vec::new(),
-            kind: GenericParamKind::Const { ty, kw_span: const_span },
+            kind: GenericParamKind::Const { ty, kw_span: const_span, default },
             is_placeholder: false,
         })
     }
diff --git a/compiler/rustc_parse/src/parser/path.rs b/compiler/rustc_parse/src/parser/path.rs
@@ -515,6 +515,23 @@ impl<'a> Parser<'a> {
         }
     }
 
+    /// Parse a const argument, e.g. `<3>`. It is assumed the angle brackets will be parsed by
+    /// the caller.
+    pub(super) fn parse_const_arg(&mut self) -> PResult<'a, AnonConst> {
+        // Parse const argument.
+        let value = if let token::OpenDelim(token::Brace) = self.token.kind {
+            self.parse_block_expr(
+                None,
+                self.token.span,
+                BlockCheckMode::Default,
+                ast::AttrVec::new(),
+            )?
+        } else {
+            self.handle_unambiguous_unbraced_const_arg()?
+        };
+        Ok(AnonConst { id: ast::DUMMY_NODE_ID, value })
+    }
+
     /// Parse a generic argument in a path segment.
     /// This does not include constraints, e.g., `Item = u8`, which is handled in `parse_angle_arg`.
     fn parse_generic_arg(&mut self) -> PResult<'a, Option<GenericArg>> {
@@ -524,17 +541,7 @@ impl<'a> Parser<'a> {
             GenericArg::Lifetime(self.expect_lifetime())
         } else if self.check_const_arg() {
             // Parse const argument.
-            let value = if let token::OpenDelim(token::Brace) = self.token.kind {
-                self.parse_block_expr(
-                    None,
-                    self.token.span,
-                    BlockCheckMode::Default,
-                    ast::AttrVec::new(),
-                )?
-            } else {
-                self.handle_unambiguous_unbraced_const_arg()?
-            };
-            GenericArg::Const(AnonConst { id: ast::DUMMY_NODE_ID, value })
+            GenericArg::Const(self.parse_const_arg()?)
         } else if self.check_type() {
             // Parse type argument.
             match self.parse_ty() {
diff --git a/compiler/rustc_resolve/src/late.rs b/compiler/rustc_resolve/src/late.rs
@@ -586,7 +586,8 @@ impl<'a: 'ast, 'ast> Visitor<'ast> for LateResolutionVisitor<'a, '_, 'ast> {
                     // Allow all following defaults to refer to this type parameter.
                     default_ban_rib.bindings.remove(&Ident::with_dummy_span(param.ident.name));
                 }
-                GenericParamKind::Const { ref ty, kw_span: _ } => {
+                GenericParamKind::Const { ref ty, kw_span: _, default: _ } => {
+                    // FIXME(const_generics_defaults): handle `default` value here
                     for bound in &param.bounds {
                         self.visit_param_bound(bound);
                     }
diff --git a/compiler/rustc_save_analysis/src/dump_visitor.rs b/compiler/rustc_save_analysis/src/dump_visitor.rs
@@ -1343,9 +1343,12 @@ impl<'tcx> Visitor<'tcx> for DumpVisitor<'tcx> {
                         self.visit_ty(ty);
                     }
                 }
-                hir::GenericParamKind::Const { ref ty } => {
+                hir::GenericParamKind::Const { ref ty, ref default } => {
                     self.process_bounds(param.bounds);
                     self.visit_ty(ty);
+                    if let Some(default) = default {
+                        self.visit_anon_const(default);
+                    }
                 }
             }
         }
diff --git a/compiler/rustc_save_analysis/src/sig.rs b/compiler/rustc_save_analysis/src/sig.rs
@@ -614,9 +614,13 @@ impl<'hir> Sig for hir::Generics<'hir> {
                 start: offset + text.len(),
                 end: offset + text.len() + param_text.as_str().len(),
             });
-            if let hir::GenericParamKind::Const { ref ty } = param.kind {
+            if let hir::GenericParamKind::Const { ref ty, ref default } = param.kind {
                 param_text.push_str(": ");
                 param_text.push_str(&ty_to_string(&ty));
+                if let Some(ref _default) = default {
+                    // FIXME(const_generics_defaults): push the `default` value here
+                    todo!();
+                }
             }
             if !param.bounds.is_empty() {
                 param_text.push_str(": ");
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
@@ -368,6 +368,7 @@ symbols! {
         const_fn_transmute,
         const_fn_union,
         const_generics,
+        const_generics_defaults,
         const_if_match,
         const_impl_trait,
         const_in_array_repeat_expressions,
diff --git a/compiler/rustc_typeck/src/check/wfcheck.rs b/compiler/rustc_typeck/src/check/wfcheck.rs
@@ -286,9 +286,9 @@ fn check_param_wf(tcx: TyCtxt<'_>, param: &hir::GenericParam<'_>) {
         // We currently only check wf of const params here.
         hir::GenericParamKind::Lifetime { .. } | hir::GenericParamKind::Type { .. } => (),
 
-        // Const parameters are well formed if their
-        // type is structural match.
-        hir::GenericParamKind::Const { ty: hir_ty } => {
+        // Const parameters are well formed if their type is structural match.
+        // FIXME(const_generics_defaults): we also need to check that the `default` is wf.
+        hir::GenericParamKind::Const { ty: hir_ty, default: _ } => {
             let ty = tcx.type_of(tcx.hir().local_def_id(param.hir_id));
 
             let err_ty_str;
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
@@ -607,11 +607,12 @@ impl Clean<GenericParamDef> for hir::GenericParam<'_> {
                     synthetic,
                 },
             ),
-            hir::GenericParamKind::Const { ref ty } => (
+            hir::GenericParamKind::Const { ref ty, default: _ } => (
                 self.name.ident().name,
                 GenericParamDefKind::Const {
                     did: cx.tcx.hir().local_def_id(self.hir_id).to_def_id(),
                     ty: ty.clean(cx),
+                    // FIXME(const_generics_defaults): add `default` field here to the docs
                 },
             ),
         };
diff --git a/src/tools/clippy/clippy_lints/src/utils/ast_utils.rs b/src/tools/clippy/clippy_lints/src/utils/ast_utils.rs
@@ -407,6 +407,10 @@ pub fn eq_use_tree_kind(l: &UseTreeKind, r: &UseTreeKind) -> bool {
     }
 }
 
+pub fn eq_anon_const(l: &AnonConst, r: &AnonConst) -> bool {
+    eq_expr(&l.value, &r.value)
+}
+
 pub fn eq_defaultness(l: Defaultness, r: Defaultness) -> bool {
     matches!(
         (l, r),
@@ -497,7 +501,8 @@ pub fn eq_generic_param(l: &GenericParam, r: &GenericParam) -> bool {
         && match (&l.kind, &r.kind) {
             (Lifetime, Lifetime) => true,
             (Type { default: l }, Type { default: r }) => both(l, r, |l, r| eq_ty(l, r)),
-            (Const { ty: l, kw_span: _ }, Const { ty: r, kw_span: _ }) => eq_ty(l, r),
+            (Const { ty: lt, kw_span: _ , default: ld}, Const { ty: rt, kw_span: _, default: rd }) =>
+                eq_ty(lt, rt) && both(ld, rd, |ld, rd| eq_anon_const(ld, rd)),
             _ => false,
         }
         && over(&l.attrs, &r.attrs, |l, r| eq_attr(l, r))

Original file line number	Diff line number	Diff line change
`@@ -368,6 +368,8 @@ pub enum GenericParamKind {`
`368`	`368`	`ty: P<Ty>,`
`369`	`369`	/// Span of the `const` keyword.
`370`	`370`	`kw_span: Span,`
	`371`	`+ /// Optional default value for the const generic param`
	`372`	`+ default: Option<AnonConst>,`
`371`	`373`	`},`
`372`	`374`	`}`
`373`	`375`
Original file line number	Diff line number	Diff line change
`@@ -790,8 +790,9 @@ pub fn noop_flat_map_generic_param<T: MutVisitor>(`
`790`	`790`	`GenericParamKind::Type { default } => {`
`791`	`791`	`visit_opt(default, \|default\| vis.visit_ty(default));`
`792`	`792`	`}`
`793`		`- GenericParamKind::Const { ty, kw_span: _ } => {`
	`793`	`+ GenericParamKind::Const { ty, kw_span: _, default } => {`
`794`	`794`	`vis.visit_ty(ty);`
	`795`	`+ visit_opt(default, \|default\| vis.visit_anon_const(default));`
`795`	`796`	`}`
`796`	`797`	`}`
`797`	`798`	`smallvec![param]`
Original file line number	Diff line number	Diff line change
`@@ -578,7 +578,12 @@ pub fn walk_generic_param<'a, V: Visitor<'a>>(visitor: &mut V, param: &'a Generi`
`578`	`578`	`match param.kind {`
`579`	`579`	`GenericParamKind::Lifetime => (),`
`580`	`580`	`GenericParamKind::Type { ref default } => walk_list!(visitor, visit_ty, default),`
`581`		`- GenericParamKind::Const { ref ty, .. } => visitor.visit_ty(ty),`
	`581`	`+ GenericParamKind::Const { ref ty, ref default, .. } => {`
	`582`	`+ visitor.visit_ty(ty);`
	`583`	`+ if let Some(default) = default {`
	`584`	`+ visitor.visit_anon_const(default);`
	`585`	`+ }`
	`586`	`+ }`
`582`	`587`	`}`
`583`	`588`	`}`
`584`	`589`
Original file line number	Diff line number	Diff line change
`@@ -2242,13 +2242,14 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {`
`2242`	`2242`
`2243`	`2243`	`(hir::ParamName::Plain(param.ident), kind)`
`2244`	`2244`	`}`
`2245`		`- GenericParamKind::Const { ref ty, kw_span: _ } => {`
	`2245`	`+ GenericParamKind::Const { ref ty, kw_span: _, ref default } => {`
`2246`	`2246`	`let ty = self`
`2247`	`2247`	`.with_anonymous_lifetime_mode(AnonymousLifetimeMode::ReportError, \|this\| {`
`2248`	`2248`	`this.lower_ty(&ty, ImplTraitContext::disallowed())`
`2249`	`2249`	`});`
	`2250`	`+ let default = default.as_ref().map(\|def\| self.lower_anon_const(def));`
`2250`	`2251`
`2251`		`- (hir::ParamName::Plain(param.ident), hir::GenericParamKind::Const { ty })`
	`2252`	`+ (hir::ParamName::Plain(param.ident), hir::GenericParamKind::Const { ty, default })`
`2252`	`2253`	`}`
`2253`	`2254`	`};`
`2254`	`2255`
Original file line number	Diff line number	Diff line change
`@@ -2668,13 +2668,17 @@ impl<'a> State<'a> {`
`2668`	`2668`	`s.print_type(default)`
`2669`	`2669`	`}`
`2670`	`2670`	`}`
`2671`		`- ast::GenericParamKind::Const { ref ty, kw_span: _ } => {`
	`2671`	`+ ast::GenericParamKind::Const { ref ty, kw_span: _, ref default } => {`
`2672`	`2672`	`s.word_space("const");`
`2673`	`2673`	`s.print_ident(param.ident);`
`2674`	`2674`	`s.s.space();`
`2675`	`2675`	`s.word_space(":");`
`2676`	`2676`	`s.print_type(ty);`
`2677`		`- s.print_type_bounds(":", &param.bounds)`
	`2677`	`+ s.print_type_bounds(":", &param.bounds);`
	`2678`	`+ if let Some(ref _default) = default {`
	`2679`	+ // FIXME(const_generics_defaults): print the `default` value here
	`2680`	`+ todo!();`
	`2681`	`+ }`
`2678`	`2682`	`}`
`2679`	`2683`	`}`
`2680`	`2684`	`});`
Original file line number	Diff line number	Diff line change
`@@ -145,7 +145,8 @@ fn inject_impl_of_structural_trait(`
`145`	`145`	`*default = None;`
`146`	`146`	`ast::GenericArg::Type(cx.ty_ident(span, param.ident))`
`147`	`147`	`}`
`148`		`- ast::GenericParamKind::Const { ty: _, kw_span: _ } => {`
	`148`	`+ ast::GenericParamKind::Const { ty: _, kw_span: _, default } => {`
	`149`	`+ *default = None;`
`149`	`150`	`ast::GenericArg::Const(cx.const_ident(span, param.ident))`
`150`	`151`	`}`
`151`	`152`	`})`
Original file line number	Diff line number	Diff line change
`@@ -418,6 +418,8 @@ pub enum GenericParamKind<'hir> {`
`418`	`418`	`},`
`419`	`419`	`Const {`
`420`	`420`	`ty: &'hir Ty<'hir>,`
	`421`	`+ /// Optional default value for the const generic param`
	`422`	`+ default: Option<AnonConst>,`
`421`	`423`	`},`
`422`	`424`	`}`
`423`	`425`
Original file line number	Diff line number	Diff line change
`@@ -877,7 +877,12 @@ pub fn walk_generic_param<'v, V: Visitor<'v>>(visitor: &mut V, param: &'v Generi`
`877`	`877`	`match param.kind {`
`878`	`878`	`GenericParamKind::Lifetime { .. } => {}`
`879`	`879`	`GenericParamKind::Type { ref default, .. } => walk_list!(visitor, visit_ty, default),`
`880`		`- GenericParamKind::Const { ref ty } => visitor.visit_ty(ty),`
	`880`	`+ GenericParamKind::Const { ref ty, ref default } => {`
	`881`	`+ visitor.visit_ty(ty);`
	`882`	`+ if let Some(ref default) = default {`
	`883`	`+ visitor.visit_anon_const(default);`
	`884`	`+ }`
	`885`	`+ }`
`881`	`886`	`}`
`882`	`887`	`walk_list!(visitor, visit_param_bound, param.bounds);`
`883`	`888`	`}`