Improve the generic_arg_infer docs

Syntactically, the inferred const is an expression.  Semantically,
though, it's a new kind of const generic argument.  Let's add the
necessary language in various places to make this all clear, and let's
fix the grammar for `GenericArgsConst` correspondingly.

Author: traviscross

src/expressions/array-expr.md

@@ -35,7 +35,7 @@ r[expr.array.length-operand]
 The expression after the `;` is called the *length operand*.
 
 r[expr.array.length-restriction]
-It must have type `usize` and be a [constant expression], such as a [literal] or a [constant item].
+The length operand must either be an [inferred const] or be a [constant expression] of type `usize` (e.g. a [literal] or a [constant item]).
 
 r[expr.array.repeat-behavior]
 An array expression of this form creates an array with the length of the value of the length operand with each element being a copy of the repeat operand.
@@ -113,6 +113,7 @@ The array index expression can be implemented for types other than arrays and sl
 [array]: ../types/array.md
 [constant expression]: ../const_eval.md#constant-expressions
 [constant item]: ../items/constant-items.md
+[inferred const]: items.generics.const.inferred
 [literal]: ../tokens.md#literals
 [memory location]: ../expressions.md#place-expressions-and-value-expressions
 [panic]: ../panic.md

src/items/generics.md

@@ -172,17 +172,24 @@ fn example() {
 ```
 
 r[items.generics.const.inferred]
-Where a const argument is expected, an `_` (optionally surrounding by any number of matching parentheses), called the "inferred const", can be used instead. This asks the compiler to infer the const argument if possible based on surrounding information.
+Where a const argument is expected, an `_` (optionally surrounding by any number of matching parentheses), called the *inferred const* ([grammar][InferredConst], [path rules][paths.expr.complex-const-params]), can be used instead. This asks the compiler to infer the const argument if possible based on surrounding information.
 
 ```rust
-fn make_buf() -> [u8; 1024] {
+fn make_buf<const N: usize>() -> [u8; N] {
     [0x1; _]
-    //    ^ Infers `1024`.
+    //    ^ Infers `N`.
 }
+let _: [u8; 1024] = make_buf::<_>();
+//                             ^ Infers `1024`.
 ```
 
 r[items.generics.const.inferred.constraint]
-It cannot be used in item signatures.
+The inferred const cannot be used in item signatures.
+
+```rust,compile_fail
+fn f<const N: usize>(x: [u8; N]) -> [u8; _] { x }
+//                                       ^ ERROR
+```
 
 r[items.generics.const.type-ambiguity]
 When there is ambiguity if a generic argument could be resolved as either a

src/paths.md

@@ -62,10 +62,15 @@ GenericArg ->
 
 GenericArgsConst ->
       BlockExpression
+    | InferredConst
     | LiteralExpression
     | `-` LiteralExpression
     | SimplePathSegment
 
+InferredConst ->
+    | `(` InferredConst `)`
+    | `_`
+
 GenericArgsBinding ->
     IDENTIFIER GenericArgs? `=` Type
 
@@ -91,8 +96,21 @@ The order of generic arguments is restricted to lifetime arguments, then type
 arguments, then const arguments, then equality constraints.
 
 r[paths.expr.complex-const-params]
-Const arguments must be surrounded by braces unless they are a
-[literal] or a single segment path.
+Const arguments must be surrounded by braces unless they are a [literal], an [inferred const] ([grammar][InferredConst]), or a single segment path.
+
+```rust
+mod m {
+    pub const C: usize = 42;
+}
+const C: usize = m::C;
+fn f<const N: usize>() -> [u8; N] { [0; N] }
+
+let _ = f::<42>(); // Literal.
+let _: [_; 42] = f::<_>(); // Inferred const.
+let _: [_; 42] = f::<(((_)))>(); // Inferred const.
+let _ = f::<C>(); // Single segment path.
+let _ = f::<{ m::C }>(); // Multi-segment path must be braced.
+```
 
 r[paths.expr.impl-trait-params]
 The synthetic type parameters corresponding to `impl Trait` types are implicit,
@@ -484,6 +502,7 @@ mod without { // crate::without
 [expressions]: expressions.md
 [extern prelude]: names/preludes.md#extern-prelude
 [implementation]: items/implementations.md
+[inferred const]: items.generics.const.inferred
 [macro transcribers]: macros-by-example.md
 [macros]: macros.md
 [mbe]: macros-by-example.md