Document inferred const args (feature(generic_arg_infer))

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

@@ -171,6 +171,26 @@ 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* ([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<const N: usize>() -> [u8; N] {
+    [0; _]
+    //  ^ Infers `N`.
+}
+let _: [u8; 1024] = make_buf::<_>();
+//                             ^ Infers `1024`.
+```
+
+r[items.generics.const.inferred.constraint]
+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
 type or const argument, it is always resolved as a type. Placing the argument

src/paths.md

@@ -91,8 +91,24 @@ 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], 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.
+```
+
+> [!NOTE]
+> An [inferred const] is parsed as an [inferred type] but then semantically treated as a separate kind of [const generic argument].
 
 r[paths.expr.impl-trait-params]
 The synthetic type parameters corresponding to `impl Trait` types are implicit,
@@ -480,10 +496,13 @@ mod without { // crate::without
 [`Self` scope]: names/scopes.md#self-scope
 [`use`]: items/use-declarations.md
 [attributes]: attributes.md
+[const generic argument]: items.generics.const.argument
 [enumeration]: items/enumerations.md
 [expressions]: expressions.md
 [extern prelude]: names/preludes.md#extern-prelude
 [implementation]: items/implementations.md
+[inferred const]: items.generics.const.inferred
+[inferred type]: type.inferred
 [macro transcribers]: macros-by-example.md
 [macros]: macros.md
 [mbe]: macros-by-example.md